Sto cercando di sovrascrivere l'azione predefinita del pulsante Indietro in un controller di navigazione. Ho fornito a un target un'azione sul pulsante personalizzato. La cosa strana è quando lo si assegna sebbene l'attributo backbutton non presti attenzione a loro e salti semplicemente la vista corrente e torni alla radice:

UIBarButtonItem *backButton = [[UIBarButtonItem alloc] 
                                  initWithTitle: @"Servers" 
                                  style:UIBarButtonItemStylePlain 
                                  target:self 
                                  action:@selector(home)];
self.navigationItem.backBarButtonItem = backButton;

Non appena l'ho impostato leftBarButtonItemsu on navigationItem, chiama la mia azione, tuttavia il pulsante sembra un round semplice invece di quello con la freccia indietro:

self.navigationItem.leftBarButtonItem = backButton;

Come faccio a richiamare la mia azione personalizzata prima di tornare alla vista principale? C'è un modo per sovrascrivere l'azione di ritorno predefinita o c'è un metodo che viene sempre chiamato quando si esce da una vista ( viewDidUnloadnon lo fa)?

Prova a inserirlo nel controller di visualizzazione in cui desideri rilevare la stampante:

-(void) viewWillDisappear:(BOOL)animated {
    if ([self.navigationController.viewControllers indexOfObject:self]==NSNotFound) {
       // back button was pressed.  We know this is true because self is no longer
       // in the navigation stack.  
    }
    [super viewWillDisappear:animated];
}

Ho implementato l' estensione UIViewController-BackButtonHandler . Non è necessario sottoclassare nulla, basta inserirlo nel progetto e sovrascrivere il navigationShouldPopOnBackButtonmetodo in UIViewControllerclasse:

-(BOOL) navigationShouldPopOnBackButton {
    if(needsShowConfirmation) {
        // Show confirmation alert
        // ...
        return NO; // Ignore 'Back' button this time
    }
    return YES; // Process 'Back' button click and Pop view controler
}

Scarica l'app di esempio .

A differenza di Amagrammer, è possibile. Devi sottoclassare il tuo navigationController. Ho spiegato tutto qui (incluso il codice di esempio).

Versione rapida:

(di https://stackoverflow.com/a/19132881/826435 )

Nel tuo controller di visualizzazione devi solo conformarti a un protocollo ed eseguire qualsiasi azione ti serva:

extension MyViewController: NavigationControllerBackButtonDelegate {
    func shouldPopOnBackButtonPress() -> Bool {
        performSomeActionOnThePressOfABackButton()
        return false
    }
}

Quindi crea una classe, diciamo NavigationController+BackButton, e copia e incolla il codice qui sotto:

protocol NavigationControllerBackButtonDelegate {
    func shouldPopOnBackButtonPress() -> Bool
}

extension UINavigationController {
    public func navigationBar(_ navigationBar: UINavigationBar, shouldPop item: UINavigationItem) -> Bool {
        // Prevents from a synchronization issue of popping too many navigation items
        // and not enough view controllers or viceversa from unusual tapping
        if viewControllers.count < navigationBar.items!.count {
            return true
        }

        // Check if we have a view controller that wants to respond to being popped
        var shouldPop = true
        if let viewController = topViewController as? NavigationControllerBackButtonDelegate {
            shouldPop = viewController.shouldPopOnBackButtonPress()
        }

        if (shouldPop) {
            DispatchQueue.main.async {
                self.popViewController(animated: true)
            }
        } else {
            // Prevent the back button from staying in an disabled state
            for view in navigationBar.subviews {
                if view.alpha < 1.0 {
                    UIView.animate(withDuration: 0.25, animations: {
                        view.alpha = 1.0
                    })
                }
            }

        }

        return false
    }
}

Non è possibile farlo direttamente. Ci sono un paio di alternative:

1. Crea la tua personalizzazione UIBarButtonItemche convalida al tocco e si apre se il test ha esito positivo
2. Convalida del contenuto del campo modulo utilizzando a UITextField metodo delegato, ad esempio -textFieldShouldReturn:, che viene chiamato dopo aver premuto il pulsante Returno Donesulla tastiera

Il rovescio della medaglia della prima opzione è che lo stile della freccia rivolta verso sinistra del pulsante Indietro non è accessibile da un pulsante della barra personalizzato. Quindi devi usare un'immagine o andare con un pulsante di stile normale.

La seconda opzione è utile perché il campo di testo viene ripristinato nel metodo delegato, quindi è possibile indirizzare la logica di convalida al campo di testo specifico inviato al metodo di richiamata delegato.

Per alcuni motivi di threading, la soluzione menzionata da @HansPinckaers non era adatta a me, ma ho trovato un modo molto più semplice per cogliere un tocco sul pulsante Indietro e voglio bloccarlo qui nel caso in cui ciò potesse evitare ore di inganni per qualcun altro. Il trucco è davvero semplice: basta aggiungere un UIButton trasparente come sottoview alla tua UINavigationBar e impostare i selettori per lui come se fosse il vero pulsante! Ecco un esempio usando Monotouch e C #, ma la traduzione in obiettivo-c non dovrebbe essere troppo difficile da trovare.

public class Test : UIViewController {
    public override void ViewDidLoad() {
        UIButton b = new UIButton(new RectangleF(0, 0, 60, 44)); //width must be adapted to label contained in button
        b.BackgroundColor = UIColor.Clear; //making the background invisible
        b.Title = string.Empty; // and no need to write anything
        b.TouchDown += delegate {
            Console.WriteLine("caught!");
            if (true) // check what you want here
                NavigationController.PopViewControllerAnimated(true); // and then we pop if we want
        };
        NavigationController.NavigationBar.AddSubview(button); // insert the button to the nav bar
    }
}

Curiosità: a scopo di test e per trovare buone dimensioni per il mio pulsante falso, ho impostato il colore di sfondo su blu ... E si mostra dietro il pulsante Indietro! Ad ogni modo, cattura ancora qualsiasi tocco mirando al pulsante originale.

Questa tecnica ti consente di cambiare il testo del pulsante "indietro" senza influenzare il titolo di nessuno dei controller di visualizzazione o vedere il testo del pulsante Indietro cambiare durante l'animazione.

Aggiungi questo al metodo init nel controller della vista chiamante :

UIBarButtonItem *temporaryBarButtonItem = [[UIBarButtonItem alloc] init];   
temporaryBarButtonItem.title = @"Back";
self.navigationItem.backBarButtonItem = temporaryBarButtonItem;
[temporaryBarButtonItem release];

Il modo più semplice

È possibile utilizzare i metodi delegati di UINavigationController. Il metodo willShowViewControllerviene chiamato quando viene premuto il pulsante Indietro del VC. Fai quello che vuoi quando btn viene premuto

- (void)navigationController:(UINavigationController *)navigationController willShowViewController:(UIViewController *)viewController animated:(BOOL)animated;

Ecco la mia soluzione Swift. Nella sottoclasse di UIViewController, sovrascrivere il metodo navigationShouldPopOnBackButton.

extension UIViewController {
    func navigationShouldPopOnBackButton() -> Bool {
        return true
    }
}

extension UINavigationController {

    func navigationBar(navigationBar: UINavigationBar, shouldPopItem item: UINavigationItem) -> Bool {
        if let vc = self.topViewController {
            if vc.navigationShouldPopOnBackButton() {
                self.popViewControllerAnimated(true)
            } else {
                for it in navigationBar.subviews {
                    let view = it as! UIView
                    if view.alpha < 1.0 {
                        [UIView .animateWithDuration(0.25, animations: { () -> Void in
                            view.alpha = 1.0
                        })]
                    }
                }
                return false
            }
        }
        return true
    }

}

Trovata una soluzione che mantiene anche lo stile del pulsante Indietro. Aggiungi il seguente metodo al tuo controller di visualizzazione.

-(void) overrideBack{

    UIButton *transparentButton = [[UIButton alloc] init];
    [transparentButton setFrame:CGRectMake(0,0, 50, 40)];
    [transparentButton setBackgroundColor:[UIColor clearColor]];
    [transparentButton addTarget:self action:@selector(backAction:) forControlEvents:UIControlEventTouchUpInside];
    [self.navigationController.navigationBar addSubview:transparentButton];


}

Ora fornisce una funzionalità secondo necessità nel seguente metodo:

-(void)backAction:(UIBarButtonItem *)sender {
    //Your functionality
}

Non fa altro che coprire il pulsante Indietro con un pulsante trasparente;)

Sostituzione di navigationBar (_ navigationBar: shouldPop) : questa non è una buona idea, anche se funziona. per me ha generato arresti casuali sulla navigazione indietro. Ti consiglio di sovrascrivere il pulsante Indietro rimuovendo il pulsante Indietro predefinito da navigationItem e creando un pulsante Indietro personalizzato come di seguito:

override func viewDidLoad(){
   super.viewDidLoad()
   
   navigationItem.leftBarButton = .init(title: "Go Back", ... , action: #selector(myCutsomBackAction) 

   ...
 
}

========================================

Basandosi sulle risposte precedenti con UIAlert in Swift5 in modo asincrono

protocol NavigationControllerBackButtonDelegate {
    func shouldPopOnBackButtonPress(_ completion: @escaping (Bool) -> ())
}

extension UINavigationController: UINavigationBarDelegate {
    public func navigationBar(_ navigationBar: UINavigationBar, shouldPop item: UINavigationItem) -> Bool {
      
        if viewControllers.count < navigationBar.items!.count {
            return true
        }
        
        // Check if we have a view controller that wants to respond to being popped
        
        if let viewController = topViewController as? NavigationControllerBackButtonDelegate {
            
            viewController.shouldPopOnBackButtonPress { shouldPop in
                if (shouldPop) {
                    /// on confirm => pop
                    DispatchQueue.main.async {
                        self.popViewController(animated: true)
                    }
                } else {
                    /// on cancel => do nothing
                }
            }
            /// return false => so navigator will cancel the popBack
            /// until user confirm or cancel
            return false
        }else{
            DispatchQueue.main.async {
                self.popViewController(animated: true)
            }
        }
        return true
    }
}

Sul tuo controller

extension MyController: NavigationControllerBackButtonDelegate {
    
    func shouldPopOnBackButtonPress(_ completion: @escaping (Bool) -> ()) {
    
        let msg = "message"
        
        /// show UIAlert
        alertAttention(msg: msg, actions: [
            
            .init(title: "Continuer", style: .destructive, handler: { _ in
                completion(true)
            }),
            .init(title: "Annuler", style: .cancel, handler: { _ in
                completion(false)
            })
            ])
   
    }

}

Non credo sia possibile, facilmente. L'unico modo in cui credo di aggirare questo è di creare la tua immagine della freccia del pulsante indietro per posizionarla lassù. All'inizio è stato frustrante per me, ma vedo perché, per motivi di coerenza, è stato lasciato fuori.

Puoi avvicinarti (senza la freccia) creando un pulsante normale e nascondendo il pulsante Indietro predefinito:

self.navigationItem.leftBarButtonItem = [[[UIBarButtonItem alloc] initWithTitle:@"Servers" style:UIBarButtonItemStyleDone target:nil action:nil] autorelease];
self.navigationItem.hidesBackButton = YES;

C'è un modo più semplice semplicemente sottoclassando il metodo delegato di UINavigationBare sovrascrivendo il ShouldPopItemmetodo .

La soluzione di onegray non è sicura. Secondo i documenti ufficiali di Apple, https://developer.apple.com/library/ios/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC/CustomizingExistingClasses/CustomizingExistingClasses.html , dovremmo evitare di farlo.

"Se il nome di un metodo dichiarato in una categoria è lo stesso di un metodo nella classe originale o di un metodo in un'altra categoria della stessa classe (o persino una superclasse), il comportamento non è definito su quale implementazione del metodo viene utilizzata in fase di esecuzione. È meno probabile che si tratti di un problema se si utilizzano categorie con le proprie classi, ma possono causare problemi quando si utilizzano le categorie per aggiungere metodi alle classi standard Cocoa o Cocoa Touch. "

Utilizzando Swift:

override func viewWillDisappear(animated: Bool) {
    super.viewWillDisappear(animated)
    if self.navigationController?.topViewController != self {
        print("back button tapped")
    }
}

Ecco la versione Swift 3 della risposta di @oneway per catturare l'evento del pulsante indietro della barra di navigazione prima che venga attivato. Poiché UINavigationBarDelegatenon è possibile utilizzarlo UIViewController, è necessario creare un delegato che verrà attivato quando navigationBar shouldPopviene chiamato.

@objc public protocol BackButtonDelegate {
      @objc optional func navigationShouldPopOnBackButton() -> Bool 
}

extension UINavigationController: UINavigationBarDelegate  {

    public func navigationBar(_ navigationBar: UINavigationBar, shouldPop item: UINavigationItem) -> Bool {

        if viewControllers.count < (navigationBar.items?.count)! {                
            return true
        }

        var shouldPop = true
        let vc = self.topViewController

        if vc.responds(to: #selector(vc.navigationShouldPopOnBackButton)) {
            shouldPop = vc.navigationShouldPopOnBackButton()
        }

        if shouldPop {
            DispatchQueue.main.async {
                self.popViewController(animated: true)
            }
        } else {
            for subView in navigationBar.subviews {
                if(0 < subView.alpha && subView.alpha < 1) {
                    UIView.animate(withDuration: 0.25, animations: {
                        subView.alpha = 1
                    })
                }
            }
        }

        return false
    }
}

E poi, nella vista controller aggiungi la funzione delegato:

class BaseVC: UIViewController, BackButtonDelegate {
    func navigationShouldPopOnBackButton() -> Bool {
        if ... {
            return true
        } else {
            return false
        }        
    }
}

Mi sono reso conto che spesso vogliamo aggiungere un controller di avviso per gli utenti per decidere se vogliono tornare indietro. Se è così, si può sempre return falsein navigationShouldPopOnBackButton()funzione e chiudere il controller della vista facendo qualcosa di simile a questo:

func navigationShouldPopOnBackButton() -> Bool {
     let alert = UIAlertController(title: "Warning",
                                          message: "Do you want to quit?",
                                          preferredStyle: .alert)
            alert.addAction(UIAlertAction(title: "Yes", style: .default, handler: { UIAlertAction in self.yes()}))
            alert.addAction(UIAlertAction(title: "No", style: .cancel, handler: { UIAlertAction in self.no()}))
            present(alert, animated: true, completion: nil)
      return false
}

func yes() {
     print("yes")
     DispatchQueue.main.async {
            _ = self.navigationController?.popViewController(animated: true)
        }
}

func no() {
    print("no")       
}

Swift 4 iOS 11.3 versione:

Questo si basa sulla risposta di kgaidis da https://stackoverflow.com/a/34343418/4316579

Non sono sicuro quando l'estensione ha smesso di funzionare, ma al momento della stesura di questo documento (Swift 4), sembra che l'estensione non verrà più eseguita a meno che non si dichiari la conformità UINavigationBarDelegate come descritto di seguito.

Spero che questo aiuti le persone che si chiedono perché la loro estensione non funziona più.

extension UINavigationController: UINavigationBarDelegate {
    public func navigationBar(_ navigationBar: UINavigationBar, shouldPop item: UINavigationItem) -> Bool {

    }
}

Utilizzando le variabili target e action che si stanno lasciando 'zero', si dovrebbe essere in grado di collegare le finestre di dialogo di salvataggio in modo che vengano chiamate quando il pulsante è "selezionato". Attenzione, questo potrebbe attivarsi in strani momenti.

Concordo principalmente con Amagrammer, ma non credo che sarebbe così difficile creare il pulsante con la freccia personalizzata. Vorrei solo rinominare il pulsante Indietro, scattare una schermata, Photoshop le dimensioni del pulsante necessarie e avere quella immagine nella parte superiore del pulsante.

Puoi provare ad accedere alla voce Tasto destro di NavigationBars e impostarne la proprietà del selettore ... ecco un riferimento UIBarButtonItem di riferimento , un'altra cosa se questo doenst lavoro che funzionerà sicuramente è, imposta l'elemento del pulsante destro della barra di navigazione su un UIBarButtonItem personalizzato crea e imposta il suo selettore ... spero che questo aiuti

Per un modulo che richiede input dell'utente come questo, consiglierei di invocarlo come "modale" anziché come parte del tuo stack di navigazione. In questo modo devono occuparsi degli affari nel modulo, quindi è possibile convalidarlo e chiuderlo utilizzando un pulsante personalizzato. Puoi persino progettare una barra di navigazione che assomigli al resto della tua app ma ti dia un maggiore controllo.

Per intercettare il pulsante Indietro, è sufficiente coprirlo con un UIControl trasparente e intercettare i tocchi.

@interface MyViewController : UIViewController
{
    UIControl   *backCover;
    BOOL        inhibitBackButtonBOOL;
}
@end

@implementation MyViewController
-(void)viewDidAppear:(BOOL)animated
{
    [super viewDidAppear:animated];

    // Cover the back button (cannot do this in viewWillAppear -- too soon)
    if ( backCover == nil ) {
        backCover = [[UIControl alloc] initWithFrame:CGRectMake( 0, 0, 80, 44)];
#if TARGET_IPHONE_SIMULATOR
        // show the cover for testing
        backCover.backgroundColor = [UIColor colorWithRed:1.0 green:0.0 blue:0.0 alpha:0.15];
#endif
        [backCover addTarget:self action:@selector(backCoverAction) forControlEvents:UIControlEventTouchDown];
        UINavigationBar *navBar = self.navigationController.navigationBar;
        [navBar addSubview:backCover];
    }
}

-(void)viewWillDisappear:(BOOL)animated
{
    [super viewWillDisappear:animated];

    [backCover removeFromSuperview];
    backCover = nil;
}

- (void)backCoverAction
{
    if ( inhibitBackButtonBOOL ) {
        NSLog(@"Back button aborted");
        // notify the user why...
    } else {
        [self.navigationController popViewControllerAnimated:YES]; // "Back"
    }
}
@end

Almeno in Xcode 5, esiste una soluzione semplice e abbastanza buona (non perfetta). In IB, trascina un elemento pulsante barra dal riquadro Utilità e rilascialo sul lato sinistro della barra di navigazione dove si trova il pulsante Indietro. Imposta l'etichetta su "Indietro". Avrai un pulsante funzionante che puoi collegare alla tua IBAction e chiudere il tuo viewController. Sto facendo un po 'di lavoro e quindi innescando un svolgersi segue e funziona perfettamente.

Ciò che non è l'ideale è che questo pulsante non ottiene la <freccia e non porta avanti il ​​titolo VC precedente, ma penso che questo possa essere gestito. Per i miei scopi, ho impostato il nuovo pulsante Indietro in modo che sia "Fatto" in modo che il suo scopo sia chiaro.

Si finisce anche con due pulsanti Indietro nel navigatore IB, ma è abbastanza facile etichettarlo per chiarezza.

veloce

override func viewWillDisappear(animated: Bool) {
    let viewControllers = self.navigationController?.viewControllers!
    if indexOfArray(viewControllers!, searchObject: self) == nil {
        // do something
    }
    super.viewWillDisappear(animated)
}

func indexOfArray(array:[AnyObject], searchObject: AnyObject)-> Int? {
    for (index, value) in enumerate(array) {
        if value as UIViewController == searchObject as UIViewController {
            return index
        }
    }
    return nil
}

Questo approccio ha funzionato per me (ma il pulsante "Indietro" non avrà il segno "<"):

- (void)viewDidLoad
{
    [super viewDidLoad];

    UIBarButtonItem* backNavButton = [[UIBarButtonItem alloc] initWithTitle:@"Back"
                                                                      style:UIBarButtonItemStyleBordered
                                                                     target:self
                                                                     action:@selector(backButtonClicked)];
    self.navigationItem.leftBarButtonItem = backNavButton;
}

-(void)backButtonClicked
{
    // Do something...
    AppDelegate* delegate = (AppDelegate*)[[UIApplication sharedApplication] delegate];
    [delegate.navController popViewControllerAnimated:YES];
}

Versione rapida della risposta di @ onegray

protocol RequestsNavigationPopVerification {
    var confirmationTitle: String { get }
    var confirmationMessage: String { get }
}

extension RequestsNavigationPopVerification where Self: UIViewController {
    var confirmationTitle: String {
        return "Go back?"
    }

    var confirmationMessage: String {
        return "Are you sure?"
    }
}

final class NavigationController: UINavigationController {

    func navigationBar(navigationBar: UINavigationBar, shouldPopItem item: UINavigationItem) -> Bool {

        guard let requestsPopConfirm = topViewController as? RequestsNavigationPopVerification else {
            popViewControllerAnimated(true)
            return true
        }

        let alertController = UIAlertController(title: requestsPopConfirm.confirmationTitle, message: requestsPopConfirm.confirmationMessage, preferredStyle: .Alert)

        alertController.addAction(UIAlertAction(title: "Cancel", style: .Cancel) { _ in
            dispatch_async(dispatch_get_main_queue(), {
                let dimmed = navigationBar.subviews.flatMap { $0.alpha < 1 ? $0 : nil }
                UIView.animateWithDuration(0.25) {
                    dimmed.forEach { $0.alpha = 1 }
                }
            })
            return
        })

        alertController.addAction(UIAlertAction(title: "Go back", style: .Default) { _ in
            dispatch_async(dispatch_get_main_queue(), {
                self.popViewControllerAnimated(true)
            })
        })

        presentViewController(alertController, animated: true, completion: nil)

        return false
    }
}

Ora in qualsiasi controller, basta conformarsi RequestsNavigationPopVerificatione questo comportamento è adottato per impostazione predefinita.

Uso isMovingFromParentViewController

override func viewWillDisappear(animated: Bool) {
    super.viewWillDisappear(true)

    if self.isMovingFromParentViewController {
        // current viewController is removed from parent
        // do some work
    }
}

La risposta di @William è corretta, tuttavia, se l'utente avvia un gesto di scorrimento per tornare indietro, il viewWillDisappearmetodo viene chiamato e selfnon si troverà nemmeno nello stack di navigazione (ovvero, self.navigationController.viewControllersnon conterrà self), anche se lo scorrimento non è completato e il controller di visualizzazione non viene effettivamente visualizzato. Pertanto, la soluzione sarebbe:

1. Disattiva il gesto di scorrimento per tornare indietro viewDidAppeare consenti solo di utilizzare il pulsante Indietro, usando:

   if ([self.navigationController respondsToSelector:@selector(interactivePopGestureRecognizer)])
   {
       self.navigationController.interactivePopGestureRecognizer.enabled = NO;
   }

2. O semplicemente usa viewDidDisappearinvece, come segue:

   - (void)viewDidDisappear:(BOOL)animated
   {
       [super viewDidDisappear:animated];
       if (![self.navigationController.viewControllers containsObject:self])
       {
           // back button was pressed or the the swipe-to-go-back gesture was
           // completed. We know this is true because self is no longer
           // in the navigation stack.
       }
   }

La soluzione che ho trovato finora non è molto bella, ma funziona per me. Prendendo questa risposta , controllo anche se sto saltando programmaticamente o meno:

- (void)viewWillDisappear:(BOOL)animated {
  [super viewWillDisappear:animated];

  if ((self.isMovingFromParentViewController || self.isBeingDismissed)
      && !self.isPoppingProgrammatically) {
    // Do your stuff here
  }
}

Devi aggiungere quella proprietà al tuo controller e impostarla su SÌ prima di far apparire programmaticamente:

self.isPoppingProgrammatically = YES;
[self.navigationController popViewControllerAnimated:YES];

Trovato un nuovo modo di farlo:

Objective-C

- (void)didMoveToParentViewController:(UIViewController *)parent{
    if (parent == NULL) {
        NSLog(@"Back Pressed");
    }
}

veloce

override func didMoveToParentViewController(parent: UIViewController?) {
    if parent == nil {
        println("Back Pressed")
    }
}