Wie erkenne ich das Ereignis, wenn der Benutzer das Ziehen eines Schiebereglers beendet hat?

Wenn Sie zwischen dem Ziehen keine Daten benötigen, sollten Sie einfach Folgendes festlegen:

[mySlider setContinuous: NO];

Auf diese Weise erhalten Sie nur dann ein valueChangedEreignis, wenn der Benutzer den Schieberegler nicht mehr bewegt.

Swift 5 Version:

mySlider.isContinuous = false

Sie können für UIControlEventValueChanged eine Aktion hinzufügen, die zwei Parameter akzeptiert: Absender und Ereignis:

[slider addTarget:self action:@selector(onSliderValChanged:forEvent:) forControlEvents:UIControlEventValueChanged]

Überprüfen Sie dann die Phase des Touch-Objekts in Ihrem Handler:

- (void)onSliderValChanged:(UISlider*)slider forEvent:(UIEvent*)event {     
    UITouch *touchEvent = [[event allTouches] anyObject];
    switch (touchEvent.phase) {     
        case UITouchPhaseBegan:
            // handle drag began
            break;
        case UITouchPhaseMoved:
            // handle drag moved
            break;
        case UITouchPhaseEnded:
            // handle drag ended
            break;
        default:
            break;
    }
}

Schnelle 4 & 5

slider.addTarget(self, action: #selector(onSliderValChanged(slider:event:)), for: .valueChanged)

@objc func onSliderValChanged(slider: UISlider, event: UIEvent) {
    if let touchEvent = event.allTouches?.first {
        switch touchEvent.phase {
        case .began:
            // handle drag began
        case .moved:
            // handle drag moved
        case .ended:
            // handle drag ended
        default:
            break
        }
    }
}

Beachten Sie, dass Sie im Interface Builder beim Hinzufügen einer Aktion auch die Option haben, der Aktion sowohl Absender- als auch Ereignisparameter hinzuzufügen.

Ich verwende die Benachrichtigungen "Touch Up Inside" und "Touch Up Outside".

Interface Builder:

Verbinden Sie beide Benachrichtigungen im Interface Builder mit Ihrer Empfangsmethode. Die Methode könnte folgendermaßen aussehen:

- (IBAction)lengthSliderDidEndSliding:(id)sender {
    NSLog(@"Slider did end sliding... Do your stuff here");
}

In Code:

Wenn Sie es programmgesteuert verkabeln möchten, haben Sie so etwas in Ihrem viewWillAppear-Aufruf (oder wo immer es Ihnen passt):

[_mySlider addTarget:self
              action:@selector(sliderDidEndSliding:) 
    forControlEvents:(UIControlEventTouchUpInside | UIControlEventTouchUpOutside)];

Die Empfangsmethode würde folgendermaßen aussehen:

- (void)sliderDidEndSliding:(NSNotification *)notification {
     NSLog(@"Slider did end sliding... Do your stuff here");
}

Da UISlideres sich um eine Unterklasse von handelt UIControl, können Sie ein Ziel und eine Aktion für seine festlegen UIControlEventTouchUpInside.

Wenn Sie es in Code tun möchten, sieht es so aus:

[self.slider addTarget:self action:@selector(dragEndedForSlider:)
    forControlEvents:UIControlEventTouchUpInside];

Das wird Ihnen eine dragEndedForSlider:Nachricht senden, wenn die Berührung endet.

Wenn Sie dies in Ihrer Feder tun möchten, können Sie bei gedrückter Ctrl-Taste auf Ihren Schieberegler klicken, um das Verbindungsmenü aufzurufen, und dann vom Sockel „Touch Up Inside“ zum Zielobjekt ziehen.

Sie sollten auch ein Ziel und eine Aktion für UIControlEventTouchUpOutsideund für hinzufügen UIControlEventTouchCancel.

Swift 5 und Swift 4

1. Ziel für touchUpInsideund touchUpOutsideEreignisse hinzufügen. Sie können dies entweder programmgesteuert oder über das Storyboard tun. So machen Sie es programmatisch

   slider.addTarget(self, action: #selector(sliderDidEndSliding), for: [.touchUpInside, .touchUpOutside])

2. Schreiben Sie Ihre Funktion, um das Ende des Schiebereglers zu bewältigen

   func sliderDidEndSliding() {
       print("end sliding")
   }

Sie können verwenden:

- (void)addTarget:(id)target action:(SEL)action 
                   forControlEvents:(UIControlEvents)controlEvents  

um zu erkennen, wann die Ereignisse touchDown und touchUp in UISlider auftreten

Ich denke, Sie brauchen das Kontrollereignis UIControlEventTouchUpInside.

Schnelle 3 Antwort

Ich hatte das gleiche Problem und brachte es schließlich zum Laufen, also hilft es vielleicht jemandem. Verbinden Sie Ihren_Slider mit 'Wert geändert' im Storyboard und wenn der Schieberegler bewegt wird, wird "Schieberegler berührt" aktiviert und wenn "Schieberegler freigegeben" losgelassen wird.

@IBAction func your_Slider(_ sender: UISlider) {
    if (yourSlider.isTracking) {
        print("Slider Touched")
    } else {
        print("Slider Released")
    }
}

Verbinden Touch Up InsideundValue Changed

Swift 3.1

Manchmal möchten Sie, dass die Drag-Ereignisse des Schiebereglers kontinuierlich ausgelöst werden, haben jedoch die Möglichkeit, unterschiedlichen Code auszuführen, je nachdem, ob der Slider noch gezogen wird oder gerade nicht mehr gezogen wurde.

Zu diesem Zweck habe ich die obige Antwort von Andy erweitert, die die isTrackingEigenschaft des Schiebereglers nutzt . Ich musste zwei Zustände aufzeichnen: sliderHasFinishedTrackingund sliderLastStoredValue.

Mein Code richtig:

• Löst beim Starten des Ziehens keine Aktion aus

• Löst die Aktion aus, wenn der Benutzer den Schieberegler nur mit einem einzigen Tastendruck anstößt (was bedeutet, dass dies isTrackingverbleibt false).

class SliderExample: UIViewController {
  var slider: UISlider = UISlider()
  var sliderHasFinishedTracking: Bool = true
  var sliderLastStoredValue: Float!

  override func loadView() {
    super.loadView()

    slider.minimumValue = 100.0
    slider.maximumValue = 200.0
    slider.isContinuous = true
    slider.value = 100.0
    self.sliderLastStoredValue = slider.value
    slider.addTarget(self, action: #selector(respondToSlideEvents), for: .valueChanged)
    // add your slider to the view however you like
  }

  func respondToSlideEvents(sender: UISlider) {
    let currentValue: Float = Float(sender.value)
    print("Event fired. Current value for slider: \(currentValue)%.")

    if(slider.isTracking) {
      self.sliderHasFinishedTracking = false
      print("Action while the slider is being dragged ⏳")
    } else {
      if(self.sliderHasFinishedTracking && currentValue == self.sliderLastStoredValue){
        print("Slider has finished tracking and its value hasn't changed, " +
              "yet event was fired anyway. 🤷") // No need to take action.
      } else {
        self.sliderHasFinishedTracking = true
        print("Action upon slider drag/tap finishing ⌛️")
      }
    }

    self.sliderLastStoredValue = currentValue
  }
}

In Swift 4 können Sie diese Funktion verwenden

1 Frist-Schritt: - Hinzufügen des Ziels im Schieberegler

self.distanceSlider.addTarget(self, action: #selector(self.sliderDidEndSliding(notification:)), for: ([.touchUpInside,.touchUpOutside]))

2 Zweiter Schritt: - Erstellen Sie eine Funktion

@objc func sliderDidEndSliding(notification: NSNotification)
{
   print("Hello-->\(distanceSlider.value)")
}

Möglicherweise sollten Sie ein Ziel für UIControlEventTouchUpInside 、 UIControlEventTouchUpOutside 、 UIControlEventTouchCancel-Ereignisse hinzufügen.

Ich bin zuvor auf dasselbe Problem gestoßen , weil ich kein Ziel für das UIControlEventTouchCancel- Ereignis hinzugefügt habe .

Ich hatte kürzlich ein ähnliches Problem. Folgendes habe ich in Swift getan:

    theSlider.continuous = false;

Der Code, der diesen fortlaufenden Wert enthält, lautet:

public var continuous: Bool // if set, value change events are generated
    // any time the value changes due to dragging. default = YES

Der Standardwert scheint JA (wahr) zu sein. Wenn Sie es auf false setzen, tun Sie genau das, was Sie wollen.

Versuchen Sie es so

customSlider.minimumValue = 0.0;
    customSlider.maximumValue = 10.0;
[customSlider addTarget:self action:@selector(changeSlider:) forControlEvents:UIControlEventValueChanged];


-(void)changeSlider:(id)sender{
    UISlider *slider=(UISlider *)sender;
    float sliderValue=(float)(slider.value );
NSLog(@"sliderValue = %f",sliderValue);
}

RxSwift:

self.slider.rx.controlEvent([.touchUpInside, .touchUpOutside])
    .bind(to: self.viewModel.endSlidingSlider)
    .disposed(by: self.disposeBag)

Erstellen Sie eine Aktion und einen Ausgang für den Schieberegler (oder geben Sie den Absender von der Aktion in UISlider ein), und deaktivieren Sie in der Benutzeroberfläche das Kontrollkästchen Kontinuierliche Updates. Auf diese Weise erhalten wir den Schiebereglerwert nur, wenn der Schieberegler nicht mehr gezogen wird.

@IBAction func actionSlider(_ sender: Any) {
   let value = sliderSpeed.value.rounded()
}