Fragments onResume from back stack

Estou usando o pacote de compatibilidade para usar Fragments com Android 2.2. Ao usar fragmentos e adicionar transições entre eles na pilha de backstack, gostaria de obter o mesmo comportamento de onResume de uma atividade, ou seja, sempre que um fragmento é trazido para "primeiro plano" (visível para o usuário) após sair do backstack, gostaria que algum tipo de retorno de chamada fosse ativado dentro do fragmento (para realizar certas mudanças em um recurso de IU compartilhado, por exemplo).

Percebi que não há retorno de chamada embutido na estrutura do fragmento. existe uma boa prática para conseguir isso?

Por falta de uma solução melhor, coloquei isso funcionando para mim: suponha que eu tenha 1 atividade (MyActivity) e alguns fragmentos que se substituem (apenas um é visível por vez).

Em MyActivity, adicione este ouvinte:

getSupportFragmentManager().addOnBackStackChangedListener(getListener());

(Como você pode ver, estou usando o pacote de compatibilidade).

Implementação getListener:

private OnBackStackChangedListener getListener()
    {
        OnBackStackChangedListener result = new OnBackStackChangedListener()
        {
            public void onBackStackChanged() 
            {                   
                FragmentManager manager = getSupportFragmentManager();

                if (manager != null)
                {
                    MyFragment currFrag = (MyFragment) manager.findFragmentById(R.id.fragmentItem);

                    currFrag.onFragmentResume();
                }                   
            }
        };

        return result;
    }

MyFragment.onFragmentResume()será chamado depois que "Voltar" for pressionado. algumas advertências embora:

1. Ele assume que você adicionou todas as transações à pilha de retorno (usando FragmentTransaction.addToBackStack())
2. Ele será ativado a cada mudança de pilha (você pode armazenar outras coisas na pilha posterior, como animação), portanto, você pode obter várias chamadas para a mesma instância de fragmento.

Mudei um pouco a solução sugerida. Funciona melhor para mim assim:

private OnBackStackChangedListener getListener() {
    OnBackStackChangedListener result = new OnBackStackChangedListener() {
        public void onBackStackChanged() {
            FragmentManager manager = getSupportFragmentManager();
            if (manager != null) {
                int backStackEntryCount = manager.getBackStackEntryCount();
                if (backStackEntryCount == 0) {
                    finish();
                }
                Fragment fragment = manager.getFragments()
                                           .get(backStackEntryCount - 1);
                fragment.onResume();
            }
        }
    };
    return result;
}

Depois de um, popStackBack()você pode usar o seguinte retorno de chamada: onHiddenChanged(boolean hidden)dentro do seu fragmento

A seção a seguir em Desenvolvedores Android descreve um mecanismo de comunicação Criando callbacks de eventos para a atividade . Para citar uma linha dele:

Uma boa maneira de fazer isso é definir uma interface de retorno de chamada dentro do fragmento e exigir que a atividade do host a implemente. Quando a atividade recebe um retorno de chamada por meio da interface, ela pode compartilhar as informações com outros fragmentos no layout, conforme necessário.

Editar: o fragmento possui um onStart(...)que é invocado quando o fragmento está visível para o usuário. Da mesma forma, onResume(...)quando visível e em execução ativa. Eles estão vinculados às suas contrapartes de atividade. Resumindo: useonResume()

Na minha atividade onCreate ()

getSupportFragmentManager().addOnBackStackChangedListener(getListener());

Use este método para capturar Fragment específico e chamar onResume ()

private FragmentManager.OnBackStackChangedListener getListener()
    {
        FragmentManager.OnBackStackChangedListener result = new FragmentManager.OnBackStackChangedListener()
        {
            public void onBackStackChanged()
            {
                Fragment currentFragment = getSupportFragmentManager().findFragmentById(R.id.fragment_container);
                if (currentFragment instanceof YOURFRAGMENT) {
                    currentFragment.onResume();
                }
            }
        };

        return result;
    }

Um pouco melhorado e embrulhado em uma solução de gerenciamento.

Coisas a ter em mente. FragmentManager não é um singleton, ele gerencia apenas Fragments dentro de Activity, então em cada atividade será novo. Além disso, esta solução até agora não leva o ViewPager em consideração que chama o método setUserVisibleHint () ajudando a controlar a visibilidade dos Fragments.

Sinta-se à vontade para usar as classes a seguir ao lidar com esse problema (usa injeção Dagger2). Chamada em atividade:

//inject FragmentBackstackStateManager instance to myFragmentBackstackStateManager
FragmentManager fragmentManager = getSupportFragmentManager(); 
myFragmentBackstackStateManager.apply(fragmentManager);

FragmentBackstackStateManager.java:

@Singleton
public class FragmentBackstackStateManager {

    private FragmentManager fragmentManager;

    @Inject
    public FragmentBackstackStateManager() {
    }

    private BackstackCallback backstackCallbackImpl = new BackstackCallback() {
        @Override
        public void onFragmentPushed(Fragment parentFragment) {
            parentFragment.onPause();
        }

        @Override
        public void onFragmentPopped(Fragment parentFragment) {
            parentFragment.onResume();
        }
    };

    public FragmentBackstackChangeListenerImpl getListener() {
        return new FragmentBackstackChangeListenerImpl(fragmentManager, backstackCallbackImpl);
    }

    public void apply(FragmentManager fragmentManager) {
        this.fragmentManager = fragmentManager;
        fragmentManager.addOnBackStackChangedListener(getListener());
    }
}

FragmentBackstackChangeListenerImpl.java:

public class FragmentBackstackChangeListenerImpl implements FragmentManager.OnBackStackChangedListener {

    private int lastBackStackEntryCount = 0;
    private final FragmentManager fragmentManager;
    private final BackstackCallback backstackChangeListener;

    public FragmentBackstackChangeListenerImpl(FragmentManager fragmentManager, BackstackCallback backstackChangeListener) {
        this.fragmentManager = fragmentManager;
        this.backstackChangeListener = backstackChangeListener;
        lastBackStackEntryCount = fragmentManager.getBackStackEntryCount();
    }

    private boolean wasPushed(int backStackEntryCount) {
        return lastBackStackEntryCount < backStackEntryCount;
    }

    private boolean wasPopped(int backStackEntryCount) {
        return lastBackStackEntryCount > backStackEntryCount;
    }

    private boolean haveFragments() {
        List<Fragment> fragmentList = fragmentManager.getFragments();
        return fragmentList != null && !fragmentList.isEmpty();
    }


    /**
     * If we push a fragment to backstack then parent would be the one before => size - 2
     * If we pop a fragment from backstack logically it should be the last fragment in the list, but in Android popping a fragment just makes list entry null keeping list size intact, thus it's also size - 2
     *
     * @return fragment that is parent to the one that is pushed to or popped from back stack
     */
    private Fragment getParentFragment() {
        List<Fragment> fragmentList = fragmentManager.getFragments();
        return fragmentList.get(Math.max(0, fragmentList.size() - 2));
    }

    @Override
    public void onBackStackChanged() {
        int currentBackStackEntryCount = fragmentManager.getBackStackEntryCount();
        if (haveFragments()) {
            Fragment parentFragment = getParentFragment();

            //will be null if was just popped and was last in the stack
            if (parentFragment != null) {
                if (wasPushed(currentBackStackEntryCount)) {
                    backstackChangeListener.onFragmentPushed(parentFragment);
                } else if (wasPopped(currentBackStackEntryCount)) {
                    backstackChangeListener.onFragmentPopped(parentFragment);
                }
            }
        }

        lastBackStackEntryCount = currentBackStackEntryCount;
    }
}

BackstackCallback.java:

public interface BackstackCallback {
    void onFragmentPushed(Fragment parentFragment);

    void onFragmentPopped(Fragment parentFragment);
}

Se um fragmento for colocado na pilha de retorno, o Android simplesmente destrói sua visualização. A própria instância do fragmento não é eliminada. Uma maneira simples de começar é ouvir o evento onViewCreated e colocar a lógica "onResume ()" lá.

boolean fragmentAlreadyLoaded = false;
    @Override
    public void onViewCreated(View view, @Nullable Bundle savedInstanceState) {
        // TODO Auto-generated method stub
        super.onViewCreated(view, savedInstanceState);

        if (savedInstanceState == null && !fragmentAlreadyLoaded) {
            fragmentAlreadyLoaded = true;

            // Code placed here will be executed once
        }

        //Code placed here will be executed even when the fragment comes from backstack
    }

Esta é a resposta correta que você pode chamar onResume (), desde que o fragmento esteja anexado à atividade. Alternativamente, você pode usar onAttach e onDetach

onResume () para o fragmento funciona bem ...

public class listBook extends Fragment {

    private String listbook_last_subtitle;
...

    @Override
       public void onCreate(Bundle savedInstanceState) {

        String thisFragSubtitle = (String) getActivity().getActionBar().getSubtitle();
        listbook_last_subtitle = thisFragSubtitle;
       }
...

    @Override
        public void onResume(){
            super.onResume();
            getActivity().getActionBar().setSubtitle(listbook_last_subtitle);
        }
...

public abstract class RootFragment extends Fragment implements OnBackPressListener {

 @Override
 public boolean onBackPressed() {
  return new BackPressImpl(this).onBackPressed();
 }

 public abstract void OnRefreshUI();

}


public class BackPressImpl implements OnBackPressListener {

 private Fragment parentFragment;

 public BackPressImpl(Fragment parentFragment) {
  this.parentFragment = parentFragment;
 }

 @Override
 public boolean onBackPressed() {
  ((RootFragment) parentFragment).OnRefreshUI();
 }
}

e a extensão final do seu Frament from RootFragment para ver o efeito

Minha solução alternativa é obter o título atual da barra de ações no Fragment antes de defini-lo com o novo título. Dessa forma, uma vez que o Fragment é exibido, posso voltar a esse título.

@Override
public void onResume() {
    super.onResume();
    // Get/Backup current title
    mTitle = ((ActionBarActivity) getActivity()).getSupportActionBar()
            .getTitle();
    // Set new title
    ((ActionBarActivity) getActivity()).getSupportActionBar()
        .setTitle(R.string.this_fragment_title);
}

@Override
public void onDestroy() {
    // Set title back
    ((ActionBarActivity) getActivity()).getSupportActionBar()
        .setTitle(mTitle);

    super.onDestroy();
}

Usei enum FragmentTagspara definir todas as minhas classes de fragmento.

TAG_FOR_FRAGMENT_A(A.class),
TAG_FOR_FRAGMENT_B(B.class),
TAG_FOR_FRAGMENT_C(C.class)

passar FragmentTags.TAG_FOR_FRAGMENT_A.name()como tag de fragmento.

e agora em

@Override
public void onBackPressed(){
   FragmentManager fragmentManager = getFragmentManager();
   Fragment current
   = fragmentManager.findFragmentById(R.id.fragment_container);
    FragmentTags fragmentTag = FragmentTags.valueOf(current.getTag());

  switch(fragmentTag){
    case TAG_FOR_FRAGMENT_A:
        finish();
        break;
   case TAG_FOR_FRAGMENT_B:
        fragmentManager.popBackStack();
        break;
   case default: 
   break;
}