Fornisci una navigazione a ritroso personalizzata

La navigazione a ritroso indica il modo in cui gli utenti tornano indietro nella cronologia delle schermate visitate in precedenza. Tutti i dispositivi Android offrono un pulsante Indietro per questo tipo di navigazione, quindi non aggiungerlo all'interfaccia utente dell'app. A seconda del dispositivo Android dell'utente, questo pulsante potrebbe essere fisico o software.

Android mantiene uno stack posteriore di destinazioni mentre l'utente naviga nell'applicazione. In questo modo Android può andare correttamente alle destinazioni precedenti quando si preme il pulsante Indietro. Tuttavia, in alcuni casi, la tua app potrebbe dover implementare il proprio comportamento Indietro per fornire la migliore esperienza utente possibile.

Ad esempio, quando utilizzi un WebView, ti consigliamo di ignorare il comportamento predefinito del pulsante Indietro per consentire all'utente di tornare indietro nella cronologia di navigazione web anziché nelle schermate precedenti dell'app.

Android 13 e versioni successive include un gesto Indietro predittivo per i dispositivi Android. Per scoprire di più su questa funzionalità, consulta l'articolo Aggiungere il supporto del gesto Indietro predittivo.

Implementare la navigazione a ritroso personalizzata

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

OnBackPressedDispatcher controlla il modo in cui gli eventi del pulsante Indietro vengono inviati a uno o più oggetti OnBackPressedCallback. Il costruttore di OnBackPressedCallback utilizza un valore booleano per lo stato iniziale abilitato. Quando un callback è attivato, ovvero isEnabled() restituisce true, il supervisore chiama il callback handleOnBackPressed() per gestire l'evento del pulsante Indietro. Puoi modificare lo stato attivo chiamando setEnabled().

I callback vengono aggiunti utilizzando i metodi addCallback. Ti consigliamo di utilizzare il metodo addCallback(), che richiede LifecycleOwner. In questo modo, OnBackPressedCallback viene aggiunto solo quando LifecycleOwner è Lifecycle.State.STARTED. L'attività rimuove anche i callback registrati quando viene eliminato l'oggetto LifecycleOwner associato, il che impedisce le perdite di memoria e rende LifecycleOwner adatto all'utilizzo in frammenti o in altri proprietari del ciclo di vita con una durata più breve dell'attività.

Ecco un esempio di implementazione del callback:

Kotlin

class MyFragment : Fragment() {

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

        // This callback is only 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
    }
    ...
}

Java

public class MyFragment extends Fragment {

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

        // This callback is only 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 utilizzando addCallback(). In questo caso, i callback vengono attivati in ordine inverso rispetto all'ordine in cui li aggiungi: il callback aggiunto per ultimo è il primo che ha la possibilità di gestire l'evento del pulsante Indietro. Ad esempio, se aggiungi tre callback denominati one, two e three, in questo ordine vengono richiamati nell'ordine three, two, one.

I callback seguono il pattern di catena di responsabilità. Ogni callback nella catena viene richiamato solo se il callback precedente non è stato abilitato. Ciò significa che, nell'esempio precedente, il callback two viene richiamato solo se il callback three non è abilitato, mentre il callback one viene richiamato solo se il callback two non è abilitato.

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

Ti consigliamo di modificare lo stato attivo in OnBackPressedCallback per le modifiche temporanee, in modo da mantenere l'ordine descritto sopra. Questo è particolarmente importante se hai callback registrati su più proprietari del ciclo di vita nidificati.

Se vuoi rimuovere completamente OnBackPressedCallback, puoi chiamare remove(). In genere questa operazione non è necessaria, perché i callback vengono rimossi automaticamente quando l'elemento LifecycleOwner associato viene eliminato.

Attività onBackPressed()

Se utilizzi onBackPressed() per gestire gli eventi del pulsante Indietro, ti consigliamo di utilizzare invece un OnBackPressedCallback. Tuttavia, se non puoi apportare questa modifica, vengono applicate le seguenti regole:

  • Tutte le richiamate registrate tramite addCallback vengono valutate quando chiami super.onBackPressed().
  • In Android 12 (livello API 32) e versioni precedenti, onBackPressed viene sempre chiamato, indipendentemente dalle istanze registrate di OnBackPressedCallback.