SwiftUI Toggle how to distinguish changing value by UI action vs changing programatically

If i have a toggle, which updates its state from external async load but also by user intput, how can i differentiate those two? eg. to perform a special action on user action

    Group {
        Toggle(isOn: $on) {
            EmptyView()
        }
    }
    .onChange(of: on) { newValue in
        was "on" changed by user or onAppear async update?
    }
    .onAppear {
        async update on
    }

PS: this is mostly for macOS, and there the tapGesture on Toggle doesn't work

SwiftUI doesn't provide a built-in way to distinguish whether a state change was triggered by a user interaction or a programmatic change, such as an asynchronous update. However, you can use a workaround by creating a separate variable that acts as a flag for programmatic changes.

Here is a code example:

@State private var on = false
@State private var isProgrammaticChange = false

Group {
    Toggle(isOn: $on) {
        EmptyView()
    }
}
.onChange(of: on) { newValue in
    if isProgrammaticChange {
        // The change was made programmatically.
        // Do nothing or handle as needed.
        isProgrammaticChange = false // Reset the flag
    } else {
        // The change was made by the user.
        // Perform the special action here.
    }
}
.onAppear {
    DispatchQueue.main.asyncAfter(deadline: .now() + 1) { // Simulate async load
        isProgrammaticChange = true
        on.toggle()
    }
}

In this code, isProgrammaticChange is a flag to mark when a change is made programmatically. Before we change the on state programmatically, we set isProgrammaticChange to true. In the .onChange(of: on) modifier, we can check the isProgrammaticChange flag to see whether the change was made programmatically or by the user.

Note that DispatchQueue.main.asyncAfter(deadline: .now() + 1) is used to simulate an asynchronous update in the .onAppear modifier. You would replace this with your own asynchronous code, making sure to set isProgrammaticChange to true right before making the change to on.

Finally, remember to reset the isProgrammaticChange flag back to false after handling the programmatic change to ensure that subsequent user-triggered changes are handled correctly.

Other Solution (Combine)

Or you can use another solution using Combine that is cleaner than using a flag. You could create a PassthroughSubject that emits events whenever the toggle is switched programmatically.

import Combine
import SwiftUI

class ViewModel: ObservableObject {
    @Published var isOn: Bool = false
    let programmaticallyToggled = PassthroughSubject<Void, Never>()
}

struct ContentView: View {
    @StateObject private var viewModel = ViewModel()

    var body: some View {
        Group {
            Toggle(isOn: $viewModel.isOn) {
                EmptyView()
            }
        }
        .onChange(of: viewModel.isOn) { newValue in
            if !viewModel.programmaticallyToggled.hasAnyObservers {
                // Change was made by user, do your special action here.
            }
        }
        .onAppear {
            DispatchQueue.main.asyncAfter(deadline: .now() + 1) { // Simulate async load
                viewModel.programmaticallyToggled.send()
                viewModel.isOn.toggle()
            }
        }
        .onReceive(viewModel.programmaticallyToggled) { _ in
            // Do nothing, but this is necessary to ensure that hasAnyObservers returns true when programmatic changes occur.
        }
    }
}

In this example, we create a ViewModel class that contains the isOn state as well as a PassthroughSubject named programmaticallyToggled. In the onChange modifier of the Toggle, we check whether the programmaticallyToggled subject has any subscribers. If it doesn't, then the change was made by the user.

The onReceive modifier is necessary because a PassthroughSubject will only have subscribers while it is in the process of sending an event. Adding an onReceive modifier to the view ensures that hasAnyObservers will return true whenever programmaticallyToggled sends an event.

This method avoids the need for a separate flag variable, but it does require understanding of Combine, which is Apple's reactive programming framework. If you're not familiar with Combine, the first solution with the flag variable might be easier to understand.

If you want a side effect for use the user actions, you can use a custom wrapper Binding:

struct ContentView: View {
    @State private var on: Bool = false
    
    var userManagedOn: Binding<Bool> {
        .init {
            return on
        } set: { newValue in
            print("Side effect")
            on = newValue
        }
    }
    
    var body: some View {
        VStack {
            Group {
                Toggle(isOn: userManagedOn) {
                    EmptyView()
                }
            }
        }
        .padding()
        .onAppear {
            Task { @MainActor in
                try? await Task.sleep(nanoseconds: NSEC_PER_SEC)
                on.toggle()
            }
        }
    }
}