ViewPager y fragmentos: ¿cuál es la forma correcta de almacenar el estado del fragmento?

Los fragmentos parecen ser muy buenos para la separación de la lógica de UI en algunos módulos. Pero junto con ViewPager su ciclo de vida sigue siendo brumoso para mí. ¡Entonces los pensamientos de Guru son muy necesarios!

Editar

Vea la solución tonta a continuación 😉

Alcance

La actividad principal tiene un ViewPager con fragmentos. Esos fragmentos podrían implementar una lógica un poco diferente para otras actividades (secundarias), por lo que los datos de los fragmentos se rellenan a través de una interfaz de callback dentro de la actividad. Y todo funciona bien en el primer lanzamiento, pero! …

Problema

Cuando la actividad se vuelve a crear (por ejemplo, en el cambio de orientación) también lo hacen los fragmentos de ViewPager . El código (que encontrará a continuación) dice que cada vez que se crea la actividad trato de crear un nuevo adaptador de fragmentos ViewPager igual que fragmentos (tal vez este es el problema) pero FragmentManager ya tiene todos estos fragmentos almacenados en algún lugar (¿dónde?) y comienza el mecanismo de recreación para aquellos. Entonces, el mecanismo de recreación llama a los fragmentos “viejos” en Conectar, en Visualizar, etc. con mi llamada de interfaz de callback para iniciar datos a través del método implementado de la Actividad. Pero este método apunta al fragmento creado recientemente que se crea mediante el método onCreate de Activity.

Problema

Tal vez estoy usando patrones incorrectos, pero incluso Android 3 Pro Book no tiene mucho sobre eso. Entonces, por favor , dame un puñetazo y señala cómo hacerlo de la manera correcta. ¡Muchas gracias!

Código

Actividad principal

 public class DashboardActivity extends BasePagerActivity implements OnMessageListActionListener { private MessagesFragment mMessagesFragment; @Override protected void onCreate(Bundle savedInstanceState) { Logger.d("Dash onCreate"); super.onCreate(savedInstanceState); setContentView(R.layout.viewpager_container); new DefaultToolbar(this); // create fragments to use mMessagesFragment = new MessagesFragment(); mStreamsFragment = new StreamsFragment(); // set titles and fragments for view pager Map screens = new LinkedHashMap(); screens.put(getApplicationContext().getString(R.string.dashboard_title_dumb), new DumbFragment()); screens.put(getApplicationContext().getString(R.string.dashboard_title_messages), mMessagesFragment); // instantiate view pager via adapter mPager = (ViewPager) findViewById(R.id.viewpager_pager); mPagerAdapter = new BasePagerAdapter(screens, getSupportFragmentManager()); mPager.setAdapter(mPagerAdapter); // set title indicator TitlePageIndicator indicator = (TitlePageIndicator) findViewById(R.id.viewpager_titles); indicator.setViewPager(mPager, 1); } /* set of fragments callback interface implementations */ @Override public void onMessageInitialisation() { Logger.d("Dash onMessageInitialisation"); if (mMessagesFragment != null) mMessagesFragment.loadLastMessages(); } @Override public void onMessageSelected(Message selectedMessage) { Intent intent = new Intent(this, StreamActivity.class); intent.putExtra(Message.class.getName(), selectedMessage); startActivity(intent); } 

BasePagerActivity aka helper

 public class BasePagerActivity extends FragmentActivity { BasePagerAdapter mPagerAdapter; ViewPager mPager; } 

Adaptador

 public class BasePagerAdapter extends FragmentPagerAdapter implements TitleProvider { private Map mScreens; public BasePagerAdapter(Map screenMap, FragmentManager fm) { super(fm); this.mScreens = screenMap; } @Override public Fragment getItem(int position) { return mScreens.values().toArray(new Fragment[mScreens.size()])[position]; } @Override public int getCount() { return mScreens.size(); } @Override public String getTitle(int position) { return mScreens.keySet().toArray(new String[mScreens.size()])[position]; } // hack. we don't want to destroy our fragments and re-initiate them after @Override public void destroyItem(View container, int position, Object object) { // TODO Auto-generated method stub } } 

Fragmento

 public class MessagesFragment extends ListFragment { private boolean mIsLastMessages; private List mMessagesList; private MessageArrayAdapter mAdapter; private LoadMessagesTask mLoadMessagesTask; private OnMessageListActionListener mListener; // define callback interface public interface OnMessageListActionListener { public void onMessageInitialisation(); public void onMessageSelected(Message selectedMessage); } @Override public void onAttach(Activity activity) { super.onAttach(activity); // setting callback mListener = (OnMessageListActionListener) activity; mIsLastMessages = activity instanceof DashboardActivity; } @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { inflater.inflate(R.layout.fragment_listview, container); mProgressView = inflater.inflate(R.layout.listrow_progress, null); mEmptyView = inflater.inflate(R.layout.fragment_nodata, null); return super.onCreateView(inflater, container, savedInstanceState); } @Override public void onActivityCreated(Bundle savedInstanceState) { super.onActivityCreated(savedInstanceState); // instantiate loading task mLoadMessagesTask = new LoadMessagesTask(); // instantiate list of messages mMessagesList = new ArrayList(); mAdapter = new MessageArrayAdapter(getActivity(), mMessagesList); setListAdapter(mAdapter); } @Override public void onResume() { mListener.onMessageInitialisation(); super.onResume(); } public void onListItemClick(ListView l, View v, int position, long id) { Message selectedMessage = (Message) getListAdapter().getItem(position); mListener.onMessageSelected(selectedMessage); super.onListItemClick(l, v, position, id); } /* public methods to load messages from host acitivity, etc... */ } 

Solución

La solución tonta es guardar los fragmentos dentro de SaveInstanceState (de la actividad del host) con putFragment y obtenerlos en onCreate a través de getFragment. Pero todavía tengo la extraña sensación de que las cosas no deberían funcionar así … Ver código a continuación:

  @Override protected void onSaveInstanceState(Bundle outState) { super.onSaveInstanceState(outState); getSupportFragmentManager() .putFragment(outState, MessagesFragment.class.getName(), mMessagesFragment); } protected void onCreate(Bundle savedInstanceState) { Logger.d("Dash onCreate"); super.onCreate(savedInstanceState); ... // create fragments to use if (savedInstanceState != null) { mMessagesFragment = (MessagesFragment) getSupportFragmentManager().getFragment( savedInstanceState, MessagesFragment.class.getName()); StreamsFragment.class.getName()); } if (mMessagesFragment == null) mMessagesFragment = new MessagesFragment(); ... } 

Cuando FragmentPagerAdapter agrega un fragmento al FragmentManager, usa una etiqueta especial basada en la posición particular en la que se colocará el fragmento. FragmentPagerAdapter.getItem(int position) solo se invoca cuando no existe un fragmento para esa posición. Después de rotar, Android notará que ya creó / guardó un fragmento para esta posición en particular y, por lo tanto, simplemente intenta reconectarse con él con FragmentManager.findFragmentByTag() , en lugar de crear uno nuevo. Todo esto es gratis cuando se utiliza FragmentPagerAdapter y es por eso que es habitual tener el código de inicialización de fragmentos dentro del getItem(int) .

Incluso si no estuviéramos utilizando un FragmentPagerAdapter , no es una buena idea crear un nuevo fragmento cada vez en Activity.onCreate(Bundle) . Como habrás notado, cuando se agrega un fragmento al FragmentManager, se volverá a crear para ti después de rotar y no hay necesidad de agregarlo nuevamente. Hacerlo es una causa común de errores cuando se trabaja con fragmentos.

Un enfoque habitual cuando se trabaja con fragmentos es este:

 protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); ... CustomFragment fragment; if (savedInstanceState != null) { fragment = (CustomFragment) getSupportFragmentManager().findFragmentByTag("customtag"); } else { fragment = new CustomFragment(); getSupportFragmentManager().beginTransaction().add(R.id.container, fragment, "customtag").commit(); } ... } 

Al usar un FragmentPagerAdapter , renunciamos a la administración de fragmentos en el adaptador, y no es necesario que realice los pasos anteriores. De forma predeterminada, solo precargará un Fragmento delante y detrás de la posición actual (aunque no los destruirá a menos que esté utilizando FragmentStatePagerAdapter ). Esto está controlado por ViewPager.setOffscreenPageLimit (int) . Debido a esto, no se garantiza que los métodos de llamada directa en los fragmentos fuera del adaptador sean válidos, ya que es posible que ni siquiera estén activos.

Para abreviar, su solución para usar putFragment para poder obtener una referencia después no es tan disparatada, y no tan diferente de la manera normal de usar fragmentos de todos modos (arriba). De lo contrario, es difícil obtener una referencia porque el fragmento es agregado por el adaptador y no tú personalmente. Solo asegúrese de que el offscreenPageLimit sea ​​lo suficientemente alto como para cargar los fragmentos deseados en todo momento, ya que depende de que esté presente. Esto evita las capacidades de carga lenta de ViewPager, pero parece ser lo que desea para su aplicación.

Otro enfoque es anular FragmentPageAdapter.instantiateItem(View, int) y guardar una referencia al fragmento devuelto por la super llamada antes de devolverlo (tiene la lógica para encontrar el fragmento, si ya está presente).

Para una imagen más completa, eche un vistazo a algunas de las fonts de FragmentPagerAdapter (short) y ViewPager (long).

Deseo ofrecer una solución que amplíe la maravillosa respuesta de antonyt y mencionar el reemplazo de FragmentPageAdapter.instantiateItem(View, int) para guardar las referencias a los Fragments creados para que pueda trabajar en ellos más adelante. Esto también debería funcionar con FragmentStatePagerAdapter ; ver notas para más detalles.


Aquí hay un ejemplo simple de cómo obtener una referencia a los Fragments devueltos por FragmentPagerAdapter que no depende de las tags internas establecidas en los Fragments . La clave es anular instantiateItem() y guardar referencias allí en lugar de en getItem() .

 public class SomeActivity extends Activity { private FragmentA m1stFragment; private FragmentB m2ndFragment; // other code in your Activity... private class CustomPagerAdapter extends FragmentPagerAdapter { // other code in your custom FragmentPagerAdapter... public CustomPagerAdapter(FragmentManager fm) { super(fm); } @Override public Fragment getItem(int position) { // Do NOT try to save references to the Fragments in getItem(), // because getItem() is not always called. If the Fragment // was already created then it will be retrieved from the FragmentManger // and not here (ie getItem() won't be called again). switch (position) { case 0: return new FragmentA(); case 1: return new FragmentB(); default: // This should never happen. Always account for each position above return null; } } // Here we can finally safely save a reference to the created // Fragment, no matter where it came from (either getItem() or // FragmentManger). Simply save the returned Fragment from // super.instantiateItem() into an appropriate reference depending // on the ViewPager position. @Override public Object instantiateItem(ViewGroup container, int position) { Fragment createdFragment = (Fragment) super.instantiateItem(container, position); // save the appropriate reference depending on position switch (position) { case 0: m1stFragment = (FragmentA) createdFragment; break; case 1: m2ndFragment = (FragmentB) createdFragment; break; } return createdFragment; } } public void someMethod() { // do work on the referenced Fragments, but first check if they // even exist yet, otherwise you'll get an NPE. if (m1stFragment != null) { // m1stFragment.doWork(); } if (m2ndFragment != null) { // m2ndFragment.doSomeWorkToo(); } } } 

o si prefiere trabajar con tags lugar de variables de miembro de clase / referencias a los Fragments , también puede tomar las tags establecidas por FragmentPagerAdapter de la misma manera: NOTA: esto no se aplica a FragmentStatePagerAdapter ya que no establece tags al crear sus Fragments .

 @Override public Object instantiateItem(ViewGroup container, int position) { Fragment createdFragment = (Fragment) super.instantiateItem(container, position); // get the tags set by FragmentPagerAdapter switch (position) { case 0: String firstTag = createdFragment.getTag(); break; case 1: String secondTag = createdFragment.getTag(); break; } // ... save the tags somewhere so you can reference them later return createdFragment; } 

Tenga en cuenta que este método NO se basa en imitar la tag interna establecida por FragmentPagerAdapter y en su lugar utiliza las API adecuadas para recuperarlos. De esta forma, incluso si la tag cambia en futuras versiones de SupportLibrary , estará a salvo.


No olvide que, dependiendo del diseño de su Activity , los Fragments que está tratando de trabajar pueden o no existir aún, por lo que tiene que dar cuenta de ello haciendo comprobaciones null antes de usar sus referencias.

Además, si en cambio estás trabajando con FragmentStatePagerAdapter , entonces no querrás mantener referencias difíciles a tus Fragments porque podrías tener muchos de ellos y las referencias difíciles los mantendrían innecesariamente en la memoria. En su lugar, guarde las referencias al Fragment en WeakReference variables WeakReference en lugar de las estándar. Me gusta esto:

 WeakReference m1stFragment = new WeakReference(createdFragment); // ...and access them like so Fragment firstFragment = m1stFragment.get(); if (firstFragment != null) { // reference hasn't been cleared yet; do work... } 

Encontré otra solución relativamente fácil para tu pregunta.

Como puede ver en el código fuente FragmentPagerAdapter , los fragmentos gestionados por FragmentPagerAdapter almacenan en FragmentManager bajo la etiqueta generada usando:

 String tag="android:switcher:" + viewId + ":" + index; 

viewId es container.getId() , el container es su instancia de ViewPager . El index es la posición del fragmento. Por lo tanto, puede guardar el id del objeto en outState :

 @Override protected void onSaveInstanceState(Bundle outState) { super.onSaveInstanceState(outState); outState.putInt("viewpagerid" , mViewPager.getId() ); } @Override protected void onCreate(Bundle savedInstanceState) { setContentView(R.layout.activity_main); if (savedInstanceState != null) viewpagerid=savedInstanceState.getInt("viewpagerid", -1 ); MyFragmentPagerAdapter titleAdapter = new MyFragmentPagerAdapter (getSupportFragmentManager() , this); mViewPager = (ViewPager) findViewById(R.id.pager); if (viewpagerid != -1 ){ mViewPager.setId(viewpagerid); }else{ viewpagerid=mViewPager.getId(); } mViewPager.setAdapter(titleAdapter); 

Si desea comunicarse con este fragmento, puede obtenerlo de FragmentManager , como:

 getSupportFragmentManager().findFragmentByTag("android:switcher:" + viewpagerid + ":0") 

Quiero ofrecer una solución alternativa para tal vez un caso ligeramente diferente, ya que muchas de mis búsquedas de respuestas siguieron guiándome hasta este hilo.

Mi caso : estoy creando / agregando páginas dinámicamente y deslizándolas en una ViewPager, pero cuando se rotan (enConfigurationChange) termino con una nueva página porque, por supuesto, se llama nuevamente a OnCreate. Pero quiero mantener una referencia a todas las páginas que se crearon antes de la rotación.

Problema : no tengo identificadores únicos para cada fragmento que creo, por lo que la única forma de referencia era almacenar de alguna manera las referencias en una matriz para restaurar después del cambio de rotación / configuración.

Solución alternativa : el concepto clave era que la Actividad (que muestra los Fragmentos) también administre la matriz de referencias a Fragmentos existentes, ya que esta actividad puede utilizar Bundles en onSaveInstanceState

 public class MainActivity extends FragmentActivity 

Entonces, dentro de esta Actividad, declaro que un miembro privado rastrea las páginas abiertas

 private List retainedPages = new ArrayList(); 

Esto se actualiza cada vez que se llama y restaura SaveStanceState en onCreate

 @Override protected void onSaveInstanceState(Bundle outState) { retainedPages = _adapter.exportList(); outState.putSerializable("retainedPages", (Serializable) retainedPages); super.onSaveInstanceState(outState); } 

… así que una vez que se almacena, se puede recuperar …

 @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); if (savedInstanceState != null) { retainedPages = (List) savedInstanceState.getSerializable("retainedPages"); } _mViewPager = (CustomViewPager) findViewById(R.id.viewPager); _adapter = new ViewPagerAdapter(getApplicationContext(), getSupportFragmentManager()); if (retainedPages.size() > 0) { _adapter.importList(retainedPages); } _mViewPager.setAdapter(_adapter); _mViewPager.setCurrentItem(_adapter.getCount()-1); } 

Estos fueron los cambios necesarios para la actividad principal, por lo que necesitaba los miembros y los métodos dentro de mi FragmentPagerAdapter para que esto funcione, por lo que dentro

 public class ViewPagerAdapter extends FragmentPagerAdapter 

una construcción idéntica (como se muestra arriba en MainActivity)

 private List _pages = new ArrayList(); 

y esta sincronización (como se utilizó anteriormente en onSaveInstanceState) es compatible específicamente con los métodos

 public List exportList() { return _pages; } public void importList(List savedPages) { _pages = savedPages; } 

Y finalmente, en la clase de fragmento

 public class CustomFragment extends Fragment 

Para que todo esto funcione, hubo dos cambios, primero

 public class CustomFragment extends Fragment implements Serializable 

y luego agregar esto a onCreate para que los fragmentos no se destruyan

 setRetainInstance(true); 

Todavía estoy en el proceso de abarcar los Fragmentos y el ciclo de vida de Android, por lo que es posible que existan redundancias / ineficiencias en este método. Pero funciona para mí y espero que pueda ser útil para otros con casos similares a los míos.

Mi solución es muy grosera pero funciona: siendo mis fragmentos creados dinámicamente a partir de datos retenidos, simplemente PageAdapter todos los fragmentos del PageAdapter antes de llamar a super.onSaveInstanceState() y luego los super.onSaveInstanceState() crear en la creación de actividades:

 @Override protected void onSaveInstanceState(Bundle outState) { outState.putInt("viewpagerpos", mViewPager.getCurrentItem() ); mSectionsPagerAdapter.removeAllfragments(); super.onSaveInstanceState(outState); } 

No puede eliminarlos en onDestroy() ; de lo contrario, obtendrá esta excepción:

java.lang.IllegalStateException: no se puede realizar esta acción después de onSaveInstanceState

Aquí el código en el adaptador de página:

 public void removeAllfragments() { if ( mFragmentList != null ) { for ( Fragment fragment : mFragmentList ) { mFm.beginTransaction().remove(fragment).commit(); } mFragmentList.clear(); notifyDataSetChanged(); } } 

Solo onCreate() la página actual y la restauro en onCreate() , después de que los fragmentos hayan sido creados.

 if (savedInstanceState != null) mViewPager.setCurrentItem( savedInstanceState.getInt("viewpagerpos", 0 ) ); 

¿Qué es ese BasePagerAdapter ? Debería utilizar uno de los adaptadores de buscapersonas estándar, ya sea FragmentPagerAdapter o FragmentStatePagerAdapter , dependiendo de si desea que los fragmentos que ya no necesite el ViewPager se mantengan (el primero) o que se guarde su estado (el último) y se re guarden. -creada si es necesario nuevamente.

El código de muestra para usar ViewPager se puede encontrar aquí

Es cierto que la administración de fragmentos en un localizador de vistas a través de instancias de actividad es un poco complicado, porque FragmentManager en el marco se ocupa de guardar el estado y restaurar cualquier fragmento activo que el localizador haya creado. Todo esto realmente significa que el adaptador al inicializarse necesita asegurarse de que se vuelva a conectar con los fragmentos restaurados que haya. Puede ver el código de FragmentPagerAdapter o FragmentStatePagerAdapter para ver cómo se hace esto.

Si alguien tiene problemas con su FragmentStatePagerAdapter que no restaura correctamente el estado de sus fragmentos … es decir … FragmentStatePagerAdapter está creando Fragmentos nuevos en lugar de restaurarlos desde el estado …

Asegúrese de llamar a ViewPager.setOffscreenPageLimit() ANTES de llamar a ViewPager.setAdapeter(fragmentStatePagerAdapter)

Al llamar a ViewPager.setOffscreenPageLimit() … el ViewPager buscará inmediatamente su adaptador e intentará obtener sus fragmentos. Esto podría suceder antes de que ViewPager tenga la posibilidad de restaurar los Fragments desde savedInstanceState (creando así nuevos Fragmentos que no pueden ser reinicializados desde SavedInstanceState porque son nuevos).

Se me ocurrió esta solución simple y elegante. Asume que la actividad es responsable de crear los Fragmentos, y el Adaptador simplemente los sirve.

Este es el código del adaptador (nada extraño aquí, excepto por el hecho de que mFragments es una lista de fragmentos mantenidos por la Actividad)

 class MyFragmentPagerAdapter extends FragmentStatePagerAdapter { public MyFragmentPagerAdapter(FragmentManager fm) { super(fm); } @Override public Fragment getItem(int position) { return mFragments.get(position); } @Override public int getCount() { return mFragments.size(); } @Override public int getItemPosition(Object object) { return POSITION_NONE; } @Override public CharSequence getPageTitle(int position) { TabFragment fragment = (TabFragment)mFragments.get(position); return fragment.getTitle(); } } 

Todo el problema de este hilo es obtener una referencia de los fragmentos “antiguos”, así que uso este código en Activity onCreate.

  if (savedInstanceState!=null) { if (getSupportFragmentManager().getFragments()!=null) { for (Fragment fragment : getSupportFragmentManager().getFragments()) { mFragments.add(fragment); } } } 

Por supuesto, puedes afinar aún más este código si es necesario, por ejemplo asegurándote de que los fragmentos sean instancias de una clase en particular.

Para obtener los fragmentos después de cambiar la orientación, debe usar .getTag ().

  getSupportFragmentManager().findFragmentByTag("android:switcher:" + viewPagerId + ":" + positionOfItemInViewPager) 

Para un manejo un poco más, escribí mi propia ArrayList para mi PageAdapter para obtener el fragmento de viewPagerId y FragmentClass en cualquier posición:

 public class MyPageAdapter extends FragmentPagerAdapter implements Serializable { private final String logTAG = MyPageAdapter.class.getName() + "."; private ArrayList fragmentPages; public MyPageAdapter(FragmentManager fm, ArrayList fragments) { super(fm); fragmentPages = fragments; } @Override public Fragment getItem(int position) { return this.fragmentPages.get(position).getFragment(); } @Override public CharSequence getPageTitle(int position) { return this.fragmentPages.get(position).getPageTitle(); } @Override public int getCount() { return this.fragmentPages.size(); } public int getItemPosition(Object object) { //benötigt, damit bei notifyDataSetChanged alle Fragemnts refrehsed werden Log.d(logTAG, object.getClass().getName()); return POSITION_NONE; } public Fragment getFragment(int position) { return getItem(position); } public String getTag(int position, int viewPagerId) { //getSupportFragmentManager().findFragmentByTag("android:switcher:" + R.id.shares_detail_activity_viewpager + ":" + myViewPager.getCurrentItem()) return "android:switcher:" + viewPagerId + ":" + position; } public MyPageBuilder getPageBuilder(String pageTitle, int icon, int selectedIcon, Fragment frag) { return new MyPageBuilder(pageTitle, icon, selectedIcon, frag); } public static class MyPageBuilder { private Fragment fragment; public Fragment getFragment() { return fragment; } public void setFragment(Fragment fragment) { this.fragment = fragment; } private String pageTitle; public String getPageTitle() { return pageTitle; } public void setPageTitle(String pageTitle) { this.pageTitle = pageTitle; } private int icon; public int getIconUnselected() { return icon; } public void setIconUnselected(int iconUnselected) { this.icon = iconUnselected; } private int iconSelected; public int getIconSelected() { return iconSelected; } public void setIconSelected(int iconSelected) { this.iconSelected = iconSelected; } public MyPageBuilder(String pageTitle, int icon, int selectedIcon, Fragment frag) { this.pageTitle = pageTitle; this.icon = icon; this.iconSelected = selectedIcon; this.fragment = frag; } } public static class MyPageArrayList extends ArrayList { private final String logTAG = MyPageArrayList.class.getName() + "."; public MyPageBuilder get(Class cls) { // Fragment über FragmentClass holen for (MyPageBuilder item : this) { if (item.fragment.getClass().getName().equalsIgnoreCase(cls.getName())) { return super.get(indexOf(item)); } } return null; } public String getTag(int viewPagerId, Class cls) { // Tag des Fragment unabhängig vom State zB nach bei Orientation change for (MyPageBuilder item : this) { if (item.fragment.getClass().getName().equalsIgnoreCase(cls.getName())) { return "android:switcher:" + viewPagerId + ":" + indexOf(item); } } return null; } } 

Así que solo crea una MyPageArrayList con los fragmentos:

  myFragPages = new MyPageAdapter.MyPageArrayList(); myFragPages.add(new MyPageAdapter.MyPageBuilder( getString(R.string.widget_config_data_frag), R.drawable.ic_sd_storage_24dp, R.drawable.ic_sd_storage_selected_24dp, new WidgetDataFrag())); myFragPages.add(new MyPageAdapter.MyPageBuilder( getString(R.string.widget_config_color_frag), R.drawable.ic_color_24dp, R.drawable.ic_color_selected_24dp, new WidgetColorFrag())); myFragPages.add(new MyPageAdapter.MyPageBuilder( getString(R.string.widget_config_textsize_frag), R.drawable.ic_settings_widget_24dp, R.drawable.ic_settings_selected_24dp, new WidgetTextSizeFrag())); 

y agréguelos a viewPager:

  mAdapter = new MyPageAdapter(getSupportFragmentManager(), myFragPages); myViewPager.setAdapter(mAdapter); 

después de esto puedes obtener después de la orientación cambiar el fragmento correcto usando su clase:

  WidgetDataFrag dataFragment = (WidgetDataFrag) getSupportFragmentManager() .findFragmentByTag(myFragPages.getTag(myViewPager.getId(), WidgetDataFrag.class)); 

añadir:

  @SuppressLint("ValidFragment") 

antes de tu clase.

Si no funciona, haz algo como esto:

 @SuppressLint({ "ValidFragment", "HandlerLeak" })