Fragmente onResume vom Backstack

Ich verwende das Kompatibilitätspaket, um Fragmente mit Android 2.2 zu verwenden. Wenn Sie Fragmente verwenden und Übergänge zwischen ihnen zum Backstack hinzufügen, möchte ich das gleiche Verhalten wie onResume einer Aktivität erzielen, dh immer dann, wenn ein Fragment nach dem Verlassen des Stacks in den "Vordergrund" (für den Benutzer sichtbar) gebracht wird Backstack, ich möchte, dass eine Art Rückruf innerhalb des Fragments aktiviert wird (um beispielsweise bestimmte Änderungen an einer gemeinsam genutzten UI-Ressource vorzunehmen).

Ich habe gesehen, dass es innerhalb des Fragment-Frameworks keinen eingebauten Rückruf gibt. Gibt es eine gute Praxis, um dies zu erreichen?

Da es keine bessere Lösung gibt, funktioniert dies für mich: Angenommen, ich habe 1 Aktivität (MyActivity) und wenige Fragmente, die sich gegenseitig ersetzen (jeweils nur eines ist sichtbar).

Fügen Sie in MyActivity diesen Listener hinzu:

getSupportFragmentManager().addOnBackStackChangedListener(getListener());

(Wie Sie sehen, verwende ich das Kompatibilitätspaket).

getListener-Implementierung:

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()wird aufgerufen, nachdem ein "Zurück" gedrückt wurde. Einige Einschränkungen:

1. Es wird davon ausgegangen, dass Sie alle Transaktionen zum Backstack hinzugefügt haben (using FragmentTransaction.addToBackStack())
2. Es wird bei jedem Stapelwechsel aktiviert (Sie können andere Inhalte im Backstack speichern, z. B. Animationen), sodass Sie möglicherweise mehrere Aufrufe für dieselbe Fragmentinstanz erhalten.

Ich habe die vorgeschlagene Lösung ein wenig geändert. Funktioniert bei mir so besser:

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

Nach a können popStackBack()Sie den folgenden Rückruf verwenden: onHiddenChanged(boolean hidden)innerhalb Ihres Fragments

Der folgende Abschnitt bei Android Developers beschreibt einen Kommunikationsmechanismus, der Ereignisrückrufe für die Aktivität erstellt . Um eine Zeile daraus zu zitieren:

Eine gute Möglichkeit, dies zu tun, besteht darin, eine Rückrufschnittstelle innerhalb des Fragments zu definieren und zu verlangen, dass die Hostaktivität diese implementiert. Wenn die Aktivität über die Schnittstelle einen Rückruf erhält, kann sie die Informationen nach Bedarf mit anderen Fragmenten im Layout teilen.

Bearbeiten: Das Fragment hat eine, onStart(...)die aufgerufen wird, wenn das Fragment für den Benutzer sichtbar ist. Ebenso ein onResume(...)wenn sichtbar und aktiv laufend. Diese sind an ihre Aktivitätsgegenstücke gebunden. Kurzum: verwendenonResume()

In meiner Aktivität onCreate ()

getSupportFragmentManager().addOnBackStackChangedListener(getListener());

Verwenden Sie diese Methode, um ein bestimmtes Fragment abzufangen und onResume () aufzurufen.

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

Ein wenig verbessert und in eine Manager-Lösung eingewickelt.

Dinge zu beachten. FragmentManager ist kein Singleton, sondern verwaltet nur Fragmente innerhalb der Aktivität, sodass es in jeder Aktivität neu ist. Bei dieser Lösung wird ViewPager bisher nicht berücksichtigt, da die Methode setUserVisibleHint () aufgerufen wird, um die Sichtbarkeit von Fragmenten zu steuern.

Wenn Sie sich mit diesem Problem befassen, können Sie die folgenden Klassen verwenden (verwendet Dagger2-Injektion). Aktivität aufrufen:

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

Wenn ein Fragment auf den Backstack gelegt wird, zerstört Android einfach seine Ansicht. Die Fragmentinstanz selbst wird nicht getötet. Eine einfache Möglichkeit zum Starten besteht darin, das Ereignis onViewCreated abzuhören und dort die Logik "onResume ()" zu platzieren.

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
    }

Dies ist die richtige Antwort, die Sie onResume () aufrufen können, sofern das Fragment an die Aktivität angehängt ist. Alternativ können Sie onAttach und onDetach verwenden

onResume () für das Fragment funktioniert gut ...

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

und schließlich Umfang dein Frament von RootFragment, um Wirkung zu sehen

Meine Problemumgehung besteht darin, den aktuellen Titel der Aktionsleiste im Fragment abzurufen, bevor Sie den neuen Titel festlegen. Auf diese Weise kann ich nach dem Aufspringen des Fragments wieder zu diesem Titel zurückkehren.

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

Ich habe enum verwendet FragmentTags, um alle meine Fragmentklassen zu definieren.

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

bestehen FragmentTags.TAG_FOR_FRAGMENT_A.name() als Fragment - Tag.

und jetzt weiter

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