Jak wykryć zakończenie przewijania UIScrollView

UIScrollViewDelegate ma dwie metody delegata scrollViewDidScroll:a scrollViewDidEndScrollingAnimation:jednak żadna z nich nie powiedzieć podczas przewijania została zakończona. scrollViewDidScrollinformuje tylko o tym, że widok przewijania został przewinięty, a nie o zakończeniu przewijania.

Druga metoda scrollViewDidEndScrollingAnimationwydaje się uruchamiać tylko wtedy, gdy programowo przesuniesz widok przewijania, a nie, gdy użytkownik przewija.

Czy ktoś zna schemat wykrywania zakończenia przewijania widoku przewijania?

- (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView {
    [self stoppedScrolling];
}

- (void)scrollViewDidEndDragging:(UIScrollView *)scrollView willDecelerate:(BOOL)decelerate {
    if (!decelerate) {
        [self stoppedScrolling];
    }
}

- (void)stoppedScrolling {
    // ...
}

Do 320 implementacje są o wiele lepiej - tutaj jest to poprawka, aby uzyskać spójne start / końce zwoju.

-(void)scrollViewDidScroll:(UIScrollView *)sender 
{   
[NSObject cancelPreviousPerformRequestsWithTarget:self];
    //ensure that the end of scroll is fired.
    [self performSelector:@selector(scrollViewDidEndScrollingAnimation:) withObject:sender afterDelay:0.3]; 

...
}

-(void)scrollViewDidEndScrollingAnimation:(UIScrollView *)scrollView
{
    [NSObject cancelPreviousPerformRequestsWithTarget:self];
...
}

Myślę, że scrollViewDidEndDecelerating to ten, którego chcesz. Jego opcjonalna metoda UIScrollViewDelegates:

- (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView

Informuje delegata, że ​​widok przewijania zakończył spowolnienie ruchu przewijania.

Dokumentacja UIScrollViewDelegate

W przypadku wszystkich zwojów związanych z przeciąganiem interakcji będzie to wystarczające:

- (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView {
    _isScrolling = NO;
}

- (void)scrollViewDidEndDragging:(UIScrollView *)scrollView willDecelerate:(BOOL)decelerate {
    if (!decelerate) {
        _isScrolling = NO;
    }
}

Teraz, jeśli przewijanie wynika z programowego setContentOffset / scrollRectVisible (z animated= YES lub oczywiście wiesz, kiedy przewijanie się zakończyło):

 - (void)scrollViewDidEndScrollingAnimation {
     _isScrolling = NO;
}

Jeśli przyczyną przewijania jest coś innego (np. Otwarcie lub zamknięcie klawiatury), wydaje się, że będziesz musiał wykryć zdarzenie za pomocą hackowania, ponieważ również scrollViewDidEndScrollingAnimationnie jest przydatne.

Przypadek widoku przewijania PAGINATED :

Ponieważ, jak sądzę, Apple stosuje krzywą przyspieszenia, jest scrollViewDidEndDeceleratingwywoływany przy każdym oporze, więc nie ma potrzeby używania scrollViewDidEndDraggingw tym przypadku.

Zostało to opisane w niektórych innych odpowiedziach, ale oto (w kodzie), jak połączyć scrollViewDidEndDeceleratingi scrollViewDidEndDragging:willDeceleratewykonać jakąś operację po zakończeniu przewijania:

- (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView
{
    [self stoppedScrolling];
}

- (void)scrollViewDidEndDragging:(UIScrollView *)scrollView 
                  willDecelerate:(BOOL)decelerate
{
    if (!decelerate) {
        [self stoppedScrolling];
    }
}

- (void)stoppedScrolling
{
    // done, do whatever
}

Dopiero co znalazłem to pytanie, które jest prawie takie samo, jak zadałem: Skąd dokładnie wiedzieć, kiedy zatrzymało się przewijanie UIScrollView?

Chociaż didEndDecelerating działa podczas przewijania, panoramowanie ze zwolnieniem stacjonarnym nie jest rejestrowane.

W końcu znalazłem rozwiązanie. didEndDragging ma parametr WillDecelerate, który jest fałszywy w przypadku zwolnienia stacjonarnego.

Sprawdzając! Decelerate w DidEndDragging, w połączeniu z didEndDecelerating, otrzymujesz obie sytuacje, które kończą przewijanie.

Jeśli interesujesz się Rx, możesz rozszerzyć UIScrollView w następujący sposób:

import RxSwift
import RxCocoa

extension Reactive where Base: UIScrollView {
    public var didEndScrolling: ControlEvent<Void> {
        let source = Observable
            .merge([base.rx.didEndDragging.map { !$0 },
                    base.rx.didEndDecelerating.mapTo(true)])
            .filter { $0 }
            .mapTo(())
        return ControlEvent(events: source)
    }
}

co pozwoli ci zrobić tak po prostu:

scrollView.rx.didEndScrolling.subscribe(onNext: {
    // Do what needs to be done here
})

Uwzględni to zarówno przeciąganie, jak i zwalnianie.

func scrollViewDidEndDecelerating(_ scrollView: UIScrollView) {
    scrollingFinished(scrollView: scrollView)
}

func scrollViewDidEndDragging(_ scrollView: UIScrollView, willDecelerate decelerate: Bool) {
    if decelerate {
        //didEndDecelerating will be called for sure
        return
    }
    else {
        scrollingFinished(scrollView: scrollView)
    }
}

func scrollingFinished(scrollView: UIScrollView) {
   // Your code
}

Wypróbowałem odpowiedź Ashley Smart i zadziałała jak urok. Oto inny pomysł, z użyciem tylko scrollViewDidScroll

-(void)scrollViewDidScroll:(UIScrollView *)sender 
{   
    if(self.scrollView_Result.contentOffset.x == self.scrollView_Result.frame.size.width)       {
    // You have reached page 1
    }
}

Miałem tylko dwie strony, więc zadziałało. Jeśli jednak masz więcej niż jedną stronę, może to być problematyczne (możesz sprawdzić, czy bieżące przesunięcie jest wielokrotnością szerokości, ale wtedy nie wiesz, czy użytkownik zatrzymał się na drugiej stronie, czy jest w drodze na trzecią lub więcej)

Szybka wersja zaakceptowanej odpowiedzi:

func scrollViewDidScroll(scrollView: UIScrollView) {
     // example code
}
func scrollViewDidEndDragging(scrollView: UIScrollView, willDecelerate decelerate: Bool) {
        // example code
}
func scrollViewDidEndZooming(scrollView: UIScrollView, withView view: UIView!, atScale scale: CGFloat) {
      // example code
}

Jeśli ktoś potrzebuje, oto odpowiedź Ashley Smart w języku Swift

func scrollViewDidScroll(_ scrollView: UIScrollView) {
        NSObject.cancelPreviousPerformRequests(withTarget: self)
        perform(#selector(UIScrollViewDelegate.scrollViewDidEndScrollingAnimation), with: nil, afterDelay: 0.3)
    ...
}

func scrollViewDidEndScrollingAnimation(_ scrollView: UIScrollView) {
        NSObject.cancelPreviousPerformRequests(withTarget: self)
    ...
}

Właśnie opracowane rozwiązanie do wykrywania przewijania w całej aplikacji: https://gist.github.com/k06a/731654e3168277fb1fd0e64abc7d899e

Opiera się na idei śledzenia zmian trybów runloop. I wykonaj bloki co najmniej po 0,2 sekundy po przewinięciu.

Oto podstawowa idea śledzenia zmian trybów runloop iOS10 +:

- (void)tick {
    [[NSRunLoop mainRunLoop] performInModes:@[ UITrackingRunLoopMode ] block:^{
        [self tock];
    }];
}

- (void)tock {
    self.runLoopModeWasUITrackingAgain = YES;
    [[NSRunLoop mainRunLoop] performInModes:@[ NSDefaultRunLoopMode ] block:^{
        [self tick];
    }];
}

I rozwiązanie dla małych celów wdrożeniowych, takich jak iOS2 +:

- (void)tick {
    [[NSRunLoop mainRunLoop] performSelector:@selector(tock) target:self argument:nil order:0 modes:@[ UITrackingRunLoopMode ]];
}

- (void)tock {
    self.runLoopModeWasUITrackingAgain = YES;
    [[NSRunLoop mainRunLoop] performSelector:@selector(tick) target:self argument:nil order:0 modes:@[ NSDefaultRunLoopMode ]];
}

Podsumowując (i dla początkujących). To nie jest takie bolesne. Po prostu dodaj protokół, a następnie dodaj funkcje potrzebne do wykrywania.

W widoku (klasie), który zawiera UIScrolView, dodaj protokół, a następnie dodaj wszystkie funkcje z tego miejsca do swojego widoku (klasy).

// --------------------------------
// In the "h" file:
// --------------------------------
@interface myViewClass : UIViewController  <UIScrollViewDelegate> // <-- Adding the protocol here

// Scroll view
@property (nonatomic, retain) UIScrollView *myScrollView;
@property (nonatomic, assign) BOOL isScrolling;

// Protocol functions
- (void)scrollViewWillBeginDragging:(UIScrollView *)scrollView
- (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView;
- (void)scrollViewDidEndDragging:(UIScrollView *)scrollView;


// --------------------------------
// In the "m" file:
// --------------------------------
@implementation BlockerViewController

- (void)viewDidLoad {
    CGRect scrollRect = self.view.frame; // Same size as this view
    self.myScrollView = [[UIScrollView alloc] initWithFrame:scrollRect];
    self.myScrollView.delegate = self;
    self.myScrollView.contentSize = CGSizeMake(scrollRect.size.width, scrollRect.size.height);
    self.myScrollView.contentInset = UIEdgeInsetsMake(0.0,22.0,0.0,22.0);
    // Allow dragging button to display outside the boundaries
    self.myScrollView.clipsToBounds = NO;
    // Prevent buttons from activating scroller:
    self.myScrollView.canCancelContentTouches = NO;
    self.myScrollView.delaysContentTouches = NO;
    [self.myScrollView setBackgroundColor:[UIColor darkGrayColor]];
    [self.view addSubview:self.myScrollView];

    // Add stuff to scrollview
    UIImage *myImage = [UIImage imageNamed:@"foo.png"];
    [self.myScrollView addSubview:myImage];
}

// Protocol functions
- (void)scrollViewWillBeginDragging:(UIScrollView *)scrollView {
    NSLog(@"start drag");
    _isScrolling = YES;
}

- (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView {
    NSLog(@"end decel");
    _isScrolling = NO;
}

- (void)scrollViewDidEndDragging:(UIScrollView *)scrollView willDecelerate:(BOOL)decelerate {
    NSLog(@"end dragging");
    if (!decelerate) {
       _isScrolling = NO;
    }
}

// All of the available functions are here:
// https://developer.apple.com/library/ios/documentation/UIKit/Reference/UIScrollViewDelegate_Protocol/Reference/UIScrollViewDelegate.html

Miałem przypadek stukania i przeciągania akcji i odkryłem, że przeciąganie wywoływało scrollViewDidEndDecelerating

Zmiana przesunięcia ręcznie za pomocą kodu ([_scrollView setContentOffset: contentOffset animated: YES];) wywoływała scrollViewDidEndScrollingAnimation.

//This delegate method is called when the dragging scrolling happens, but no when the     tapping
- (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView
{
    //do whatever you want to happen when the scroll is done
}

//This delegate method is called when the tapping scrolling happens, but no when the  dragging
-(void)scrollViewDidEndScrollingAnimation:(UIScrollView *)scrollView
{
     //do whatever you want to happen when the scroll is done
}

Alternatywą byłoby użycie, scrollViewWillEndDragging:withVelocity:targetContentOffsetktóre jest wywoływane za każdym razem, gdy użytkownik podniesie palec i zawiera docelowe przesunięcie zawartości, w którym przewijanie się zatrzyma. Użycie tego przesunięcia zawartości w scrollViewDidScroll:prawidłowo identyfikuje, kiedy widok przewijania przestał się przewijać.

private var targetY: CGFloat?
public func scrollViewWillEndDragging(_ scrollView: UIScrollView,
                                      withVelocity velocity: CGPoint,
                                      targetContentOffset: UnsafeMutablePointer<CGPoint>) {
       targetY = targetContentOffset.pointee.y
}
public func scrollViewDidScroll(_ scrollView: UIScrollView) {
    if (scrollView.contentOffset.y == targetY) {
        print("finished scrolling")
    }

UIScrollview ma metodę delegata

- (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView

Dodaj poniższe wiersze kodu w metodzie delegata

- (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView
{
CGSize scrollview_content=scrollView.contentSize;
CGPoint scrollview_offset=scrollView.contentOffset;
CGFloat size=scrollview_content.width;
CGFloat x=scrollview_offset.x;
if ((size-self.view.frame.size.width)==x) {
    //You have reached last page
}
}

Istnieje metoda, UIScrollViewDelegatektórej można użyć do wykrycia (lub lepiej powiedzieć „przewidywanie”), kiedy przewijanie naprawdę się zakończyło:

func scrollViewWillEndDragging(_ scrollView: UIScrollView, withVelocity velocity: CGPoint, targetContentOffset: UnsafeMutablePointer<CGPoint>)

z UIScrollViewDelegatektórych mogą być stosowane do wykrywania (lub lepiej powiedzieć „przewidzieć”) podczas przewijania naprawdę skończony.

W moim przypadku użyłem go z przewijaniem poziomym w następujący sposób (w Swift 3 ):

func scrollViewWillEndDragging(_ scrollView: UIScrollView, withVelocity velocity: CGPoint, targetContentOffset: UnsafeMutablePointer<CGPoint>) {
    perform(#selector(self.actionOnFinishedScrolling), with: nil, afterDelay: Double(velocity.x))
}
func actionOnFinishedScrolling() {
    print("scrolling is finished")
    // do what you need
}

Korzysta z logiki Ashley Smart i jest przekształcany w Swift 4.0 i nowsze.

    func scrollViewDidScroll(_ scrollView: UIScrollView) {
         NSObject.cancelPreviousPerformRequests(withTarget: self)
        perform(#selector(UIScrollViewDelegate.scrollViewDidEndScrollingAnimation(_:)), with: scrollView, afterDelay: 0.3)
    }

    func scrollViewDidEndScrollingAnimation(_ scrollView: UIScrollView) {
        NSObject.cancelPreviousPerformRequests(withTarget: self)
    }

Powyższa logika rozwiązuje problemy, takie jak przewijanie przez użytkownika widoku tabeli. Bez logiki, kiedy przewiniesz widok tabeli, didEndzostanie wywołany, ale nic nie wykona. Obecnie używa go w roku 2020.

W niektórych wcześniejszych wersjach iOS (takich jak iOS 9, 10) scrollViewDidEndDeceleratingnie zostanie wyzwolony, jeśli scrollView zostanie nagle zatrzymany przez dotknięcie.

Ale w obecnej wersji (iOS 13) scrollViewDidEndDeceleratingna pewno zostanie uruchomiony (o ile wiem).

Jeśli więc Twoja aplikacja była skierowana również do wcześniejszych wersji, możesz potrzebować obejścia takiego jak to, o którym wspomina Ashley Smart, lub możesz użyć następującego.

    func scrollViewDidEndDecelerating(_ scrollView: UIScrollView) {
        if !scrollView.isTracking, !scrollView.isDragging, !scrollView.isDecelerating { // 1
            scrollViewDidEndScrolling(scrollView)
        }
    }

    func scrollViewDidEndDragging(_ scrollView: UIScrollView, willDecelerate decelerate: Bool) {
        if !decelerate, scrollView.isTracking, !scrollView.isDragging, !scrollView.isDecelerating { // 2
            scrollViewDidEndScrolling(scrollView)
        }
    }

    func scrollViewDidEndScrolling(_ scrollView: UIScrollView) {
        // Do something here
    }

Wyjaśnienie

UIScrollView zostanie zatrzymany na trzy sposoby:
- szybko przewijany i zatrzymywany samoczynnie
- szybko przewijany i zatrzymywany przez dotknięcie palcem (jak hamulec awaryjny)
- powoli przewijany i zatrzymywany

Pierwszą można wykryć scrollViewDidEndDeceleratingi innymi podobnymi metodami, podczas gdy dwie pozostałe nie.

Na szczęście UIScrollViewma trzy stany, których możemy użyć do ich identyfikacji, które są używane w dwóch wierszach opatrzonych komentarzem „// 1” i „// 2”.