Fragmento de Android: cómo guardar estados de vistas en un fragmento cuando se empuja otro fragmento sobre él

En Android, un fragmento (por ejemplo FragA) se agrega a la pila y otro fragmento (por ejemplo FragB) llega a la parte superior. Ahora al devolver el golpe FragAllega a la cima y onCreateView()se llama. Ahora me encontraba FragAen un estado particular antes de que FragBme pusieran encima.

Mi pregunta es ¿cómo puedo restaurar FragAa su estado anterior? ¿Hay alguna manera de guardar el estado (como decir en un paquete) y, de ser así, ¿qué método debo anular?

En el ejemplo de FragmentList de la guía de fragmentos puedes encontrar:

@Override
public void onSaveInstanceState(Bundle outState) {
    super.onSaveInstanceState(outState);
    outState.putInt("curChoice", mCurCheckPosition);
}

Que puedes usar más tarde así:

@Override
public void onActivityCreated(Bundle savedInstanceState) {
    super.onActivityCreated(savedInstanceState);
    if (savedInstanceState != null) {
        // Restore last state for checked position.
        mCurCheckPosition = savedInstanceState.getInt("curChoice", 0);
    }
}

Soy un principiante en Fragments pero parece que es la solución de su problema;) OnActivityCreated se invoca después de que el fragmento vuelve de la pila posterior.

Los fragmentos onSaveInstanceState(Bundle outState)nunca se llamarán a menos que la actividad del fragmento lo llame a sí mismo y a los fragmentos adjuntos. Por lo tanto, este método no se llamará hasta que algo (generalmente rotación) fuerce la actividad SaveInstanceStatey la restaure más tarde. Pero si solo tiene una actividad y un gran conjunto de fragmentos dentro de ella (con un uso intensivo de replace) y la aplicación se ejecuta solo en una orientación, es onSaveInstanceState(Bundle outState)posible que no se llame durante mucho tiempo.

Sé tres posibles soluciones alternativas.

El primero:

use argumentos de fragmentos para contener datos importantes:

public class FragmentA extends Fragment {
    private static final String PERSISTENT_VARIABLE_BUNDLE_KEY = "persistentVariable";

    private EditText persistentVariableEdit;

    public FragmentA() {
        setArguments(new Bundle());
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        View view = inflater.inflate(R.layout.fragment_a, null);

        persistentVariableEdit = (EditText) view.findViewById(R.id.editText);

        TextView proofTextView = (TextView) view.findViewById(R.id.textView);

        Bundle mySavedInstanceState = getArguments();
        String persistentVariable = mySavedInstanceState.getString(PERSISTENT_VARIABLE_BUNDLE_KEY);

        proofTextView.setText(persistentVariable);


        view.findViewById(R.id.btnPushFragmentB).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                getFragmentManager()
                        .beginTransaction()
                        .replace(R.id.frameLayout, new FragmentB())
                        .addToBackStack(null)
                        .commit();
            }
        });

        return view;
    }

    @Override
    public void onPause() {
        super.onPause();
        String persistentVariable = persistentVariableEdit.getText().toString();

        getArguments().putString(PERSISTENT_VARIABLE_BUNDLE_KEY, persistentVariable);
    }
}

La segunda pero menos pedante forma: mantenga las variables en singletons

El tercero: no replace()fragmentes sino add()/ show()/ hide()ellos en su lugar.

Solo tenga en cuenta que si trabaja con Fragments usando ViewPager, es bastante fácil. Sólo tiene que llamar a este método: setOffscreenPageLimit().

Acordar a los documentos:

Establezca el número de páginas que se deben conservar a ambos lados de la página actual en la jerarquía de vistas en un estado inactivo. Las páginas más allá de este límite se recrearán desde el adaptador cuando sea necesario.

Problema similar aquí

Simplemente infle su Vista por una vez.

Ejemplo sigue:

public class AFragment extends Fragment {

private View mRootView;
@Nullable
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    if(mRootView==null){
        mRootView = inflater.inflate(R.id.fragment_a, container, false);
        //......
    }
    return mRootView;
}

}

Trabajé con un problema muy similar a este. Como sabía que volvería con frecuencia a un fragmento anterior, verifiqué si el fragmento .isAdded()era verdadero, y si es así, en lugar de hacer un transaction.replace()solo hago un transaction.show(). Esto evita que el fragmento se vuelva a crear si ya está en la pila, sin necesidad de guardar el estado.

Fragment target = <my fragment>;
FragmentTransaction transaction = getFragmentManager().beginTransaction();
transaction.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_OPEN);
if(target.isAdded()) {
    transaction.show(target);
} else {
    transaction.addToBackStack(button_id + "stack_item");
    transaction.replace(R.id.page_fragment, target);
}
transaction.commit();

Otra cosa a tener en cuenta es que, si bien esto preserva el orden natural de los fragmentos, es posible que aún necesite manejar la actividad en sí misma que se destruye y recrea en el cambio de orientación (configuración). Para solucionar esto en AndroidManifest.xml para su nodo:

android:configChanges="orientation|screenSize"

En Android 3.0 y superior, screenSizeaparentemente se requiere.

Buena suerte

La mejor solución que encontré está a continuación:

onSavedInstanceState (): siempre se llama dentro del fragmento cuando la actividad se va a cerrar (mover la actividad de una a otra o cambiar la configuración). Entonces, si estamos llamando a varios fragmentos en la misma actividad, entonces tenemos que usar el siguiente enfoque:

Use OnDestroyView () del fragmento y guarde todo el objeto dentro de ese método. Luego OnActivityCreated (): compruebe que si el objeto es nulo o no (porque este método llama cada vez). Ahora restaure el estado de un objeto aquí.

¡Funciona siempre!

si está manejando los cambios de configuración en su actividad de fragmento especificada en el manifiesto de Android como este

<activity
    android:name=".courses.posts.EditPostActivity"
    android:configChanges="keyboardHidden|orientation"
    android:screenOrientation="unspecified" />

entonces onSaveInstanceStateno se invocará el fragmento y el savedInstanceStateobjeto siempre será nulo.

No creo que onSaveInstanceStatesea ​​una buena solución. solo se usa para actividades que habían sido destruidas.

Desde Android 3.0, Fragmen ha sido administrado por FragmentManager, la condición es: una actividad que mapea muchos fragmentos, cuando el fragmento se agrega (no reemplaza: se volverá a crear) en backStack, la vista se destruirá. cuando regrese al último, se mostrará como antes.

Así que creo que el fragmentManger y la transacción son lo suficientemente buenos como para manejarlo.

Usé un enfoque híbrido para fragmentos que contienen una vista de lista. Parece ser rentable ya que no reemplazo el fragmento actual, sino que agrego el nuevo fragmento y oculto el actual. Tengo el siguiente método en la actividad que aloja mis fragmentos:

public void addFragment(Fragment currentFragment, Fragment targetFragment, String tag) {
    FragmentManager fragmentManager = getSupportFragmentManager();
    FragmentTransaction transaction = fragmentManager.beginTransaction();
    transaction.setCustomAnimations(0,0,0,0);
    transaction.hide(currentFragment);
    // use a fragment tag, so that later on we can find the currently displayed fragment
    transaction.add(R.id.frame_layout, targetFragment, tag)
            .addToBackStack(tag)
            .commit();
}

Utilizo este método en mi fragmento (que contiene la vista de lista) cada vez que se hace clic / se toca un elemento de la lista (y, por lo tanto, necesito iniciar / mostrar el fragmento de detalles):

FragmentManager fragmentManager = getActivity().getSupportFragmentManager();
SearchFragment currentFragment = (SearchFragment) fragmentManager.findFragmentByTag(getFragmentTags()[0]);
DetailsFragment detailsFragment = DetailsFragment.newInstance("some object containing some details");
((MainActivity) getActivity()).addFragment(currentFragment, detailsFragment, "Details");

getFragmentTags()devuelve una matriz de cadenas que uso como etiquetas para diferentes fragmentos cuando agrego un nuevo fragmento (vea el transaction.addmétodo en el addFragmentmétodo anterior).

En el fragmento que contiene la vista de lista, hago esto en su método onPause ():

@Override
public void onPause() {
    // keep the list view's state in memory ("save" it) 
    // before adding a new fragment or replacing current fragment with a new one
    ListView lv =  (ListView) getActivity().findViewById(R.id.listView);
    mListViewState = lv.onSaveInstanceState();
    super.onPause();
}

Luego, en onCreateView del fragmento (en realidad en un método que se invoca en onCreateView), restauro el estado:

// Restore previous state (including selected item index and scroll position)
if(mListViewState != null) {
    Log.d(TAG, "Restoring the listview's state.");
    lv.onRestoreInstanceState(mListViewState);
}

Al final, después de probar muchas de estas soluciones complicadas, ya que solo necesitaba guardar / restaurar un solo valor en mi Fragmento (el contenido de un EditText), y aunque podría no ser la solución más elegante, crear una referencia compartida y almacenar mi estado a mi me funciono

Una forma sencilla de mantener los valores de los campos en diferentes fragmentos de una actividad.

Cree las instancias de fragmentos y agregue en lugar de reemplazar y eliminar

    FragA  fa= new FragA();
    FragB  fb= new FragB();
    FragC  fc= new FragB();
    fragmentManager = getSupportFragmentManager();
    fragmentTransaction = fragmentManager.beginTransaction();
    fragmentTransaction.add(R.id.fragmnt_container, fa);
    fragmentTransaction.add(R.id.fragmnt_container, fb);
    fragmentTransaction.add(R.id.fragmnt_container, fc);
    fragmentTransaction.show(fa);
    fragmentTransaction.hide(fb);
    fragmentTransaction.hide(fc);
    fragmentTransaction.commit();

Luego solo muestra y oculta los fragmentos en lugar de agregarlos y eliminarlos nuevamente

    fragmentTransaction = fragmentManager.beginTransaction();
    fragmentTransaction.hide(fa);
    fragmentTransaction.show(fb);
    fragmentTransaction.hide(fc);
    fragmentTransaction.commit()

;

private ViewPager viewPager;
viewPager = (ViewPager) findViewById(R.id.pager);
mAdapter = new TabsPagerAdapter(getSupportFragmentManager());
viewPager.setAdapter(mAdapter);
viewPager.setOnPageChangeListener(new ViewPager.OnPageChangeListener() {

        @Override
        public void onPageSelected(int position) {
            // on changing the page
            // make respected tab selected
            actionBar.setSelectedNavigationItem(position);
        }

        @Override
        public void onPageScrolled(int arg0, float arg1, int arg2) {
        }

        @Override
        public void onPageScrollStateChanged(int arg0) {
        }
    });
}

@Override
public void onTabReselected(Tab tab, FragmentTransaction ft) {
}

@Override
public void onTabSelected(Tab tab, FragmentTransaction ft) {
    // on tab selected
    // show respected fragment view
    viewPager.setCurrentItem(tab.getPosition());
}

@Override
public void onTabUnselected(Tab tab, FragmentTransaction ft) {
}