Transazioni di frammenti

In fase di esecuzione, FragmentManager può aggiungere, rimuovere, sostituire ed eseguire altre azioni con frammenti in risposta all'interazione dell'utente. Ogni insieme di frammenti viene modificato il commit è chiamato transazione e puoi specificare cosa fare la transazione utilizzando le API fornite FragmentTransaction: . Puoi raggruppare più azioni in una singola transazione, ad esempio un può aggiungere o sostituire più frammenti. Questo raggruppamento può essere è utile quando vengono visualizzati più frammenti di pari livello sullo stesso schermo, ad esempio con le visualizzazioni divise.

Puoi salvare ogni transazione in uno stack esistente gestito dal FragmentManager, che consente all'utente di tornare indietro nel modifiche dei frammenti, simili all'esplorazione a ritroso delle attività.

Puoi ottenere un'istanza di FragmentTransaction da FragmentManager chiamando beginTransaction(), come mostrato nell'esempio seguente:

val fragmentManager = ...
val fragmentTransaction = fragmentManager.beginTransaction()

FragmentManager fragmentManager = ...
FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();

L'ultima chiamata su ogni FragmentTransaction deve eseguire il commit della transazione. La chiamata commit() segnala a FragmentManager che tutte le operazioni sono stati aggiunti alla transazione.

val fragmentManager = ...
// The fragment-ktx module provides a commit block that automatically
// calls beginTransaction and commit for you.
fragmentManager.commit {
    // Add operations here
}

FragmentManager fragmentManager = ...
FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();

// Add operations here

fragmentTransaction.commit();

Consenti il riordinamento delle modifiche dello stato dei frammenti

Ogni FragmentTransaction deve utilizzare setReorderingAllowed(true):

supportFragmentManager.commit {
    ...
    setReorderingAllowed(true)
}

FragmentManager fragmentManager = ...
fragmentManager.beginTransaction()
    ...
    .setReorderingAllowed(true)
    .commit();

Per garantire la compatibilità del comportamento, il flag di riordinamento non è abilitato per impostazione predefinita. Tuttavia, è obbligatorio per consentire la corretta esecuzione di FragmentManager il tuo FragmentTransaction, in particolare se opera sulle back stack ed esegue animazioni e transizioni. L'attivazione del flag garantisce che, se vengono eseguite più transazioni contemporaneamente, eventuali frammenti intermedi (ovvero quelli aggiunti e poi sostituiti immediatamente) non passano attraverso cambiamenti del ciclo di vita o l'esecuzione delle relative animazioni o transizioni. Tieni presente che questo flag influisce sia sull'esecuzione iniziale della transazione sia sull'inversione la transazione con popBackStack().

Aggiunta e rimozione di frammenti

Per aggiungere un frammento a FragmentManager, richiama add() sulla transazione. Questo metodo riceve l'ID del container per il frammento e il nome della classe che desideri aggiungere. Il frammento aggiunto viene spostato in RESUMED stato. È vivamente consigliato che il container sia un FragmentContainerView: che fa parte della gerarchia delle viste.

Per rimuovere un frammento dall'host, chiama remove(), passa in un'istanza del frammento recuperata dal frammento amministratore tramite findFragmentById() o findFragmentByTag(). Se la vista del frammento è stata aggiunta in precedenza a un container, viene rimosso dal container a questo punto. Il frammento rimosso viene spostato allo stato DESTROYED.

Utilizza le funzionalità di replace() per sostituire un frammento esistente in un container con un'istanza di un la nuova classe di frammento fornita. Chiamare replace() equivale a chiamando remove() con un frammento in un container e aggiungendo un nuovo nello stesso container.

Il seguente snippet di codice mostra come sostituire un frammento con un altro:

// Create new fragment
val fragmentManager = // ...

// Create and commit a new transaction
fragmentManager.commit {
    setReorderingAllowed(true)
    // Replace whatever is in the fragment_container view with this fragment
    replace<ExampleFragment>(R.id.fragment_container)
}

// Create new fragment and transaction
FragmentManager fragmentManager = ...
FragmentTransaction transaction = fragmentManager.beginTransaction();
transaction.setReorderingAllowed(true);

// Replace whatever is in the fragment_container view with this fragment
transaction.replace(R.id.fragment_container, ExampleFragment.class, null);

// Commit the transaction
transaction.commit();

In questo esempio, una nuova istanza di ExampleFragment sostituisce il frammento, che si trova nel contenitore di layout identificato da R.id.fragment_container.

Per impostazione predefinita, le modifiche apportate in un FragmentTransaction non vengono aggiunte lo stack posteriore. Per salvare queste modifiche, puoi chiamare addToBackStack() il FragmentTransaction. Per ulteriori informazioni, vedi Gestore dei frammenti.

Il commit è asincrono

Chiamata in corso commit() non esegue immediatamente la transazione. Piuttosto, la transazione è pianificato per essere eseguito sul thread dell'interfaccia utente principale non appena possibile. Se necessario, tuttavia, puoi richiamare commitNow() per eseguire immediatamente la transazione del frammento sul thread della UI.

Tieni presente che commitNow non è compatibile con addToBackStack. In alternativa, puoi eseguire tutti i FragmentTransactions in attesa inviati da commit() non ancora effettuate chiamando executePendingTransactions(). Questo approccio è compatibile con addToBackStack.

Per la maggior parte dei casi d'uso, commit() è tutto ciò di cui hai bisogno.

L'ordine delle operazioni è significativo

L'ordine in cui esegui operazioni all'interno di un FragmentTransaction è significativa, in particolare quando si utilizza setCustomAnimations(). Questo applica le animazioni date a tutte le operazioni sui frammenti seguitela.

supportFragmentManager.commit {
    setCustomAnimations(enter1, exit1, popEnter1, popExit1)
    add<ExampleFragment>(R.id.container) // gets the first animations
    setCustomAnimations(enter2, exit2, popEnter2, popExit2)
    add<ExampleFragment>(R.id.container) // gets the second animations
}

getSupportFragmentManager().beginTransaction()
        .setCustomAnimations(enter1, exit1, popEnter1, popExit1)
        .add(R.id.container, ExampleFragment.class, null) // gets the first animations
        .setCustomAnimations(enter2, exit2, popEnter2, popExit2)
        .add(R.id.container, ExampleFragment.class, null) // gets the second animations
        .commit()

Limita il ciclo di vita del frammento

FragmentTransactions può influire sullo stato del ciclo di vita di un aggiunti nell'ambito della transazione. Quando crei un FragmentTransaction, setMaxLifecycle() imposta uno stato massimo per il frammento specificato. Ad esempio: ViewPager2 utilizza setMaxLifecycle() per limitare i frammenti fuori schermo allo stato STARTED.

Mostrare e nascondere le visualizzazioni del frammento

Utilizza i metodi FragmentTransaction show() e hide() per mostrare e nascondere la visualizzazione dei frammenti aggiunti a un container. Questi metodi impostano la visibilità delle viste del frammento senza influire il ciclo di vita del frammento.

Anche se non è necessario utilizzare una transazione con frammento per attivare/disattivare la visibilità delle viste all'interno di un frammento, questi metodi sono utili per i casi in cui associare le modifiche allo stato di visibilità transazioni sul back stack.

Collegamento e scollegamento di frammenti

Il metodo FragmentTransaction detach() scollega il frammento dalla UI, distruggendo la sua gerarchia di visualizzazioni. Il frammento rimane nello stato (STOPPED) di quando viene inserito nello stack posteriore. Ciò significa che il frammento è stato rimosso dalla UI, ma è ancora gestito da il gestore dei frammenti.

La attach() riaggancia un frammento da cui era stato scollegato in precedenza. Questo fa sì che la gerarchia delle viste venga ricreata, collegata alla UI e visualizzati.

Poiché FragmentTransaction viene considerato come un singolo insieme atomico di operazioni, a detach e attach sulla stessa istanza di frammento la stessa transazione si annulla effettivamente a vicenda, evitando distruzione e ricreazione immediata della UI del frammento. Usa separato transazioni separate, separate da executePendingOperations() se utilizzi commit(), se vuoi scollegare e poi ricollegare immediatamente un frammento.