Cómo detectar cuando un UIScrollView ha terminado de desplazarse

Las implementaciones 320 son mucho mejores - aquí hay un parche para obtener un inicio/final consistente del scroll.

-(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];
...
}

Creo que scrollViewDidEndDecelerating es lo que quieres. Su Uiscrollviewdelegata el método opcional:

- (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView

Le dice al delegado que la vista de desplazamiento ha terminado de desacelerar el movimiento de desplazamiento.

UIScrollViewDelegate documentation

Para todos los pergaminos relacionados con las interacciones de arrastre, esto será suficiente:

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

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

Ahora, si su desplazamiento se debe a un setContentOffset/scrollRectVisible programático (con animated = SÍ o obviamente sabe cuándo se termina el desplazamiento):

 - (void)scrollViewDidEndScrollingAnimation {
     _isScrolling = NO;
}

Si su desplazamiento se debe a algo más (como apertura o cierre del teclado), parece que tendrá que detectar el evento con un hackeo porque scrollViewDidEndScrollingAnimation tampoco es útil.

El caso de un desplazamiento PAGINADO vista:

Debido a que, supongo, Apple aplica una curva de aceleración, scrollViewDidEndDecelerating recibe una llamada para cada arrastre, por lo que no es necesario usar scrollViewDidEndDragging en este caso.

Esto se ha descrito en algunas de las otras respuestas, pero aquí está (en código) cómo combinar scrollViewDidEndDecelerating y scrollViewDidEndDragging:willDecelerate para realizar alguna operación cuando el desplazamiento haya terminado:

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

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

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

Acabo de encontrar esta pregunta, que es más o menos la misma que hice: ¿Cómo saber exactamente cuándo se ha detenido el desplazamiento de UIScrollView?

Aunque didEndDecelerating funciona cuando se desplaza, la panorámica con la liberación estacionaria no se registra.

Finalmente encontré una solución. didEndDragging tiene un parámetro WillDecelerate, que es false en la situación de liberación estacionaria.

Comprobando para !decelerar en DidEndDragging, combinado con didEndDecelerating, obtienes ambas situaciones que son el final del desplazamiento.

He probado la respuesta de Ashley Smart y funcionó como un encanto. Aquí hay otra idea, usando solo scrollViewDidScroll

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

Solo tenía dos páginas, así que funcionó para mí. Sin embargo, si tiene más de una página, podría ser problemático (puede verificar si el desplazamiento actual es un múltiplo del ancho, pero entonces no sabría si el usuario se detuvo en la 2a página o está en camino a la 3a o más)

Versión rápida de la respuesta aceptada:

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
}

Acaba de desarrollar una solución para detectar cuando el desplazamiento finaliza en toda la aplicación: https://gist.github.com/k06a/731654e3168277fb1fd0e64abc7d899e

Se basa en la idea de rastrear los cambios de los modos de runloop. Y realizar bloques al menos después de 0,2 segundos después del desplazamiento.

Esta es la idea central para rastrear los cambios en los modos de runloop de iOS10+:

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

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

Y solución para objetivos de despliegue bajo como 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 ]];
}

Para recapitular (y para novatos). No es tan doloroso. Simplemente agregue el protocolo, luego agregue las funciones que necesita para la detección.

En la vista (clase) que contiene UIScrolView, agregue el protocolo, luego agregue cualquier función de aquí a su vista (clase).

// --------------------------------
// 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

Tuve un caso de tocar y arrastrar acciones y me enteré de que el arrastre estaba llamando scrollViewDidEndDecelerating

Y el cambio de desplazamiento manual con código ([_scrollView setContentOffset:contentOffset animated:YES];) estaba llamando 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
}

Si alguien lo necesita, aquí está Ashley Smart answer en 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)
    ...
}

Una alternativa sería usar scrollViewWillEndDragging:withVelocity:targetContentOffset que se llama cada vez que el usuario levanta el dedo y contiene el desplazamiento de contenido objetivo donde se detendrá el desplazamiento. El uso de este desplazamiento de contenido en scrollViewDidScroll: identifica correctamente cuándo la vista de desplazamiento ha dejado de desplazarse.

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 tiene un método delegado

- (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView

Agregue las siguientes líneas de código en el método delegado

- (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
}
}

Hay un método de UIScrollViewDelegate que se puede utilizar para detectar (o mejor decir 'predecir') cuando el desplazamiento realmente ha terminado:

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

De UIScrollViewDelegate que se puede utilizar para detectar (o mejor decir 'predecir') cuando el desplazamiento realmente ha terminado.

En mi caso lo utilicé con desplazamiento horizontal de la siguiente manera (en 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
}