iOS7 UISwitch sein Ereignis ValueChanged: Kontinuierliches Aufrufen ist dieser Fehler oder was ..?

Bearbeiten

Es ist jetzt behoben ios7.1
Nehmen Sie keine Änderungen vor, um das Problem zu beheben.

Edit2

Anscheinend tritt das gleiche Problem in iOS 8.0 und 8.1 erneut auf

Edit3

Es ist jetzt behoben ios9.2
Nehmen Sie keine Änderungen vor, um das Problem zu beheben.

Hallo, heute habe ich in UISwitch'sEvent ValueChanged:Calling gesehen, wie continuously ich Onzu Offoder Offzu Ein gewechselt habe und mein Finger sich immer noch auf der rechten und linken Seite bewegt hat. Ich habe mit NSLog ein GIF-Bild erstellt, um es klarer zu machen.

Meine Methode mit Wertänderung ist:

- (IBAction)changeSwitch:(id)sender{

    if([sender isOn]){
        NSLog(@"Switch is ON");
    } else{
        NSLog(@"Switch is OFF");
    }
    
}

iOS6 funktioniert der gleiche Code von Switch wie erwartet:

kann mir also jemand vorschlagen, der nur einmal seinen zustand ein- oder ausschaltet. oder ist das ein fehler oder was ..?

AKTUALISIEREN

Hier ist meine Demo davon:

programmatisch UISwitch hinzufügen

von XIB Hinzufügen von UISwitch

Bitte beachten Sie den folgenden Code:

-(void)viewDidLoad
{
    [super viewDidLoad];    
    UISwitch *mySwitch = [[UISwitch alloc] initWithFrame:CGRectMake(130, 235, 0, 0)];    
    [mySwitch addTarget:self action:@selector(changeSwitch:) forControlEvents:UIControlEventValueChanged];
    [self.view addSubview:mySwitch];
}

- (void)changeSwitch:(id)sender{
    if([sender isOn]){
        NSLog(@"Switch is ON");
    } else{
        NSLog(@"Switch is OFF");
    }
}

Gleicher Fehler hier. Ich glaube, ich habe eine einfache Problemumgehung gefunden. Wir müssen nur eine neue verwenden BOOL, die den vorherigen Status der UISwitchund eine if-Anweisung in unserer IBAction(Wert geändert ausgelöst) speichert , um zu überprüfen, ob sich der Wert des Schalters tatsächlich geändert hat.

previousValue = FALSE;

[...]

-(IBAction)mySwitchIBAction {
    if(mySwitch.on == previousValue)
        return;
    // resetting the new switch value to the flag
    previousValue = mySwitch.on;
 }

Keine seltsamen Verhaltensweisen mehr. Ich hoffe es hilft.

Mit der Eigenschaft UISwitch's' können Sie .selectedsicherstellen, dass Ihr Code nur einmal ausgeführt wird, wenn sich der tatsächliche Wert ändert. Ich denke, dies ist eine großartige Lösung, da keine Unterklassen oder neuen Eigenschaften hinzugefügt werden müssen.

 //Add action for `ValueChanged`
 [toggleSwitch addTarget:self action:@selector(switchTwisted:) forControlEvents:UIControlEventValueChanged];

 //Handle action
- (void)switchTwisted:(UISwitch *)twistedSwitch
{
    if ([twistedSwitch isOn] && (![twistedSwitch isSelected]))
    {
        [twistedSwitch setSelected:YES];

        //Write code for SwitchON Action
    }
    else if ((![twistedSwitch isOn]) && [twistedSwitch isSelected])
    {
        [twistedSwitch setSelected:NO];

        //Write code for SwitchOFF Action
    }
}

Und hier ist es in Swift:

func doToggle(switch: UISwitch) {
    if switch.on && !switch.selected {
        switch.selected = true
        // SWITCH ACTUALLY CHANGED -- DO SOMETHING HERE
    } else {
        switch.selected = false
    }
}

Wenn Sie in Ihrer App so viele Switches verwenden, besteht ein Problem darin, den Code an allen Stellen zu ändern, an denen die Aktionsmethode von UISwitch definiert ist. Sie können benutzerdefinierte Switches vornehmen und die Ereignisse nur behandeln, wenn sich der Wert ändert.

CustomSwitch.h

#import <UIKit/UIKit.h>

@interface Care4TodayCustomSwitch : UISwitch
@end

CustomSwitch.m

@interface CustomSwitch(){
    BOOL previousValue;
}
@end

@implementation CustomSwitch



- (id)initWithFrame:(CGRect)frame
{
    self = [super initWithFrame:frame];
    if (self) {
        // Initialization code
        previousValue = self.isOn;
    }
    return self;
}


-(void)awakeFromNib{
    [super awakeFromNib];
    previousValue = self.isOn;
    self.exclusiveTouch = YES;
}


- (void)setOn:(BOOL)on animated:(BOOL)animated{

    [super setOn:on animated:animated];
    previousValue = on;
}


-(void)sendAction:(SEL)action to:(id)target forEvent:(UIEvent *)event{

    if(previousValue != self.isOn){
        for (id targetForEvent in [self allTargets]) {
            for (id actionForEvent in [self actionsForTarget:targetForEvent forControlEvent:UIControlEventValueChanged]) {
                [super sendAction:NSSelectorFromString(actionForEvent) to:targetForEvent forEvent:event];
            }
        }
        previousValue = self.isOn;
    }
}

@end

Wir ignorieren Ereignisse, wenn der Wert mit dem geänderten Wert übereinstimmt. Fügen Sie CustomSwitch in die gesamte Klasse von UISwitch im Storyboard ein. Dadurch wird das Problem behoben und das Ziel nur einmal aufgerufen, wenn sich der Wert ändert

Ich habe viele Benutzer, die mit dem gleichen Problem konfrontiert sind. Vielleicht ist dies ein Fehler, UISwitchalso habe ich gerade eine vorübergehende Lösung gefunden. Ich habe einen gitHubBenutzer gefunden KLSwitch, der dies für den Moment verwendet. Ich hoffe, Apple wird dies im nächsten Update von xCode beheben: -

https://github.com/KieranLafferty/KLSwitch

Wenn Sie nicht sofort auf die Wertänderung des Schalters reagieren müssen, kann Folgendes eine Lösung sein:

- (IBAction)switchChanged:(id)sender {
  [NSObject cancelPreviousPerformRequestsWithTarget:self];

  if ([switch isOn]) {
      [self performSelector:@selector(enable) withObject:nil afterDelay:2];
  } else {
      [self performSelector:@selector(disable) withObject:nil afterDelay:2];
  }
}

Dieses Problem ist ab iOS 9.3 Beta immer noch vorhanden. Wenn es Ihnen nichts ausmacht, dass der Benutzer nicht außerhalb des Schalters ziehen kann, funktioniert das .TouchUpInsideeher, als dass es .ValueChangedzuverlässig funktioniert.

Ich habe immer noch das gleiche Problem in iOS 9.2

Ich habe Lösung und posiere, weil es anderen helfen könnte

1. Erstellen Sie eine Zählvariable, um zu verfolgen, wie oft die Methode aufgerufen wurde

   int switchMethodCallCount = 0;

2. Speichern Sie den Bool-Wert für den Schalterwert

   bool isSwitchOn = No;

3. Führen Sie in der Wertänderungsmethode von Switch die Wunschaktion nur für den ersten Methodenaufruf aus. Wenn der Schaltwert erneut geändert wird, setzen Sie den Zählwert und den Wert der Bool-Variablen auf den Standardwert

   - (IBAction)frontCameraCaptureSwitchToggle:(id)sender {
   
   
   
   //This method will be called multiple times if user drags on Switch,
   //But desire action should be perform only on first call of this method
   
   
   //1. 'switchMethodCallCount' variable is maintain to check number of calles to method,
   //2. Action is peform for 'switchMethodCallCount = 1' i.e first call
   //3. When switch value change to another state, 'switchMethodCallCount' is reset and desire action perform
   
   switchMethodCallCount++ ;
   
   //NSLog(@"Count --> %d", switchMethodCallCount);
   
   if (switchMethodCallCount == 1) {
   
   //NSLog(@"**************Perform Acction******************");
   
   isSwitchOn = frontCameraCaptureSwitch.on
   
   [self doStuff];
   
   }
   else
   {
   //NSLog(@"Do not perform");
   
   
   if (frontCameraCaptureSwitch.on != isSwitchOn) {
   
       switchMethodCallCount = 0;
   
       isSwitchOn = frontCameraCaptureSwitch.on
   
       //NSLog(@"Count again start");
   
       //call value change method again 
       [self frontCameraCaptureSwitchToggle:frontCameraCaptureSwitch];
   
   
       }
   }
   
   
   }

Dieses Problem plagt mich, wenn ich den Schalter mit anderen Verhaltensweisen verbinde. Im Allgemeinen gehen die Dinge nicht gerne von onnach on. Hier ist meine einfache Lösung:

@interface MyView : UIView
@parameter (assign) BOOL lastSwitchState;
@parameter (strong) IBOutlet UISwitch *mySwitch;
@end

@implementation MyView

// Standard stuff goes here

- (void)mySetupMethodThatsCalledWhenever
{
    [self.mySwitch addTarget:self action:@selector(switchToggled:) forControlEvents:UIControlEventValueChanged];
}

- (void)switchToggled:(UISwitch *)someSwitch
{
    BOOL newSwitchState = self.mySwitch.on;
    if (newSwitchState == self.lastSwitchState)
    {
        return;
    }
    self.lastSwitchState = newSwitchState;

    // Do your thing
}

Stellen Sie nur sicher, dass Sie dies auch self.lastSwitchStatejedes Mal einstellen, wenn Sie manuell ändern mySwitch.on! :) :)

Diese Art von Problem wird häufig durch ValueChanged verursacht. Sie müssen die Taste nicht drücken, damit die Funktion ausgeführt wird. Es ist kein Touch-Event. Jedes Mal, wenn Sie den Schalter programmgesteuert auf Ein / Aus stellen, ändert sich der Wert und die IBAction-Funktion wird erneut aufgerufen.

@RoNiT hatte die richtige Antwort mit:

Schnell

func doToggle(switch: UISwitch) {
    if switch.on && !switch.selected {
        switch.selected = true
        // SWITCH ACTUALLY CHANGED -- DO SOMETHING HERE
    } else {
        switch.selected = false
    }
}

DispatchQueue.main.async {
        self.mySwitch.setOn(false, animated: true)
    }

Dies funktioniert einwandfrei und ruft die Auswahlfunktion nicht erneut auf.

Das hat bei mir funktioniert.

DispatchQueue.main.asyncAfter(deadline: DispatchTime.now()){
    self.switch.isOn = true
}