Como fazer com que um fragmento se remova, ou seja, seu equivalente a finish ()?

Estou convertendo um aplicativo para usar fragmentos usando a biblioteca de compatibilidade. Agora, atualmente, tenho várias atividades (ABCD) que se encadearam, D tem um botão 'OK' que, quando pressionado, termina e depois borbulha onActivityResult()para destruir adicionalmente C e B.

Para minha versão anterior do fragmento Honycomb, cada atividade é efetivamente um invólucro nos fragmentos Af Bf Cf Df. Todas as atividades são iniciadas via startActivityForResult()e onActivityResult()dentro de cada um dos fragmentos podem chamargetActivity().finish()

O problema que estou tendo, porém, está na minha versão do Honeycomb; só tenho uma atividade, A, e os fragmentos Bf, Cf, Df são carregados usando o FragmentManager.

O que não entendo é o que fazer em Df quando 'OK' é pressionado para remover os fragmentos Df, Cf e Bf?

Tentei fazer com que o fragmento aparecesse da pilha, mas isso resultou em uma exceção. onActivityResult()é inútil porque não carreguei o fragmento usando startActivityForResult().

Estou pensando nisso completamente da maneira errada? Devo estar implementando algum tipo de ouvinte que se comunica com o fragmento ou atividade pai para fazer o pop usando o gerenciador de transações?

O que não entendo é o que fazer em Df quando 'OK' é pressionado para remover os fragmentos Df, Cf e Bf?

Etapa 1: Faça com que Df diga D "yo! Temos o clique OK!" através da chamada de um método, na própria atividade ou em uma instância de interface fornecida pela atividade.

Etapa 2: Faça com que D remova os fragmentos via FragmentManager.

A atividade de hospedagem (D) é aquela que sabe quais outros fragmentos estão na atividade (versus estar em outras atividades). Portanto, os eventos no fragmento que podem afetar a mistura de fragmentos devem ser propagados para a atividade, o que fará os movimentos apropriados da orquestração.

Embora possa não ser a melhor abordagem, o equivalente mais próximo que consigo pensar é que funciona com a biblioteca de suporte / compatibilidade

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

ou

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

de outra forma.

Além disso, você pode usar o backstack e abri-lo. No entanto, lembre-se de que o fragmento pode não estar no backstack (dependendo da transação do fragmento que chegou lá ..) ou pode não ser o último que entrou na pilha, portanto, estourar a pilha pode remover o errado ...

Você pode usar a abordagem abaixo, ela funciona bem:

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

Você deve deixar a atividade lidar com a adição e remoção de fragmentos, como o CommonsWare diz, usar um ouvinte. Aqui está um exemplo:

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

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

e depois chame o fragmento:

getActivity().onBackPressed();

ou como indicado em outras respostas, chame isso no fragmento:

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

Se você estiver usando o novo componente de navegação, é simples como

findNavController().popBackStack()

Ele fará toda a FragmentTransaction atrás de você.

Veja se suas necessidades são atendidas por um DialogFragment. DialogFragment possui um método de descarte (). Muito mais limpo na minha opinião.

Eu crio um método simples para isso

popBackStack(getSupportFragmentManager());

Em seguida, coloque-o na minha classe ActivityUtils

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

É um ótimo trabalho, divirta-se!

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

É assim que eu oculto o fragmento no evento click 1

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

Em seguida, mostra de volta int evento 2

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

Se você precisar voltar do quarto fragmento do histórico do backstack para o primeiro, use tags !!!

Quando você adiciona o primeiro fragmento, deve usar algo como isto:

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

ou

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

E quando você deseja mostrar os fragmentos B, C e D, você usa isso:

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

e outras letras ....

Para retornar a FragmentA, basta chamar popBackStack(0, "A"), sim, use o sinalizador que você especificou ao adicioná-lo e observe que ele deve ser o mesmo sinalizador no comandoaddToBackStack() , e não o usado no comando substituir ou adicionar.

De nada ;)

Para fechar um fragmento enquanto estiver dentro do mesmo fragmento

getActivity().onBackPressed();

Por que não apenas:

getActivity (). finish ();