Löschen Sie den Rückstapel mit Fragmenten

Ich habe meine Android-App auf Honeycomb portiert und einen großen Refactor durchgeführt, um Fragmente zu verwenden. In meiner vorherigen Version habe ich beim Drücken der Home-Taste a ausgeführt, ACTIVITY_CLEAR_TOPum den Backstack zurückzusetzen.

Jetzt ist meine App nur eine einzelne Aktivität mit mehreren Fragmenten. Wenn ich also die Home-Taste drücke, ersetze ich einfach eines der darin enthaltenen Fragmente. Wie kann ich meinen Backstack löschen, ohne ihn startActivitymit der ACTIVITY_CLEAR_TOPFlagge verwenden zu müssen?

Ich habe hier etwas Ähnliches gepostet

Aus Joachims Antwort, aus Dianne Hackborn:

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

Am Ende habe ich nur verwendet:

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

Hätte aber auch so etwas gebrauchen können:

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

Dadurch werden alle Zustände bis zu dem genannten angezeigt. Sie können das Fragment dann einfach durch das ersetzen, was Sie möchten

Um eine Antwort auf den Kommentar von @ Warpzit zu geben und anderen das Auffinden zu erleichtern.

Verwenden:

fragmentManager.popBackStack(null, FragmentManager.POP_BACK_STACK_INCLUSIVE);

Bei allem Respekt gegenüber allen Beteiligten; Ich bin sehr überrascht zu sehen, wie viele von Ihnen den gesamten Fragment-Backstack mit einem einfachen löschen können

fm.popBackStack(null, FragmentManager.POP_BACK_STACK_INCLUSIVE);

Laut Android-Dokumentation (bezüglich des nameArguments - die "Null" in den beanspruchten Arbeitsvorschlägen).

Wenn null, wird nur der oberste Status angezeigt

Jetzt ist mir klar, dass mir Kenntnisse über Ihre speziellen Implementierungen fehlen (z. B. wie viele Einträge Sie zu einem bestimmten Zeitpunkt im Backstack haben), aber ich würde mein ganzes Geld auf die akzeptierte Antwort setzen, wenn ich eine genau definierte Antwort erwarte Verhalten über eine größere Anzahl von Geräten und Anbietern:

(als Referenz etwas dazu)

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

Funktioniert für mich und auf einfache Weise ohne Schleife:

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

Akzeptierte Antwort war mir nicht genug. Ich musste verwenden:

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

Clear Backstack ohne Schleifen

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

Wobei Name der Parameter addToBackStack () ist

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

Ich wollte nur hinzufügen: -

Herausspringen aus dem Backstack mit folgenden Schritten

fragmentManager.popBackStack ()

Es geht nur darum, die Fragmente aus der Transaktion zu entfernen. Auf keinen Fall wird das Fragment vom Bildschirm entfernt. Im Idealfall ist es für Sie möglicherweise nicht sichtbar, aber möglicherweise sind zwei oder drei Fragmente übereinander gestapelt, und beim Drücken der Zurück-Taste sieht die Benutzeroberfläche möglicherweise überladen und gestapelt aus.

Nehmen wir nur ein einfaches Beispiel: -

Angenommen, Sie haben ein FragmentA, das Fragmnet B mit fragmentmanager.replace () lädt, und dann fügen wir AddBoStack hinzu, um diese Transaktion zu speichern. Der Fluss ist also:

SCHRITT 1 -> FragmentA-> FragmentB (wir sind zu FragmentB übergegangen, aber Fragment A befindet sich im Hintergrund und ist nicht sichtbar).

Jetzt erledigen Sie einige Arbeiten in FragmentB und klicken auf die Schaltfläche Speichern. Nach dem Speichern sollte wieder zu FragmentA zurückkehren.

SCHRITT 2-> Beim Speichern von FragmentB kehren wir zu FragmentA zurück.

SCHRITT 3 -> Ein häufiger Fehler wäre also ... in Fragment B werden wir fragment Manager.replace () fragmentB mit fragmentA ausführen.

Aber was tatsächlich passiert, wir laden Fragment A erneut und ersetzen Fragment B. Jetzt gibt es also zwei FragmentA (eines aus STEP-1 und eines aus diesem STEP-3).

Zwei Instanzen von FragmentenA sind übereinander gestapelt, was möglicherweise nicht sichtbar ist, aber vorhanden ist.

Selbst wenn wir den Backstack mit den oben genannten Methoden löschen, wird die Transaktion gelöscht, nicht jedoch die tatsächlichen Fragmente. Idealerweise müssen Sie in einem solchen speziellen Fall beim Drücken der Schaltfläche Speichern einfach zu fragmentA zurückkehren, indem Sie einfach fm.popBackStack () oder fm.popBackImmediate () ausführen .

Also richtig Step3-> fm.popBackStack () gehe zurück zu fragmentA, das sich bereits im Speicher befindet.

Wenn Sie die Dokumentation lesen und die Fragment-ID untersuchen, scheint es sich lediglich um den Stapelindex zu handeln. Dies funktioniert also:

fragmentManager.popBackStackImmediate(0, FragmentManager.POP_BACK_STACK_INCLUSIVE);

Null ( 0) ist die Unterseite des Stapels. Wenn Sie also einschließlich aufspringen, wird der Stapel gelöscht.

CAVEAT: Obwohl das oben Genannte in meinem Programm funktioniert, zögere ich ein wenig, da in der FragmentManager-Dokumentation nie angegeben wird, dass die ID der Stapelindex ist. Es macht Sinn, dass es so wäre, und alle meine Debug-Protokolle zeigen, dass es so ist, aber vielleicht würde es unter bestimmten Umständen nicht so sein? Kann jemand dies auf die eine oder andere Weise bestätigen? Wenn dies der Fall ist, ist das Obige die beste Lösung. Wenn nicht, ist dies die Alternative:

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

Verwenden Sie einfach diese Methode und übergeben Sie das Context & Fragment-Tag, an das wir die Backstake-Fragmente entfernen müssen.

Verwendung

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();
    }
}

Hallo ~ Ich habe eine Lösung gefunden, die viel besser ist: 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);
    }
}

Ich habe das so gemacht:

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

Es funktioniert für mich, versuchen Sie dieses:

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);
    }

Der Aufruf dieser Methode wäre sehr ordentlich.

1. Keine Schleife erforderlich.
2. Wenn Sie Animationen in Fragmenten verwenden, werden nicht zu viele Animationen angezeigt. Aber mit Schleife wird.

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;
}