¿Cómo hacer que un Fragment se elimine, es decir, su equivalente de finish ()?

Estoy convirtiendo una aplicación para usar fragmentos usando la biblioteca de compatibilidad. Ahora actualmente tengo una serie de actividades (ABCD) que se encadenan entre sí, D tiene un botón 'OK' que, cuando se presionan las llamadas, finaliza y luego emerge onActivityResult()para destruir adicionalmente C y B.

Para mi versión previa del fragmento Honycomb, cada actividad es efectivamente un contenedor de fragmentos Af Bf Cf Df. Todas las actividades se inician a través de startActivityForResult()y onActivityResult()dentro de cada uno de los fragmentos pueden llamar felizmentegetActivity().finish()

Sin embargo, el problema que tengo es que en mi versión Honeycomb solo tengo una actividad, A, y los fragmentos Bf, Cf, Df se cargan usando el FragmentManager.

Lo que no entiendo es qué hacer en Df cuando se presiona 'OK' para eliminar los fragmentos Df, Cf y Bf.

Intenté que el fragmento saliera de la pila, pero esto resultó en una excepción. onActivityResult()es inútil porque no he cargado el fragmento usando startActivityForResult().

¿Estoy pensando en esto completamente de la manera incorrecta? ¿Debo implementar algún tipo de escucha que se comunique con el fragmento o la actividad principal para hacer el pop usando el administrador de transacciones?

Lo que no entiendo es qué hacer en Df cuando se presiona 'OK' para eliminar los fragmentos Df, Cf y Bf.

Paso # 1: ¡Df dile a D "yo! ¡Tenemos el clic OK!" llamando a un método, ya sea en la actividad en sí o en una instancia de interfaz proporcionada por la actividad.

Paso # 2: Haz que D elimine los fragmentos a través de FragmentManager.

La actividad de alojamiento (D) es la que sabe qué otros fragmentos hay en la actividad (frente a estar en otras actividades). Por lo tanto, los eventos en fragmentos que pueden afectar la mezcla de fragmentos deben propagarse a la actividad, lo que hará los movimientos de orquestación apropiados.

Si bien podría no ser el mejor enfoque, el equivalente más cercano que puedo pensar que funciona es esto con la biblioteca de compatibilidad / soporte

getActivity().getSupportFragmentManager().beginTransaction().remove(this).commit();

o

getActivity().getFragmentManager().beginTransaction().remove(this).commit();

de otra manera.

Además, puede usar el backstack y abrirlo. Sin embargo, tenga en cuenta que el fragmento podría no estar en el backstack (dependiendo de la transacción del fragmento que lo llevó allí ...) o podría no ser el último que entró en la pila, por lo que al extraer la pila podría eliminar el incorrecto ...

Puede usar el siguiente enfoque, funciona bien:

getActivity().getSupportFragmentManager().popBackStack();

Debes dejar que la actividad se ocupe de agregar y quitar fragmentos, como dice CommonsWare, usa un oyente. Aquí hay un ejemplo:

public class MyActivity extends FragmentActivity implements SuicidalFragmentListener {

    // onCreate etc

    @Override
    public void onFragmentSuicide(String tag) {
        // Check tag if you do this with more than one fragmen, then:
        getSupportFragmentManager().popBackStack();
    }
}

public interface SuicidalFragmentListener {
    void onFragmentSuicide(String tag);
}

public class MyFragment extends Fragment {

    // onCreateView etc

    @Override
    public void onAttach(Activity activity) {
        super.onAttach(activity);
        try {
           suicideListener = (SuicidalFragmentListener) activity;
        } catch (ClassCastException e) {
           throw new RuntimeException(getActivity().getClass().getSimpleName() + " must implement the suicide listener to use this fragment", e);
        }
    }

    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        // Attach the close listener to whatever action on the fragment you want
        addSuicideTouchListener();
    }

    private void addSuicideTouchListener() {
        getView().setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
              suicideListener.onFragmentSuicide(getTag());
            }
        });
    }
}

En la Actividad / AppCompatActivity:

@Override
public void onBackPressed() {
    if (mDrawerLayout.isDrawerOpen(GravityCompat.START)) {
        // if you want to handle DrawerLayout
        mDrawerLayout.closeDrawer(GravityCompat.START);
    } else {
        if (getFragmentManager().getBackStackEntryCount() == 0) {
            super.onBackPressed();
        } else {
            getFragmentManager().popBackStack();
        }
    }
}

y luego llame al fragmento:

getActivity().onBackPressed();

o como se indica en otras respuestas, llame a esto en el fragmento:

getActivity().getSupportFragmentManager().beginTransaction().remove(this).commit();

Si está utilizando el nuevo componente de navegación, es simple como

findNavController().popBackStack()

Hará toda la FragmentTransaction detrás de usted.

Vea si sus necesidades son satisfechas por un DialogFragment. DialogFragment tiene un método de despido (). Mucho más limpio en mi opinión.

Creo un método simple para eso

popBackStack(getSupportFragmentManager());

Que colocarlo en mi clase ActivityUtils

public static void popBackStack(FragmentManager manager){
        FragmentManager.BackStackEntry first = manager.getBackStackEntryAt(0);
        manager.popBackStack(first.getId(), FragmentManager.POP_BACK_STACK_INCLUSIVE);
    }

Es un gran trabajo, diviértete!

OnCreate:

//Add comment fragment
            container = FindViewById<FrameLayout>(Resource.Id.frmAttachPicture);
            mPictureFragment = new fmtAttachPicture();

            var trans = SupportFragmentManager.BeginTransaction();
            trans.Add(container.Id, mPictureFragment, "fmtPicture");
            trans.Show(mPictureFragment); trans.Commit();

Así es como oculto el fragmento en el evento de clic 1

//Close fragment
    var trans = SupportFragmentManager.BeginTransaction();
    trans.Hide(mPictureFragment);
    trans.AddToBackStack(null);
    trans.Commit();

Luego lo muestra de vuelta int evento 2

var trans = SupportFragmentManager.BeginTransaction();
            trans.Show(mPictureFragment); trans.Commit();

Si necesita retroceder desde el cuarto fragmento en el historial de backstack hasta el primero, ¡use etiquetas!

Cuando agrega el primer fragmento, debe usar algo como esto:

getFragmentManager.beginTransaction.addToBackStack("A").add(R.id.container, FragmentA).commit() 

o

getFragmentManager.beginTransaction.addToBackStack("A").replace(R.id.container, FragmentA).commit()

Y cuando quieres mostrar los Fragmentos B, C y D, usas esto:

getFragmentManager.beginTransaction.addToBackStack("B").replace(R.id.container, FragmentB, "B").commit()

y otras letras ...

Para volver a FragmentA, simplemente llame popBackStack(0, "A"), sí, use el indicador que especificó cuando lo agregó, y tenga en cuenta que debe ser el mismo indicador en el comando addToBackStack(), no el que se usa en el comando reemplazar o agregar.

De nada ;)

Para cerrar un fragmento dentro del mismo fragmento

getActivity().onBackPressed();

¿Por qué no solo:

getActivity (). finish ();