Fornisci una navigazione a ritroso personalizzata

Gli utenti possono tornare indietro nelle schermate utilizzando il comando Indietro. La maggior parte dei dispositivi Android ha un pulsante Indietro, fisico, software o basato su gesti. In genere, non devi aggiungere un pulsante Indietro alla tua app. Tuttavia, i dispositivi con sistema operativo Android Automotive (AAOS) in modalità di compatibilità utilizzano un pulsante Indietro di sistema. Gestisce la navigazione, quindi non devi aggiungerne una. Per maggiori dettagli, consulta Modalità di compatibilità AAOS.

Android gestisce una back stack di destinazioni mentre l'utente naviga nella tua applicazione. In genere, questo consente ad Android di passare correttamente alle destinazioni precedenti quando viene premuto il pulsante Indietro. Tuttavia, in alcuni casi la tua app potrebbe dover implementare il proprio comportamento di opzione Indietro per offrire la migliore esperienza utente possibile. Ad esempio, quando utilizzi un WebView, potresti voler ignorare il comportamento predefinito del pulsante Indietro per consentire all'utente di ripercorrere la cronologia di navigazione web anziché le schermate precedenti nella tua app.

Implementare la navigazione a ritroso personalizzata

ComponentActivity, la classe di base per FragmentActivity e AppCompatActivity, consente di controllare il comportamento del pulsante Indietro utilizzando il relativo OnBackPressedDispatcher, che puoi recuperare chiamando getOnBackPressedDispatcher().

OnBackPressedDispatcher controlla la modalità di invio degli eventi del pulsante Indietro a uno o più oggetti OnBackPressedCallback. Il costruttore di OnBackPressedCallback accetta un valore booleano per lo stato iniziale attivo. Solo quando è attivato un callback (ad es. isEnabled() restituisce true) il gestore chiamerà il callback handleOnBackPressed() per gestire l'evento del pulsante Indietro. Puoi modificare lo stato di attivazione chiamando setEnabled().

I callback vengono aggiunti tramite i metodi addCallback. Ti consigliamo vivamente di utilizzare il metodo addCallback() che accetta un LifecycleOwner. In questo modo, OnBackPressedCallback viene aggiunto solo quando LifecycleOwner è Lifecycle.State.STARTED. L'attività rimuove anche i callback registrati quando il relativo LifecycleOwner associato viene distrutto, il che impedisce le perdite di memoria e lo rende adatto all'uso in frammenti o altri proprietari del ciclo di vita con una durata inferiore all'attività.

Di seguito è riportato un esempio di implementazione del callback:

KotlinJava
class MyFragment : Fragment() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // This callback will only be called when MyFragment is at least Started.
        val callback = requireActivity().onBackPressedDispatcher.addCallback(this) {
            // Handle the back button event
        }

        // The callback can be enabled or disabled here or in the lambda
    }
    ...
}
 
public class MyFragment extends Fragment {

    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // This callback will only be called when MyFragment is at least Started.
        OnBackPressedCallback callback = new OnBackPressedCallback(true /* enabled by default */) {
            @Override
            public void handleOnBackPressed() {
                // Handle the back button event
            }
        };
        requireActivity().getOnBackPressedDispatcher().addCallback(this, callback);

        // The callback can be enabled or disabled here or in handleOnBackPressed()
    }
    ...
}

Puoi fornire più callback tramite addCallback(). In questo modo, i callback vengono richiamati nell'ordine inverso in cui vengono aggiunti: il callback aggiunto per ultimo è il primo a cui viene data la possibilità di gestire l'evento del pulsante Indietro. Ad esempio, se hai aggiunto tre callback denominati one, two e three in ordine, verranno richiamati nell'ordine di three, two e one, rispettivamente.

I callback seguono il pattern Chain of Responsibility. Ogni callback nella catena viene invocato solo se il callback precedente non è stato attivato. Ciò significa che nell'esempio precedente, il callback two verrebbe invocato solo se il callback three non fosse abilitato. Il callback one viene invocato solo se il callback two non è abilitato e così via.

Tieni presente che, se aggiunto tramite addCallback(), il callback non viene aggiunto alla catena di responsabilità finché LifecycleOwner non entra nello stato Lifecycle.State.STARTED.

È vivamente consigliato di modificare lo stato abilitato su OnBackPressedCallback per le modifiche temporanee, in quanto mantiene l'ordine descritto sopra, il che è particolarmente importante se hai registrato callback su più proprietari di ciclo di vita nidificati diversi.

Tuttavia, se vuoi rimuovere completamente OnBackPressedCallback, devi chiamare remove(). Tuttavia, in genere non è necessario perché i callback vengono rimossi automaticamente quando l'oggetto LifecycleOwner associato viene distrutto.

Attività onBackPressed()

Se utilizzi onBackPressed() per gestire gli eventi del pulsante Indietro, ti consigliamo di utilizzare un OnBackPressedCallback. Tuttavia, se non riesci a apportare questa modifica, si applicano le seguenti regole:

  • Tutti i callback registrati tramite addCallback vengono valutati quando chiami super.onBackPressed().
  • In Android 12 (livello API 32) e versioni precedenti, onBackPressed viene chiamato sempre, indipendentemente dalle istanze registrate di OnBackPressedCallback.