Quando si elimina un controller di visualizzazione modale utilizzando dismissViewController, è possibile fornire un blocco di completamento. Esiste un equivalente simile per popViewController?

L'argomento del completamento è abbastanza utile. Ad esempio, posso usarlo per tenere a bada la rimozione di una riga da una tableview fino a quando il modal non è fuori dallo schermo, consentendo all'utente di vedere l'animazione della riga. Quando torno da un controller di visualizzazione pushed, vorrei la stessa opportunità.

Ho provato a inserire popViewControllerun UIViewblocco di animazione, dove ho accesso a un blocco di completamento. Tuttavia, questo produce alcuni effetti collaterali indesiderati sulla vista visualizzata.

Se non è disponibile un metodo di questo tipo, quali sono le soluzioni alternative?

So che una risposta è stata accettata più di due anni fa, tuttavia questa risposta è incompleta.

Non c'è modo di fare quello che vuoi fuori dagli schemi

Questo è tecnicamente corretto perché l' UINavigationControllerAPI non offre alcuna opzione per questo. Tuttavia, utilizzando il framework CoreAnimation è possibile aggiungere un blocco di completamento all'animazione sottostante:

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

[self.navigationController popViewControllerAnimated:YES];

[CATransaction commit];

Il blocco di completamento verrà chiamato non appena l'animazione utilizzata da popViewControllerAnimated:termina. Questa funzionalità è disponibile da iOS 4.

Per la versione SWIFT di iOS9 - funziona come un fascino (non era stato testato per le versioni precedenti). Basato su questa risposta

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

Ho realizzato una Swiftversione con estensioni con risposta @JorisKluivers .

Ciò richiederà una chiusura del completamento dopo che l'animazione è stata eseguita per entrambi pushe 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()
}
}

Ho avuto lo stesso problema. E poiché ho dovuto usarlo in più occasioni e all'interno di catene di blocchi di completamento, ho creato questa soluzione generica in una sottoclasse 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];
}

assumendo

@interface NavigationController : UINavigationController <UINavigationControllerDelegate>

e

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

e

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

Non c'è modo di fare quello che vuoi fuori dagli schemi. cioè non esiste un metodo con un blocco di completamento per estrarre un controller di visualizzazione da uno stack di navigazione.

Quello che farei è inserire la logica viewDidAppear. Verrà richiamato quando la visualizzazione avrà terminato di essere visualizzata sullo schermo. Verrà chiamato per tutti i diversi scenari del controller di visualizzazione che appare, ma dovrebbe andare bene.

Oppure potresti usare il UINavigationControllerDelegatemetodo navigationController:didShowViewController:animated:per fare una cosa simile. Viene chiamato quando il controller di navigazione ha terminato di premere o aprire un controller di visualizzazione.

Lavorare correttamente con o senza animazione e include anche 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)
  }
}

Basato sulla risposta di @ HotJard, quando tutto ciò che desideri sono solo un paio di righe di codice. Facile e veloce.

Swift 4 :

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

Per il 2018 ...

se hai questo ...

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

e vuoi aggiungere un completamento ...

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

è così semplice.

Suggerimento pratico ...

È lo stesso affare per il pratico popToViewController chiamata a .

Una cosa tipica è che hai uno stack di onboarding di un milione di schermi. Quando finalmente hai finito, torni alla schermata di "base", quindi apri l'app.

Quindi nella schermata "base", per tornare indietro "fino in fondo", 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()
}

Il blocco di completamento viene chiamato dopo che il metodo viewDidDisappear è stato chiamato sul controller della vista presentato, quindi l'inserimento del codice nel metodo viewDidDisappear del controller della vista estratta dovrebbe funzionare come un blocco di completamento.

Risposta rapida 3, grazie a questa risposta: 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()
    }
}

Versione di Swift 4 con parametro viewController opzionale per visualizzarne uno specifico.

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

Versione di Swift 4 pulita in base a questa risposta .

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

C'è un pod chiamato UINavigationControllerWithCompletionBlock che aggiunge il supporto per un blocco di completamento sia quando si spinge che si apre su un UINavigationController.

2020 Swift 5.1 modo

Questa soluzione garantisce che il completamento venga eseguito dopo che popViewController è completamente terminato. Puoi testarlo eseguendo un'altra operazione sul NavigationController al termine: in tutte le altre soluzioni sopra UINavigationController è ancora impegnato con l'operazione popViewController e non risponde.

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 per completezza, ho creato una categoria Objective-C pronta per l'uso:

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

Ho ottenuto esattamente questo con precisione utilizzando un blocco. Volevo che il mio controller dei risultati recuperati mostrasse la riga aggiunta dalla visualizzazione modale, solo una volta che aveva lasciato completamente lo schermo, in modo che l'utente potesse vedere il cambiamento in corso. In preparazione per segue, che è responsabile della visualizzazione del controller di visualizzazione modale, ho impostato il blocco che voglio eseguire quando il modale scompare. E nel controller di visualizzazione modale sovrascrivo viewDidDissapear e quindi chiamo il blocco. Inizio semplicemente gli aggiornamenti quando il modale sta per apparire e termina gli aggiornamenti quando scompare, ma questo perché sto usando un NSFetchedResultsController, tuttavia puoi fare quello che vuoi all'interno del blocco.

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

Usa l'estensione successiva sul tuo codice: (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()
    }
}