Limpiar la pila usando fragmentos

Porté mi aplicación de Android a Honeycomb e hice una gran refactorización para usar fragmentos. En mi versión anterior, cuando presioné el botón de Inicio, solía hacer un ACTIVITY_CLEAR_TOPpara restablecer la pila de respaldo.

Ahora mi aplicación es solo una Actividad con múltiples fragmentos, así que cuando presiono el botón de Inicio, simplemente reemplazo uno de los fragmentos que contiene. ¿Cómo puedo limpiar mi back stack sin tener que usarlo startActivitycon la ACTIVITY_CLEAR_TOPbandera?

Publiqué algo similar aquí

De la respuesta de Joachim, de Dianne Hackborn:

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

Terminé simplemente usando:

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

Pero igualmente podría haber usado algo como:

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

Lo que mostrará todos los estados hasta el nombre. Luego puedes reemplazar el fragmento con lo que quieras

Para responder al comentario de @ Warpzit y facilitar que otros lo encuentren.

Utilizar:

fragmentManager.popBackStack(null, FragmentManager.POP_BACK_STACK_INCLUSIVE);

Con el debido respeto a todas las partes involucradas; Estoy muy sorprendido de ver cuántos de ustedes podrían limpiar todo el back stack del fragmento con un simple

fm.popBackStack(null, FragmentManager.POP_BACK_STACK_INCLUSIVE);

De acuerdo con la documentación de Android (con respecto al nameargumento, el "nulo" en las propuestas de trabajo reclamadas).

Si es nulo, solo aparece el estado superior

Ahora, me doy cuenta de que no tengo conocimiento de sus implementaciones particulares (como cuántas entradas tiene en la pila posterior en el momento dado), pero apostaría todo mi dinero en la respuesta aceptada cuando espero una respuesta bien definida comportamiento en una gama más amplia de dispositivos y proveedores:

(para referencia, algo junto con esto)

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

Funciona para mí y de manera fácil sin usar loop:

 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 respuesta aceptada no fue suficiente para mí. Tuve que usar:

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

Backstack claro sin bucles

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

Donde nombre es el parámetro addToBackStack ()

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

Solo quería agregar: -

Saliendo del backstack usando los siguientes

fragmentManager.popBackStack ()

se trata solo de eliminar los fragmentos de la transacción, de ninguna manera va a eliminar el fragmento de la pantalla. Entonces, idealmente, puede que no sea visible para usted, pero puede haber dos o tres fragmentos apilados uno sobre el otro, y al presionar la tecla de retroceso, la IU puede verse desordenada, apilada.

Solo tomando un ejemplo simple: -

Supongamos que tiene un fragmento A que carga Fragmnet B usando fragmentmanager.replace () y luego agregamos AddToBackStack, para guardar esta transacción. Entonces el flujo es: -

PASO 1 -> Fragmento A-> Fragmento B (nos mudamos a Fragmento B, pero el Fragmento A está en segundo plano, no visible).

Ahora realiza un trabajo en el fragmento B y presiona el botón Guardar, que después de guardar debe volver al fragmento A.

PASO 2-> Al guardar FragmentB, volvemos a FragmentA.

PASO 3 -> Entonces, un error común sería ... en el Fragmento B, haremos el fragmento Manager.replace () fragmentB con fragmentA.

Pero lo que realmente está sucediendo es que estamos cargando el Fragmento A nuevamente, reemplazando el Fragmento B. Entonces ahora hay dos FragmentA (uno de STEP-1, y uno de este STEP-3).

Dos instancias de FragmentsA están apiladas una sobre otra, lo que puede no ser visible, pero está ahí.

Entonces, incluso si limpiamos el backstack mediante los métodos anteriores, la transacción se borra pero no los fragmentos reales. Entonces, idealmente en un caso tan particular, al presionar el botón Guardar simplemente necesita volver al fragmento A simplemente haciendo fm.popBackStack () o fm.popBackImmediate () .

Entonces, el Paso 3-> fm.popBackStack () correcto vuelve al fragmento A, que ya está en la memoria.

Al leer la documentación y estudiar cuál es la identificación del fragmento, parece ser simplemente el índice de la pila, por lo que esto funciona:

fragmentManager.popBackStackImmediate(0, FragmentManager.POP_BACK_STACK_INCLUSIVE);

Cero ( 0) es la parte inferior de la pila, por lo que al abrirla se borra la pila.

CAVEAT: Aunque lo anterior funciona en mi programa, dudo un poco porque la documentación de FragmentManager nunca indica que la identificación es el índice de la pila. Tiene sentido que lo sea, y todos mis registros de depuración revelan que lo es, pero tal vez en alguna circunstancia especial no lo haría. ¿Puede alguien confirmar esto de una forma u otra? Si es así, entonces lo anterior es la mejor solución. Si no, esta es la alternativa:

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

Simplemente use este método y pase la etiqueta Context & Fragment a la que necesitamos eliminar los fragmentos backstake.

Uso

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

Hola ~ Encontré una solución que es mucho mejor, desde: 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);
    }
}

Tengo esto trabajando de esta manera:

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

Está funcionando para mí, prueba este:

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

Llamar a este método sería muy bueno.

1. No se requiere bucle.
2. Si está utilizando animación en fragmentos, no mostrará demasiadas animaciones. Pero usando loop lo hará.

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