Comment puis-je déclencher une action lorsqu'une bascule swiftUI () est basculée?

Tout d'abord, savez-vous réellement que les notifications KVO supplémentaires pour station.isDisplayed posent un problème? Rencontrez-vous des problèmes de performances? Sinon, ne vous inquiétez pas.

Si vous rencontrez des problèmes de performance et vous avez établi qu'ils sont dus à trop station.isDisplayed notifications KVO, la prochaine chose à faire est d' éliminer les notifications KVO inutiles. Pour ce faire, passez aux notifications KVO manuelles.

Ajoutez cette méthode à la définition de classe de la station :

@objc dynamic var isDisplayed = false {
    willSet {
        if isDisplayed != newValue { willChangeValue(for: \.isDisplayed) }
    }
    didSet {
        if isDisplayed != oldValue { didChangeValue(for: \.isDisplayed) }
    }
}

Et utilisez les observateurs willSet et didSet de Swift pour notifier manuellement les observateurs KVO, mais uniquement si la valeur change:

@objc class var automaticallyNotifiesObserversOfIsDisplayed: Bool { return false }

Vous pouvez essayer ceci (c'est une solution de contournement):

func toggleAction(state: String, index: Int) -> String {
    print("The switch no. \(index) is \(state)")
    return ""
}

Et en dessous, créez une fonction comme celle-ci:

@State var isChecked: Bool = true
@State var index: Int = 0
Toggle(isOn: self.$isChecked) {
        Text("This is a Switch")
        if (self.isChecked) {
            Text("\(self.toggleAction(state: "Checked", index: index))")
        } else {
            CustomAlertView()
            Text("\(self.toggleAction(state: "Unchecked", index: index))")
        }
    }

Je pense que ça va

struct ToggleModel {
    var isWifiOpen: Bool = true {
        willSet {
            print("wifi status will change")
        }
    }
}

struct ToggleDemo: View {
    @State var model = ToggleModel()

    var body: some View {
        Toggle(isOn: $model.isWifiOpen) {
            HStack {
                Image(systemName: "wifi")
                Text("wifi")
            }
       }.accentColor(.pink)
       .padding()
   }
}

class PWSStore : ObservableObject {
    ...
    var station: PWS
    @Published var isDisplayed = true {
        willSet {
            PWSStore.shared.toggleIsDisplayed(self.station)
        }
    }   
}

struct PWSDetailView : View {
    @ObservedObject var station = PWSStore.shared
    ...

    var body: some View {
        ...
        Toggle(isOn: $isDisplayed) { Text("Wetterstation anzeigen") }
        ...
    }   
}
Demo here https://youtu.be/N8pL7uTjEFM

J'ai trouvé une solution plus simple, utilisez simplement onTapGesture: D

Toggle(isOn: $stateChange) {
  Text("...")
}
.onTapGesture {
  // Any actions here.
}

Voici mon approche. J'étais confronté au même problème, mais j'ai plutôt décidé d'envelopper UISwitch d'UIKit dans une nouvelle classe conforme à UIViewRepresentable.

struct PWSDetailView : View {
    @State var isDisplayed: Bool = false
    @ObservedObject var station: PWS
    ...

    var body: some View {
        ...

        UIToggle(isOn: $isDisplayed) { isOn in
            //Do something here with the bool if you want
            //or use "_ in" instead, e.g.
            if isOn != station.isDisplayed {
                PWSStore.shared.toggleIsDisplayed(station)
            }
        }
        ...
    }   
}

Et puis il est utilisé comme ceci:

import SwiftUI

final class UIToggle: UIViewRepresentable {

    @Binding var isOn: Bool
    var changedAction: (Bool) -> Void

    init(isOn: Binding<Bool>, changedAction: @escaping (Bool) -> Void) {
        self._isOn = isOn
        self.changedAction = changedAction
    }

    func makeUIView(context: Context) -> UISwitch {
        let uiSwitch = UISwitch()
        return uiSwitch
    }

    func updateUIView(_ uiView: UISwitch, context: Context) {
        uiView.isOn = isOn
        uiView.addTarget(self, action: #selector(switchHasChanged(_:)), for: .valueChanged)

    }

    @objc func switchHasChanged(_ sender: UISwitch) {
        self.isOn = sender.isOn
        changedAction(sender.isOn)
    }
}

Basé sur la réponse de @Legolas Wang.

Lorsque vous masquez l'étiquette d'origine de la bascule, vous pouvez attacher le tapGesture uniquement à la bascule elle-même

HStack {
    Text("...")
    Spacer()
    Toggle("", isOn: $stateChange)
        .labelsHidden()
        .onTapGesture {
            // Any actions here.
        }
     }

L'approche la plus propre à mon avis est d'utiliser une liaison personnalisée. Avec cela, vous avez un contrôle total sur le moment où la bascule doit basculer

import SwiftUI

struct ToggleDemo: View {
    @State private var isToggled = false

    var body: some View {

        let binding = Binding(
            get: { self.isToggled },
            set: {
                potentialAsyncFunction($0)
            }
        )

        func potentialAsyncFunction(_ newState: Bool) {
            //something async
            self.isToggled = newState
        }

        return Toggle("My state", isOn: binding)
   }
}

Voici une version sans utiliser tapGesture.

@State private var isDisplayed = false
Toggle("", isOn: $isDisplayed)
   .onReceive([self.isDisplayed].publisher.first()) { (value) in
        print("New value is: \(value)")           
   }

Juste au cas où vous ne voudriez pas utiliser de fonctions supplémentaires, gâtez la structure - utilisez des états et utilisez-les où vous le souhaitez. Je sais que ce n'est pas une réponse à 100% pour le déclencheur d'événement, cependant, l'état sera enregistré et utilisé de la manière la plus simple.

struct PWSDetailView : View {


@State private var isToggle1  = false
@State private var isToggle2  = false

var body: some View {

    ZStack{

        List {
            Button(action: {
                print("\(self.isToggle1)")
                print("\(self.isToggle2)")

            }){
                Text("Settings")
                    .padding(10)
            }

                HStack {

                   Toggle(isOn: $isToggle1){
                      Text("Music")
                   }
                 }

                HStack {

                   Toggle(isOn: $isToggle1){
                      Text("Music")
                   }
                 }
        }
    }
}
}

Disponible pour XCode 12

import SwiftUI

struct ToggleView: View {
    
    @State var isActive: Bool = false
    
    var body: some View {
        Toggle(isOn: $isActive) { Text(isActive ? "Active" : "InActive") }
            .padding()
            .toggleStyle(SwitchToggleStyle(tint: .accentColor))
    }
}

Voici comment je code:

Toggle("Enabled", isOn: $isDisplayed.didSet { val in
        //Action here        
})

Code mis à jour (Xcode 12, iOS14):

Toggle("Title", isOn: $isDisplayed)
.onReceive([self.isDisplayed].publisher.first()) { (value) in
    //Action code here
}

Voici une approche plus générique que vous pouvez appliquer à n'importe quelle Binding pour presque toutes les View intégrées telles que Pickers, Textfields, Toggle.

@State var isOn: Bool = false
Toggle("Toggle Title", isOn: $isOn.didSet { (state) in
   print(state)
})

Et l'utilisation est simplement;

extension Binding {
    func didSet(execute: @escaping (Value) -> Void) -> Binding {
        return Binding(
            get: {
                return self.wrappedValue
            },
            set: {
                self.wrappedValue = $0
                execute($0)
            }
        )
    }
}

SwiftUI 2

Si vous utilisez SwiftUI 2 / iOS 14, vous pouvez utiliser onChange :

struct ContentView: View {
    @State private var isDisplayed = false
    
    var body: some View {
        Toggle("", isOn: $isDisplayed)
            .onChange(of: isDisplayed) { value in
                // action...
                print(value)
            }
    }
}