pie - android versiones

¿Cómo hacer que un Fragmento se elimine a sí mismo, es decir, que sea equivalente a finish()?

Question

Estoy convirtiendo una aplicación para usar fragmentos usando la biblioteca de compatibilidad. Ahora, actualmente tengo varias actividades (ABCD) que se encadenan unas con otras, D tiene un botón "OK" que cuando se pulsa, las llamadas finalizan y luego se onActivityResult() en onActivityResult() para destruir C y B.

Para mi versión previa al fragmento de Honycomb, cada actividad es efectivamente una envoltura de fragmentos Af Bf Cf Df. Todas las actividades se startActivityForResult() través de startActivityForResult() y onActivityResult() dentro de cada uno de los fragmentos que podemos llamar felizmente getActivity().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 utilizando 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 principal o la actividad para hacer el pop con el administrador de transacciones?

Answer 1

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

Paso n. ° 1: Pídale a Df que diga D "¡yo! ¡Tenemos el clic correcto!" llamando a un método, ya sea en la actividad misma 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 hospedaje (D) es la que sabe qué otros fragmentos hay en la actividad (en lugar de estar en otras actividades). Por lo tanto, los eventos en el fragmento que pueden afectar a la mezcla de fragmentos deben propagarse a la actividad, lo que hará que los movimientos de orquestación apropiados.

Answer 2

¿Por qué no solo?

getActivity (). finish ();

Answer 3

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!

Answer 4

Debería dejar que la Actividad se ocupe de agregar y eliminar Fragmentos, como lo dice CommonsWare, usar 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());
            }
        });
    }
}

Answer 5

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 llamar en el fragmento:

getActivity().onBackPressed();

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

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

Answer 6

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 click 1.

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

Luego lo muestra de nuevo int evento 2

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

Answer 7

Puede utilizar el siguiente enfoque, funciona bien:

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

Answer 8

Si bien puede que no sea el mejor enfoque, el equivalente más cercano que puedo pensar es que funciona con la biblioteca de soporte / compatibilidad

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

o

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

de otra manera.

Además, puedes 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 se colocó en la pila, por lo que al abrir la pila podría eliminar el incorrecto ...

Answer 9

Si necesitas hacer un popback desde el cuarto fragmento en el historial de backstack hasta el primero, ¡usa etiquetas!

Cuando agregues el primer fragmento deberías 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 al Fragment A, solo llame a 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 usado en el comando reemplazar o agregar.

De nada ;)

Answer 10

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