Podczas odrzucania modalnego kontrolera widoku za pomocą dismissViewController, istnieje opcja zapewnienia bloku uzupełniania. Czy istnieje podobny odpowiednik popViewController?

Argument ukończenia jest całkiem przydatny. Na przykład mogę go użyć do wstrzymania usuwania wiersza z widoku tabeli, dopóki modal nie zniknie z ekranu, pozwalając użytkownikowi zobaczyć animację wiersza. Wracając z wypychanego kontrolera widoku, chciałbym mieć taką samą możliwość.

Próbowałem umieścić popViewControllerw UIViewbloku animacji, gdzie mam dostęp do bloku uzupełniania. Jednak powoduje to niepożądane efekty uboczne na wyskakującym widoku.

Jeśli nie ma takiej metody, jakie są obejścia?

Wiem, że odpowiedź została przyjęta ponad dwa lata temu, jednak jest ona niepełna.

Nie ma sposobu, aby zrobić to, czego chcesz, po wyjęciu z pudełka

Jest to technicznie poprawne, ponieważ UINavigationControllerinterfejs API nie oferuje żadnych opcji. Jednak za pomocą struktury CoreAnimation można dodać blok uzupełniania do podstawowej animacji:

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

[self.navigationController popViewControllerAnimated:YES];

[CATransaction commit];

Blok ukończenia zostanie wywołany zaraz po zakończeniu animacji popViewControllerAnimated:. Ta funkcjonalność jest dostępna od iOS 4.

Dla wersji SWIFT na iOS9 - działa jak urok (nie był testowany dla wcześniejszych wersji). Na podstawie tej odpowiedzi

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

Zrobiłem Swiftwersję z rozszerzeniami z odpowiedzią @JorisKluivers .

Spowoduje to wywołanie zakończenia zakończenia po zakończeniu animacji dla obu pushi 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()
}
}

Miałem ten sam problem. A ponieważ musiałem go używać przy wielu okazjach iw ramach łańcuchów bloków uzupełniania, stworzyłem to ogólne rozwiązanie w podklasie 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];
}

Zarozumiały

@interface NavigationController : UINavigationController <UINavigationControllerDelegate>

i

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

i

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

Nie ma sposobu, aby zrobić to, czego chcesz, po wyjęciu z pudełka. tj. nie ma metody z blokiem uzupełniania do zdejmowania kontrolera widoku ze stosu nawigacji.

To, co zrobiłbym, to umieścić logikę viewDidAppear. Zostanie to wywołane, gdy widok skończy się pojawiać na ekranie. Będzie wywoływany dla wszystkich różnych scenariuszy pojawiania się kontrolera widoku, ale to powinno wystarczyć.

Lub możesz użyć tej UINavigationControllerDelegatemetody, navigationController:didShowViewController:animated:aby zrobić podobną rzecz. Jest to wywoływane, gdy kontroler nawigacji zakończy wypychanie lub otwieranie kontrolera widoku.

Praca z animacją lub bez niej, a także 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)
  }
}

W oparciu o odpowiedź @ HotJard, kiedy wszystko, czego potrzebujesz, to tylko kilka linii kodu. Szybko i łatwo.

Swift 4 :

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

Na rok 2018 ...

jeśli masz to ...

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

i chcesz dodać uzupełnienie ...

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

to takie proste.

Przydatna wskazówka ...

Ta sama sprawa dotyczy wygodnego popToViewControllerpołączenia.

Typową rzeczą jest to, że masz na pokładzie stos zillionów ekranów. Kiedy w końcu skończysz, wrócisz z powrotem do ekranu „podstawowego”, a następnie uruchomisz aplikację.

Na ekranie „podstawowym”, aby przejść „całą drogę wstecz”, 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()
}

Blok uzupełniania jest wywoływany po wywołaniu metody viewDidDisappear na prezentowanym kontrolerze widoku, więc umieszczenie kodu w metodzie viewDidDisappear kontrolera widoku popped powinno działać tak samo jak blok uzupełniania.

Szybka 3 odpowiedź, dzięki tej odpowiedzi: 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()
    }
}

Wersja Swift 4 z opcjonalnym parametrem viewController, aby wyświetlić konkretny.

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

Wyczyszczono wersję Swift 4 na podstawie tej odpowiedzi .

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

Istnieje pod o nazwie UINavigationControllerWithCompletionBlock, który dodaje obsługę bloku uzupełniania podczas wypychania i wyskakiwania na UINavigationController.

2020 Swift 5.1 sposób

To rozwiązanie gwarantuje, że ukończenie zostanie wykonane po całkowitym zakończeniu popViewController. Możesz to przetestować, wykonując inną operację na NavigationController w zakończeniu: We wszystkich innych rozwiązaniach powyżej UINavigationController jest nadal zajęty operacją popViewController i nie odpowiada.

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

Dla kompletności przygotowałem kategorię Cel-C gotową do użycia:

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

Osiągnąłem to dokładnie z precyzją za pomocą bloku. Chciałem, aby mój kontroler pobranych wyników pokazywał wiersz dodany przez widok modalny tylko wtedy, gdy całkowicie opuścił ekran, aby użytkownik mógł zobaczyć zachodzącą zmianę. Przygotowując się do przejścia, które jest odpowiedzialne za wyświetlanie kontrolera widoku modalnego, ustawiam blok, który chcę wykonać, gdy modal zniknie. W kontrolerze widoku modalnego nadpisuję viewDidDissapear, a następnie wywołuję blok. Po prostu zaczynam aktualizacje, gdy modal ma się pojawić, i kończę aktualizacje, gdy zniknie, ale to dlatego, że używam NSFetchedResultsController, ale możesz robić, co chcesz, wewnątrz bloku.

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

Użyj następnego rozszerzenia w swoim kodzie: (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()
    }
}