Al descartar un controlador de vista modal mediante dismissViewController, existe la opción de proporcionar un bloque de finalización. ¿Existe un equivalente similar para popViewController?

El argumento de la finalización es bastante útil. Por ejemplo, puedo usarlo para retrasar la eliminación de una fila de una vista de tabla hasta que el modal esté fuera de la pantalla, lo que permite al usuario ver la animación de la fila. Al regresar de un controlador de vista empujado, me gustaría tener la misma oportunidad.

He intentado colocarlo popViewControlleren un UIViewbloque de animación, donde tengo acceso a un bloque de finalización. Sin embargo, esto produce algunos efectos secundarios no deseados en la vista que se abre.

Si no existe tal método disponible, ¿cuáles son algunas soluciones?

Sé que se aceptó una respuesta hace más de dos años, sin embargo, esta respuesta está incompleta.

No hay forma de hacer lo que quiere de inmediato

Esto es técnicamente correcto porque la UINavigationControllerAPI no ofrece ninguna opción para esto. Sin embargo, al usar el marco CoreAnimation, es posible agregar un bloque de finalización a la animación subyacente:

[CATransaction begin];
[CATransaction setCompletionBlock:^{
    // handle completion here
}];

[self.navigationController popViewControllerAnimated:YES];

[CATransaction commit];

El bloque de finalización se llamará tan pronto como popViewControllerAnimated:finalice la animación utilizada por . Esta funcionalidad está disponible desde iOS 4.

Para la versión SWIFT de iOS9 : funciona como un encanto (no había probado para versiones anteriores). Basado en esta respuesta

extension UINavigationController {    
    func pushViewController(viewController: UIViewController, animated: Bool, completion: () -> ()) {
        pushViewController(viewController, animated: animated)

        if let coordinator = transitionCoordinator() where animated {
            coordinator.animateAlongsideTransition(nil) { _ in
                completion()
            }
        } else {
            completion()
        }
    }

    func popViewController(animated: Bool, completion: () -> ()) {
        popViewControllerAnimated(animated)

        if let coordinator = transitionCoordinator() where animated {
            coordinator.animateAlongsideTransition(nil) { _ in
                completion()
            }
        } else {
            completion()
        }
    }
}

Hice una Swiftversión con extensiones con la respuesta de @JorisKluivers .

Esto llamará un cierre de finalización después de que se complete la animación para ambos pushy pop.

extension UINavigationController {
    func popViewControllerWithHandler(completion: ()->()) {
        CATransaction.begin()
        CATransaction.setCompletionBlock(completion)
        self.popViewControllerAnimated(true)
        CATransaction.commit()
    }
    func pushViewController(viewController: UIViewController, completion: ()->()) {
        CATransaction.begin()
        CATransaction.setCompletionBlock(completion)
        self.pushViewController(viewController, animated: true)
        CATransaction.commit()
    }
}

SWIFT 4.1

extension UINavigationController {
func pushToViewController(_ viewController: UIViewController, animated:Bool = true, completion: @escaping ()->()) {
    CATransaction.begin()
    CATransaction.setCompletionBlock(completion)
    self.pushViewController(viewController, animated: animated)
    CATransaction.commit()
}

func popViewController(animated:Bool = true, completion: @escaping ()->()) {
    CATransaction.begin()
    CATransaction.setCompletionBlock(completion)
    self.popViewController(animated: animated)
    CATransaction.commit()
}

func popToViewController(_ viewController: UIViewController, animated:Bool = true, completion: @escaping ()->()) {
    CATransaction.begin()
    CATransaction.setCompletionBlock(completion)
    self.popToViewController(viewController, animated: animated)
    CATransaction.commit()
}

func popToRootViewController(animated:Bool = true, completion: @escaping ()->()) {
    CATransaction.begin()
    CATransaction.setCompletionBlock(completion)
    self.popToRootViewController(animated: animated)
    CATransaction.commit()
}
}

Tuve el mismo problema. Y como tuve que usarlo en múltiples ocasiones, y dentro de cadenas de bloques de finalización, creé esta solución genérica en una subclase UINavigationController:

- (void) navigationController:(UINavigationController *) navigationController didShowViewController:(UIViewController *) viewController animated:(BOOL) animated {
    if (_completion) {
        dispatch_async(dispatch_get_main_queue(),
        ^{
            _completion();
            _completion = nil;
         });
    }
}

- (UIViewController *) popViewControllerAnimated:(BOOL) animated completion:(void (^)()) completion {
    _completion = completion;
    return [super popViewControllerAnimated:animated];
}

Asumiendo

@interface NavigationController : UINavigationController <UINavigationControllerDelegate>

y

@implementation NavigationController {
    void (^_completion)();
}

y

- (id) initWithRootViewController:(UIViewController *) rootViewController {
    self = [super initWithRootViewController:rootViewController];
    if (self) {
        self.delegate = self;
    }
    return self;
}

No hay forma de hacer lo que desea de inmediato. es decir, no existe un método con un bloque de finalización para extraer un controlador de vista de una pila de navegación.

Lo que haría es poner la lógica viewDidAppear. Se llamará cuando la vista haya terminado de aparecer en pantalla. Se llamará para todos los escenarios diferentes del controlador de vista que aparecen, pero eso debería estar bien.

O puede usar el UINavigationControllerDelegatemétodo navigationController:didShowViewController:animated:para hacer algo similar. Esto se llama cuando el controlador de navegación ha terminado de presionar o abrir un controlador de vista.

Trabajar con o sin animación correctamente, y también incluye popToRootViewController:

 // updated for Swift 3.0
extension UINavigationController {

  private func doAfterAnimatingTransition(animated: Bool, completion: @escaping (() -> Void)) {
    if let coordinator = transitionCoordinator, animated {
      coordinator.animate(alongsideTransition: nil, completion: { _ in
        completion()
      })
    } else {
      DispatchQueue.main.async {
        completion()
      }
    }
  }

  func pushViewController(viewController: UIViewController, animated: Bool, completion: @escaping (() ->     Void)) {
    pushViewController(viewController, animated: animated)
    doAfterAnimatingTransition(animated: animated, completion: completion)
  }

  func popViewController(animated: Bool, completion: @escaping (() -> Void)) {
    popViewController(animated: animated)
    doAfterAnimatingTransition(animated: animated, completion: completion)
  }

  func popToRootViewController(animated: Bool, completion: @escaping (() -> Void)) {
    popToRootViewController(animated: animated)
    doAfterAnimatingTransition(animated: animated, completion: completion)
  }
}

Basado en la respuesta de @ HotJard, cuando todo lo que quieres son solo un par de líneas de código. Rapido y Facil.

Rápido 4 :

_ = self.navigationController?.popViewController(animated: true)
self.navigationController?.transitionCoordinator.animate(alongsideTransition: nil) { _ in
    doWhatIWantAfterContollerHasPopped()
}

Para 2018 ...

si tienes esto ...

    navigationController?.popViewController(animated: false)
    // I want this to happen next, help! ->
    nextStep()

y desea agregar una finalización ...

    CATransaction.begin()
    navigationController?.popViewController(animated: true)
    CATransaction.setCompletionBlock({ [weak self] in
       self?.nextStep() })
    CATransaction.commit()

Es así de simple.

Consejo útil ...

Es el mismo trato para la popToViewControllerllamada práctica .

Una cosa típica es que tiene una pila de incorporación de un trillón de pantallas. Cuando finalmente haya terminado, regrese a la pantalla "base" y, finalmente, inicie la aplicación.

Por lo tanto, en la pantalla "base", para "retroceder completamente", popToViewController(self

func onboardingStackFinallyComplete() {
    
    CATransaction.begin()
    navigationController?.popToViewController(self, animated: false)
    CATransaction.setCompletionBlock({ [weak self] in
        guard let self = self else { return }
        .. actually launch the main part of the app
    })
    CATransaction.commit()
}

El bloque de finalización se llama después de llamar al método viewDidDisappear en el controlador de vista presentado, por lo que poner código en el método viewDidDisappear del controlador de vista emergente debería funcionar igual que un bloque de finalización.

Respuesta rápida 3, gracias a esta respuesta: https://stackoverflow.com/a/28232570/3412567

    //MARK:UINavigationController Extension
extension UINavigationController {
    //Same function as "popViewController", but allow us to know when this function ends
    func popViewControllerWithHandler(completion: @escaping ()->()) {
        CATransaction.begin()
        CATransaction.setCompletionBlock(completion)
        self.popViewController(animated: true)
        CATransaction.commit()
    }
    func pushViewController(viewController: UIViewController, completion: @escaping ()->()) {
        CATransaction.begin()
        CATransaction.setCompletionBlock(completion)
        self.pushViewController(viewController, animated: true)
        CATransaction.commit()
    }
}

Versión Swift 4 con el parámetro viewController opcional para pasar a uno específico.

extension UINavigationController {
    func pushViewController(viewController: UIViewController, animated: 
        Bool, completion: @escaping () -> ()) {

        pushViewController(viewController, animated: animated)

        if let coordinator = transitionCoordinator, animated {
            coordinator.animate(alongsideTransition: nil) { _ in
                completion()
            }
        } else {
            completion()
        }
}

func popViewController(viewController: UIViewController? = nil, 
    animated: Bool, completion: @escaping () -> ()) {
        if let viewController = viewController {
            popToViewController(viewController, animated: animated)
        } else {
            popViewController(animated: animated)
        }

        if let coordinator = transitionCoordinator, animated {
            coordinator.animate(alongsideTransition: nil) { _ in
                completion()
            }
        } else {
            completion()
        }
    }
}

Se limpió la versión de Swift 4 basada en esta respuesta .

extension UINavigationController {
    func pushViewController(_ viewController: UIViewController, animated: Bool, completion: @escaping () -> Void) {
        self.pushViewController(viewController, animated: animated)
        self.callCompletion(animated: animated, completion: completion)
    }

    func popViewController(animated: Bool, completion: @escaping () -> Void) -> UIViewController? {
        let viewController = self.popViewController(animated: animated)
        self.callCompletion(animated: animated, completion: completion)
        return viewController
    }

    private func callCompletion(animated: Bool, completion: @escaping () -> Void) {
        if animated, let coordinator = self.transitionCoordinator {
            coordinator.animate(alongsideTransition: nil) { _ in
                completion()
            }
        } else {
            completion()
        }
    }
}

Hay un pod llamado UINavigationControllerWithCompletionBlock que agrega soporte para un bloque de finalización al presionar y hacer estallar un UINavigationController.

2020 Swift 5.1 forma

Esta solución garantiza que la finalización se ejecute después de que popViewController esté completamente terminado. Puede probarlo haciendo otra operación en NavigationController al finalizar: en todas las demás soluciones anteriores, UINavigationController todavía está ocupado con la operación popViewController y no responde.

public class NavigationController: UINavigationController, UINavigationControllerDelegate
{
    private var completion: (() -> Void)?

    override init(rootViewController: UIViewController) {
        super.init(rootViewController: rootViewController)
        delegate = self
    }

    required init?(coder aDecoder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }

    public override func navigationController(_ navigationController: UINavigationController, didShow viewController: UIViewController, animated: Bool)
    {
        if self.completion != nil {
            DispatchQueue.main.async(execute: {
                self.completion?()
                self.completion = nil
            })
        }
    }

    func popViewController(animated: Bool, completion: @escaping () -> Void) -> UIViewController?
    {
        self.completion = completion
        return super.popViewController(animated: animated)
    }
}

Solo para completar, he creado una categoría Objective-C lista para usar:

// UINavigationController+CompletionBlock.h

#import <UIKit/UIKit.h>

@interface UINavigationController (CompletionBlock)

- (UIViewController *)popViewControllerAnimated:(BOOL)animated completion:(void (^)()) completion;

@end

// UINavigationController+CompletionBlock.m

#import "UINavigationController+CompletionBlock.h"

@implementation UINavigationController (CompletionBlock)

- (UIViewController *)popViewControllerAnimated:(BOOL)animated completion:(void (^)()) completion {
    [CATransaction begin];
    [CATransaction setCompletionBlock:^{
        completion();
    }];

    UIViewController *vc = [self popViewControllerAnimated:animated];

    [CATransaction commit];

    return vc;
}

@end

Logré exactamente esto con precisión usando un bloque. Quería que mi controlador de resultados obtenido mostrara la fila que fue agregada por la vista modal, solo una vez que haya abandonado completamente la pantalla, para que el usuario pueda ver el cambio. En preparación para segue, que es responsable de mostrar el controlador de vista modal, configuro el bloque que quiero ejecutar cuando el modal desaparece. Y en el controlador de vista modal anulo viewDidDissapear y luego llamo al bloque. Simplemente comienzo las actualizaciones cuando va a aparecer el modal y finalizo las actualizaciones cuando desaparece, pero eso se debe a que estoy usando un NSFetchedResultsController, sin embargo, puede hacer lo que quiera dentro del bloque.

-(void)prepareForSegue:(UIStoryboardSegue *)segue sender:(id)sender{
    if([segue.identifier isEqualToString:@"addPassword"]){

        UINavigationController* nav = (UINavigationController*)segue.destinationViewController;
        AddPasswordViewController* v = (AddPasswordViewController*)nav.topViewController;

...

        // makes row appear after modal is away.
        [self.tableView beginUpdates];
        [v setViewDidDissapear:^(BOOL animated) {
            [self.tableView endUpdates];
        }];
    }
}

@interface AddPasswordViewController : UITableViewController<UITextFieldDelegate>

...

@property (nonatomic, copy, nullable) void (^viewDidDissapear)(BOOL animated);

@end

@implementation AddPasswordViewController{

...

-(void)viewDidDisappear:(BOOL)animated{
    [super viewDidDisappear:animated];
    if(self.viewDidDissapear){
        self.viewDidDissapear(animated);
    }
}

@end

Use la siguiente extensión en su código: (Swift 4)

import UIKit

extension UINavigationController {

    func popViewController(animated: Bool = true, completion: @escaping () -> Void) {
        CATransaction.begin()
        CATransaction.setCompletionBlock(completion)
        popViewController(animated: animated)
        CATransaction.commit()
    }

    func pushViewController(_ viewController: UIViewController, animated: Bool = true, completion: @escaping () -> Void) {
        CATransaction.begin()
        CATransaction.setCompletionBlock(completion)
        pushViewController(viewController, animated: animated)
        CATransaction.commit()
    }
}