Effacer la pile arrière en utilisant des fragments

J'ai porté mon application Android sur nid d'abeille et j'ai fait un gros refactor afin d'utiliser des fragments. Dans ma version précédente, lorsque j'appuyais sur le bouton Accueil, je faisais un ACTIVITY_CLEAR_TOPpour réinitialiser la pile arrière.

Maintenant, mon application est juste une seule activité avec plusieurs fragments, donc lorsque j'appuie sur le bouton Accueil, je remplace simplement l'un des fragments à l'intérieur. Comment puis-je vider ma pile arrière sans avoir à utiliser startActivityavec le ACTIVITY_CLEAR_TOPdrapeau?

J'ai posté quelque chose de similaire ici

D'après la réponse de Joachim, de Dianne Hackborn:

http://groups.google.com/group/android-developers/browse_thread/thread/d2a5c203dad6ec42

J'ai fini par utiliser:

FragmentManager fm = getActivity().getSupportFragmentManager();
for(int i = 0; i < fm.getBackStackEntryCount(); ++i) {    
    fm.popBackStack();
}

Mais aurait également pu utiliser quelque chose comme:

((AppCompatActivity)getContext()).getSupportFragmentManager().popBackStack(String name, FragmentManager.POP_BACK_STACK_INCLUSIVE)

Ce qui fera apparaître tous les états jusqu'à celui nommé. Vous pouvez alors simplement remplacer le fragment par ce que vous voulez

Pour répondre au commentaire de @ Warpzit et le rendre plus facile à trouver pour les autres.

Utilisation:

fragmentManager.popBackStack(null, FragmentManager.POP_BACK_STACK_INCLUSIVE);

Avec tout le respect dû à toutes les parties concernées; Je suis très surpris de voir combien d’entre vous ont pu effacer la pile complète de fragments avec un simple

fm.popBackStack(null, FragmentManager.POP_BACK_STACK_INCLUSIVE);

Selon la documentation Android (concernant l' nameargument - le "nul" dans les propositions de travail revendiquées).

Si null, seul l'état supérieur est sauté

Maintenant, je me rends compte que je ne connais pas vos implémentations particulières (comme le nombre d'entrées que vous avez dans la pile arrière à un moment donné), mais je parierais tout mon argent sur la réponse acceptée lorsque vous vous attendez à une définition bien définie comportement sur une plus large gamme d'appareils et de fournisseurs:

(pour référence, quelque chose avec ça)

FragmentManager fm = getFragmentManager(); // or 'getSupportFragmentManager();'
int count = fm.getBackStackEntryCount();
for(int i = 0; i < count; ++i) {    
    fm.popBackStack();
}

Fonctionne pour moi et de manière simple sans utiliser de boucle:

 FragmentManager fragmentManager = getSupportFragmentManager();
 //this will clear the back stack and displays no animation on the screen
 fragmentManager.popBackStackImmediate(null, FragmentManager.POP_BACK_STACK_INCLUSIVE);

La réponse acceptée ne me suffisait pas. J'ai dû utiliser:

FragmentManager fm = getSupportFragmentManager();
int count = fm.getBackStackEntryCount();
for(int i = 0; i < count; ++i) {
    fm.popBackStackImmediate();
}

Backstack clair sans boucles

String name = getSupportFragmentManager().getBackStackEntryAt(0).getName();
getSupportFragmentManager().popBackStack(name, FragmentManager.POP_BACK_STACK_INCLUSIVE);

Où nom est le paramètre addToBackStack ()

getSupportFragmentManager().beginTransaction().
                .replace(R.id.container, fragments.get(titleCode))
                .addToBackStack(name)

Je voulais juste ajouter: -

Sauter hors du backstack en utilisant

fragmentManager.popBackStack ()

consiste simplement à supprimer les fragments de la transaction, aucun moyen de supprimer le fragment de l'écran. Donc, idéalement, il peut ne pas être visible pour vous, mais il peut y avoir deux ou trois fragments empilés les uns sur les autres, et sur la touche arrière, l'interface utilisateur peut sembler encombrée, empilée.

Prenons juste un exemple simple: -

Supposons que vous ayez un fragmentA qui charge Fragmnet B à l'aide de fragmentmanager.replace () , puis nous ajoutons AddToBackStack, pour enregistrer cette transaction. Le flux est donc: -

ÉTAPE 1 -> FragmentA-> FragmentB (nous sommes passés à FragmentB, mais le fragment A est en arrière-plan, non visible).

Maintenant, vous travaillez dans fragmentB et appuyez sur le bouton Enregistrer - qui, après l'enregistrement, devrait revenir à fragmentA.

ÉTAPE 2-> Sur sauvegarde de FragmentB, nous revenons à FragmentA.

ÉTAPE 3 -> Une erreur courante serait donc ... dans le Fragment B, nous allons faire fragment Manager.replace () fragmentB avec fragmentA.

Mais ce qui se passe réellement, nous chargeons à nouveau le fragment A, en remplaçant le fragmentB. Il y a donc maintenant deux FragmentA (un de STEP-1 et un de STEP-3).

Deux instances de FragmentsA sont empilées l'une sur l'autre, ce qui n'est peut-être pas visible, mais elle est là.

Donc, même si nous effaçons le backstack par les méthodes ci-dessus, la transaction est effacée mais pas les fragments réels. Donc, idéalement dans un tel cas particulier, en appuyant sur le bouton Enregistrer, vous devez simplement revenir à fragmentA en faisant simplement fm.popBackStack () ou fm.popBackImmediate () .

Donc, corrigez Step3-> fm.popBackStack () pour revenir à fragmentA, qui est déjà en mémoire.

En lisant la documentation et en étudiant l'ID du fragment, il semble que ce soit simplement l'index de la pile, donc cela fonctionne:

fragmentManager.popBackStackImmediate(0, FragmentManager.POP_BACK_STACK_INCLUSIVE);

Zéro ( 0) est le bas de la pile, donc le fait d'apparaître inclus efface la pile.

CAVEAT: Bien que ce qui précède fonctionne dans mon programme, j'hésite un peu car la documentation de FragmentManager ne déclare jamais réellement que l'id est l'index de la pile. Il est logique que ce soit le cas, et tous mes journaux de débogage montrent que c'est le cas, mais peut-être que dans certaines circonstances spéciales, ce ne serait pas le cas? Quelqu'un peut-il confirmer cela dans un sens ou dans l'autre? Si c'est le cas, alors ce qui précède est la meilleure solution. Sinon, c'est l'alternative:

while(fragmentManager.getBackStackEntryCount() > 0) { fragmentManager.popBackStackImmediate(); }

Utilisez simplement cette méthode et passez la balise Context & Fragment jusqu'à laquelle nous devons supprimer les fragments de backstake.

Usage

clearFragmentByTag(context, FragmentName.class.getName());



public static void clearFragmentByTag(Context context, String tag) {
    try {
        FragmentManager fm = ((AppCompatActivity) context).getSupportFragmentManager();

        for (int i = fm.getBackStackEntryCount() - 1; i >= 0; i--) {
            String backEntry = fm.getBackStackEntryAt(i).getName();
            if (backEntry.equals(tag)) {
                break;
            } else {
                 fm.popBackStack();
            }
        }
    } catch (Exception e) {
        System.out.print("!====Popbackstack error : " + e);
        e.printStackTrace();
    }
}

Salut ~ J'ai trouvé une solution bien meilleure, à partir de: https://gist.github.com/ikew0ng/8297033

    /**
 * Remove all entries from the backStack of this fragmentManager.
 *
 * @param fragmentManager the fragmentManager to clear.
 */
private void clearBackStack(FragmentManager fragmentManager) {
    if (fragmentManager.getBackStackEntryCount() > 0) {
        FragmentManager.BackStackEntry entry = fragmentManager.getBackStackEntryAt(0);
        fragmentManager.popBackStack(entry.getId(), FragmentManager.POP_BACK_STACK_INCLUSIVE);
    }
}

Je l'ai fait fonctionner de cette façon:

public void showHome() {
    getHandler().post(new Runnable() {
        @Override
        public void run() {
            final FragmentManager fm = getSupportFragmentManager();
            while (fm.getBackStackEntryCount() > 0) {
                fm.popBackStackImmediate();
            }
        }
    });
}

Cela fonctionne pour moi, essayez celui-ci:

public void clearFragmentBackStack() {
        FragmentManager fm = getSupportFragmentManager();
        for (int i = 0; i < fm.getBackStackEntryCount() - 1; i++) {
            fm.popBackStack();
        }
    }

    private void clearBackStack(){
        SupportFragmentManaer fm = getSupportFragmentManager();
        fm.popBackStack(null, FragmentManager.POP_BACK_STACK_INCLUSIVE);
    }

L'appel à cette méthode serait très soigné.

1. Aucune boucle requise.
2. Si vous utilisez l'animation en fragments, elle n'affichera pas trop d'animations. Mais utiliser la boucle le fera.

private boolean removeFragFromBackStack() {
    try {
        FragmentManager manager = getSupportFragmentManager();
        List<Fragment> fragsList = manager.getFragments();
        if (fragsList.size() == 0) {
            return true;
        }
        manager.popBackStack(null, FragmentManager.POP_BACK_STACK_INCLUSIVE);
        return true;
    } catch (Exception e) {
        e.printStackTrace();
    }
    return false;
}