Comment obtenir des fragments lors de l'utilisation de FragmentPagerAdapter

J'ai trouvé réponse à ma question en se basant sur le post suivant: la réutilisation de fragments dans un fragmentpageradapter

Quelques choses que j'ai apprises:

1. getItem(int position) dans le FragmentPagerAdapter est plutôt trompeur nom de ce que cette méthode ne fait. Il crée de nouveaux fragments, de ne pas retourner existants. Dans ce sens, la méthode devrait être renommé quelque chose comme createItem(int position) dans le SDK Android. Si cette méthode ne permet pas d'obtenir des fragments.
2. D'explication dans le post soutien FragmentPagerAdapterholds référence à d'anciens fragments vous devez laisser à la création des fragments de la FragmentPagerAdapter et donc ce qui signifie que vous n'avez aucune référence à l'Fragments ou de leurs tags. Si vous avez fragment de la balise, vous pouvez facilement récupérer de référence à partir de la FragmentManager en appelant findFragmentByTag(). Nous avons besoin d'un moyen de trouver la balise d'un fragment à la page donnée de position.

Solution

Ajouter la suite de la méthode d'assistance dans votre classe pour récupérer le fragment de la balise et de l'envoyer à la findFragmentByTag() méthode.

private String getFragmentTag(int viewPagerId, int fragmentPosition)
{
return "android:switcher:" + viewPagerId + ":" + fragmentPosition;
}

REMARQUE! C'est une méthode identique que FragmentPagerAdapter utiliser lors de la création de nouveaux fragments. Voir ce lien http://code.google.com/p/openintents/source/browse/trunk/compatibility/AndroidSupportV2/src/android/support/v2/app/FragmentPagerAdapter.java#104

vous n'avez pas besoin de remplacer instantiateItem ni compter sur la compatibilité de la création fragment de balises internes makeFragmentName méthode. instantiateItem est un public méthode de sorte que vous pouvez (et en fait, vous devrait) en onCreate méthode de votre activité d'obtenir des références à des instances de vos fragments et de les stocker sur local vars si vous avez besoin d'. N'oubliez pas de les entourer d'un ensemble de instantiateItem appels avec
startUpdate et finishUpdate méthodes décrites dans PagerAdapter javadoc:

Un appel à la PagerAdapter méthode startUpdate(ViewGroup) indique que le contenu de la ViewPager sont sur le point de changer. Un ou plusieurs appels à instantiateItem(ViewGroup, int) et/ou destroyItem(ViewGroup, int, Object) qui va suivre, et à la fin d'une mise à jour sera signalée par un appel à finishUpdate(ViewGroup).

Ainsi, par exemple, c'est la façon de stocker les références de votre onglet fragments dans onCreate méthode:

public class MyActivity extends AppCompatActivity {
Fragment0 tab0; Fragment1 tab1;
@Override protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.myLayout);
ViewPager viewPager = (ViewPager) findViewById(R.id.myViewPager);
MyPagerAdapter adapter = new MyPagerAdapter(getSupportFragmentManager());
viewPager.setAdapter(adapter);
((TabLayout) findViewById(R.id.tabs)).setupWithViewPager(viewPager);
adapter.startUpdate(viewPager);
tab0 = (Fragment0) adapter.instantiateItem(viewPager, 0);
tab1 = (Fragment1) adapter.instantiateItem(viewPager, 1);
adapter.finishUpdate(viewPager);
}
class MyPagerAdapter extends FragmentPagerAdapter {
public MyPagerAdapter(FragmentManager manager) {super(manager);}
@Override public int getCount() {return 2;}
@Override public Fragment getItem(int position) {
if (position == 0) return new Fragment0();
if (position == 1) return new Fragment1();
return null;  //or throw some exception
}
@Override public CharSequence getPageTitle(int position) {
if (position == 0) return getString(R.string.tab0);
if (position == 1) return getString(R.string.tab1);
return null;  //or throw some exception
}
}
}

instantiateItem va d'abord essayer d'obtenir des références existantes fragment d'instances de FragmentManager. Seulement si ils n'existent pas encore, il permettra de créer de nouveaux à l'aide getItem méthode de votre adaptateur et "store" dans le FragmentManager pour toute utilisation future.

Quelques informations supplémentaires:

Si vous n'appelez pas instantiateItem entouré par startUpdate/finishUpdate dans votre onCreate méthode, puis, vous risquez que votre fragment instances ne sera jamais commis à FragmentManager: quand votre activité devient premier plan instantiateItem sera appelé automatiquement pour obtenir votre des fragments, mais startUpdate/finishUpdate peut pas (selon les détails de mise en œuvre) et ce que n'est begin/commit un FragmentTransaction.

Cette peut résultat dans les références à la création de fragment d'instances de perdre très rapidement (par exemple lorsque vous faites pivoter votre écran) et recréé beaucoup plus souvent que nécessaire. Selon la façon dont "lourd" vos fragments sont, il peut avoir une partie non négligeable de la performance conséquences.

Plus important encore, cependant, dans de tels cas, les instances de fragments stockés sur local vars va devenir obsolète: depuis la plate-forme android n'a pas été en mesure d'obtenir le même cas de FragmentManager il peut créer et d'utiliser de nouvelles, tandis que votre vars va encore faire référence à l'ancien.

la solution proposée par @personne3000 est agréable, mais il a un problème: lorsque l'activité se passe à l'arrière-plan et se fait tuer par le système (afin d'obtenir une certaine quantité de mémoire disponible), puis restauré, le fragmentReferences sera vide, parce que getItem ne serait pas appelé.

La classe ci-dessous gère la situation:

public abstract class AbstractHolderFragmentPagerAdapter<F extends Fragment> extends FragmentPagerAdapter {
public static final String FRAGMENT_SAVE_PREFIX = "holder";
private final FragmentManager fragmentManager; //we need to store fragment manager ourselves, because parent's field is private and has no getters.
public AbstractHolderFragmentPagerAdapter(FragmentManager fm) {
super(fm);
fragmentManager = fm;
}
private SparseArray<WeakReference<F>> holder = new SparseArray<WeakReference<F>>();
protected void holdFragment(F fragment) {
holdFragment(holder.size(), fragment);
}
protected void holdFragment(int position, F fragment) {
if (fragment != null)
holder.put(position, new WeakReference<F>(fragment));
}
public F getHoldedItem(int position) {
WeakReference<F> ref = holder.get(position);
return ref == null ? null : ref.get();
}
public int getHolderCount() {
return holder.size();
}
@Override
public void restoreState(Parcelable state, ClassLoader loader) { //code inspired by Google's FragmentStatePagerAdapter implementation
super.restoreState(state, loader);
Bundle bundle = (Bundle) state;
for (String key : bundle.keySet()) {
if (key.startsWith(FRAGMENT_SAVE_PREFIX)) {
int index = Integer.parseInt(key.substring(FRAGMENT_SAVE_PREFIX.length()));
Fragment f = fragmentManager.getFragment(bundle, key);
holdFragment(index, (F) f);
}
}
}
@Override
public Parcelable saveState() {
Bundle state = (Bundle) super.saveState();
if (state == null)
state = new Bundle();
for (int i = 0; i < holder.size(); i++) {
int id = holder.keyAt(i);
final F f = getHoldedItem(i);
String key = FRAGMENT_SAVE_PREFIX + id;
fragmentManager.putFragment(state, key, f);
}
return state;
}
}

J'ai toujours l'utilisation de cette classe de base, quand j'ai besoin de l'accès de l'enfant fragments ou primaire (actuellement visible) fragment. Il ne repose pas sur des détails de mise en œuvre et il prend soin de changements de cycle de vie, parce que remplacé les méthodes appelées dans les deux cas - lorsqu'un nouveau fragment de l'instance créée et quand instance obtient reçu de FragmentManager.

public abstract class FragmentPagerAdapterExt extends FragmentPagerAdapter {
private final ArrayList<Fragment> mFragments;
private Fragment mPrimaryFragment;
public FragmentPagerAdapterExt(FragmentManager fm) {
super(fm);
mFragments = new ArrayList<>(getCount());
}
@Override public Object instantiateItem(ViewGroup container, int position) {
Object object = super.instantiateItem(container, position);
mFragments.add((Fragment) object);
return object;
}
@Override public void destroyItem(ViewGroup container, int position, Object object) {
mFragments.remove(object);
super.destroyItem(container, position, object);
}
@Override public void setPrimaryItem(ViewGroup container, int position, Object object) {
super.setPrimaryItem(container, position, object);
mPrimaryFragment = (Fragment) object;
}
/** Returns currently visible (primary) fragment */
public Fragment getPrimaryFragment() {
return mPrimaryFragment;
}
/** Returned list can contain null-values for not created fragments */
public List<Fragment> getFragments() {
return Collections.unmodifiableList(mFragments);
}
}

Voir ce post sur le retour des fragments de la FragmentPagerAdapter. Il compte sur vous, sachant que l'index de votre fragment - mais ce serait fixé getItem() (à l'instanciation seulement)

Ne sais pas si ma méthode est la bonne ou la meilleure façon de le faire depuis que je suis un parent débutant avec Java/Android, mais il a fait un travail (je suis sûr qu'il viole orientée objet principes, mais aucune autre solution a fonctionné pour mon cas d'utilisation).

J'ai eu une Activité d'hébergement qui a été à l'aide d'un ViewPager avec un FragmentStatePagerAdapter. Afin d'obtenir des références pour les Fragments qui ont été créés par FragmentStatePagerAdapter j'ai créé une interface de rappel dans le fragment de classe:

public interface Callbacks {
public void addFragment (Fragment fragment);
public void removeFragment (Fragment fragment);
}

Dans l'activité d'hébergement que j'ai implémenté l'interface et créé un LinkedHasSet de garder une trace des fragments:

public class HostingActivity extends AppCompatActivity implements ViewPagerFragment.Callbacks {
private LinkedHashSet<Fragment> mFragments = new LinkedHashSet<>();
@Override
public void addFragment (Fragment fragment) {
mFragments.add(fragment);
}
@Override
public void removeFragment (Fragment fragment) {
mFragments.remove(fragment);
}
}

Dans le ViewPagerFragment classe, j'ai ajouté les fragments de la liste dans les onAttach et les ont enlevés dans onDetach:

public class ViewPagerFragment extends Fragment {
private Callbacks mCallbacks;
public interface Callbacks {
public void addFragment (Fragment fragment);
public void removeFragment (Fragment fragment);
} 
@Override
public void onAttach (Context context) {
super.onAttach(context);
mCallbacks = (Callbacks) context;
//Add this fragment to the HashSet in the hosting activity
mCallbacks.addFragment(this);
}
@Override
public void onDetach() {
super.onDetach();
//Remove this fragment from the HashSet in the hosting activity
mCallbacks.removeFragment(this);
mCallbacks = null;
}
}

Au sein de l'activité d'hébergement vous allez maintenant être en mesure d'utiliser mFragments pour itérer sur les fragments qui existent actuellement dans la FragmentStatePagerAdapter.

Il suffit d'aller essayer ce code,

public class MYFragmentPAdp extends FragmentPagerAdapter {
public MYFragmentPAdp(FragmentManager fm) {
super(fm);
}
@Override
public int getCount() {
return 2;
}
@Override
public Fragment getItem(int position) {
if (position == 0)
Fragment fragment = new Fragment1();
else (position == 1)
Fragment fragment = new Fragment2();
return fragment;
}
}