¿Cómo guardar correctamente el estado de instancia de Fragments en el back stack?

He encontrado muchas instancias de una pregunta similar sobre SO, pero desafortunadamente ninguna respuesta cumple con mis requisitos.

Tengo diferentes diseños para retrato y paisaje y estoy usando back stack, lo que me impide usar setRetainState()y trucos usando rutinas de cambio de configuración.

Muestro cierta información al usuario en TextViews, que no se guardan en el controlador predeterminado. Al escribir mi solicitud únicamente con Actividades, lo siguiente funcionó bien:

TextView vstup;

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.whatever);
    vstup = (TextView)findViewById(R.id.whatever);
    /* (...) */
}

@Override
public void onSaveInstanceState(Bundle state) {
    super.onSaveInstanceState(state);
    state.putCharSequence(App.VSTUP, vstup.getText());
}

@Override
public void onRestoreInstanceState(Bundle state) {
    super.onRestoreInstanceState(state);
    vstup.setText(state.getCharSequence(App.VSTUP));
}

Con Fragments, esto funciona solo en situaciones muy específicas. Específicamente, lo que se rompe horriblemente es reemplazar un fragmento, colocarlo en la pila posterior y luego girar la pantalla mientras se muestra el nuevo fragmento. Por lo que entendí, el antiguo fragmento no recibe una llamada onSaveInstanceState()cuando se reemplaza, pero permanece vinculado de alguna manera al Activityy este método se llama más tarde cuando Viewya no existe, por lo que busca cualquiera de mis TextViewresultados en a NullPointerException.

Además, descubrí que mantener la referencia a mi TextViewsno es una buena idea con Fragments, incluso si estaba bien con Activitys. En ese caso, en onSaveInstanceState()realidad guarda el estado, pero el problema vuelve a aparecer si giro la pantalla dos veces cuando el fragmento está oculto, ya onCreateView()que no se llama en la nueva instancia.

Pensé en salvar el estado en el onDestroyView()en algún Bundleelemento de miembro de la clase de tipo (en realidad es más datos, no sólo uno TextView) y el ahorro que en onSaveInstanceState()pero hay otros inconvenientes. Principalmente, si el fragmento se muestra actualmente, el orden de invocar las dos funciones se invierte, por lo que necesitaría tener en cuenta dos situaciones diferentes. ¡Debe haber una solución más limpia y correcta!

Para guardar correctamente el estado de la instancia Fragment, debe hacer lo siguiente:

1. En el fragmento, guarde el estado de instancia anulando onSaveInstanceState()y restaurando en onActivityCreated():

class MyFragment extends Fragment {

    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        ...
        if (savedInstanceState != null) {
            //Restore the fragment's state here
        }
    }
    ...
    @Override
    public void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);

        //Save the fragment's state here
    }

}

2. Y un punto importante , en la actividad, debe guardar la instancia del fragmento onSaveInstanceState()y restaurarla onCreate().

class MyActivity extends Activity {

    private MyFragment 

    public void onCreate(Bundle savedInstanceState) {
        ...
        if (savedInstanceState != null) {
            //Restore the fragment's instance
            mMyFragment = getSupportFragmentManager().getFragment(savedInstanceState, "myFragmentName");
            ...
        }
        ...
    }

    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);

        //Save the fragment's instance
        getSupportFragmentManager().putFragment(outState, "myFragmentName", mMyFragment);
    }

}

Espero que esto ayude.

Esta es la forma en que estoy usando en este momento ... es muy complicado, pero al menos maneja todas las situaciones posibles. En caso de que alguien esté interesado.

public final class MyFragment extends Fragment {
    private TextView vstup;
    private Bundle savedState = null;

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        View v = inflater.inflate(R.layout.whatever, null);
        vstup = (TextView)v.findViewById(R.id.whatever);

        /* (...) */

        /* If the Fragment was destroyed inbetween (screen rotation), we need to recover the savedState first */
        /* However, if it was not, it stays in the instance from the last onDestroyView() and we don't want to overwrite it */
        if(savedInstanceState != null && savedState == null) {
            savedState = savedInstanceState.getBundle(App.STAV);
        }
        if(savedState != null) {
            vstup.setText(savedState.getCharSequence(App.VSTUP));
        }
        savedState = null;

        return v;
    }

    @Override
    public void onDestroyView() {
        super.onDestroyView();
        savedState = saveState(); /* vstup defined here for sure */
        vstup = null;
    }

    private Bundle saveState() { /* called either from onDestroyView() or onSaveInstanceState() */
        Bundle state = new Bundle();
        state.putCharSequence(App.VSTUP, vstup.getText());
        return state;
    }

    @Override
    public void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        /* If onDestroyView() is called first, we can use the previously savedState but we can't call saveState() anymore */
        /* If onSaveInstanceState() is called first, we don't have savedState, so we need to call saveState() */
        /* => (?:) operator inevitable! */
        outState.putBundle(App.STAV, (savedState != null) ? savedState : saveState());
    }

    /* (...) */

}

Alternativamente , siempre es posible mantener los datos mostrados en Views pasivos en variables y usar los Views solo para mostrarlos, manteniendo las dos cosas sincronizadas. Sin embargo, no considero que la última parte esté muy limpia.

En la última biblioteca de soporte, ninguna de las soluciones discutidas aquí es necesaria. Puedes jugar con tus Activityfragmentos como quieras usando el FragmentTransaction. Solo asegúrese de que sus fragmentos puedan identificarse con una identificación o etiqueta.

Los fragmentos se restaurarán automáticamente siempre que no intentes recrearlos en cada llamada a onCreate(). En su lugar, debe verificar si savedInstanceStateno es nulo y encontrar las referencias antiguas a los fragmentos creados en este caso.

Aquí hay un ejemplo:

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    if (savedInstanceState == null) {
        myFragment = MyFragment.newInstance();
        getSupportFragmentManager()
                .beginTransaction()
                .add(R.id.my_container, myFragment, MY_FRAGMENT_TAG)
                .commit();
    } else {
        myFragment = (MyFragment) getSupportFragmentManager()
                .findFragmentByTag(MY_FRAGMENT_TAG);
    }
...
}

Sin embargo, tenga en cuenta que actualmente hay un error al restaurar el estado oculto de un fragmento. Si está ocultando fragmentos en su actividad, deberá restaurar este estado manualmente en este caso.

Solo quiero dar la solución que se me ocurrió que maneja todos los casos presentados en esta publicación que obtuve de Vasek y devconsole. Esta solución también maneja el caso especial cuando el teléfono se gira más de una vez mientras los fragmentos no son visibles.

Aquí es donde guardo el paquete para su uso posterior ya que onCreate y onSaveInstanceState son las únicas llamadas que se realizan cuando el fragmento no es visible

MyObject myObject;
private Bundle savedState = null;
private boolean createdStateInDestroyView;
private static final String SAVED_BUNDLE_TAG = "saved_bundle";

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    if (savedInstanceState != null) {
        savedState = savedInstanceState.getBundle(SAVED_BUNDLE_TAG);
    }
}

Dado que destroyView no se llama en la situación de rotación especial, podemos estar seguros de que si crea el estado, deberíamos usarlo.

@Override
public void onDestroyView() {
    super.onDestroyView();
    savedState = saveState();
    createdStateInDestroyView = true;
    myObject = null;
}

Esta parte sería la misma.

private Bundle saveState() { 
    Bundle state = new Bundle();
    state.putSerializable(SAVED_BUNDLE_TAG, myObject);
    return state;
}

Ahora aquí está la parte difícil. En mi método onActivityCreated, ejemplifico la variable "myObject", pero la rotación ocurre en onActivity y onCreateView no reciben llamadas. Por lo tanto, myObject será nulo en esta situación cuando la orientación gire más de una vez. Lo soluciono reutilizando el mismo paquete que se guardó en onCreate que el paquete saliente.

    @Override
public void onSaveInstanceState(Bundle outState) {

    if (myObject == null) {
        outState.putBundle(SAVED_BUNDLE_TAG, savedState);
    } else {
        outState.putBundle(SAVED_BUNDLE_TAG, createdStateInDestroyView ? savedState : saveState());
    }
    createdStateInDestroyView = false;
    super.onSaveInstanceState(outState);
}

Ahora, donde quiera restaurar el estado, simplemente use el paquete savedState

  @Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    ...
    if(savedState != null) {
        myObject = (MyObject) savedState.getSerializable(SAVED_BUNDLE_TAG);
    }
    ...
}

Gracias a DroidT , hice esto:

Me doy cuenta de que si el Fragment no se ejecuta en onCreateView (), su vista no se instancia. Entonces, si el fragmento en la pila posterior no creó sus vistas, guardo el último estado almacenado, de lo contrario, construyo mi propio paquete con los datos que quiero guardar / restaurar.

1) Amplíe esta clase:

import android.os.Bundle;
import android.support.v4.app.Fragment;

public abstract class StatefulFragment extends Fragment {

    private Bundle savedState;
    private boolean saved;
    private static final String _FRAGMENT_STATE = "FRAGMENT_STATE";

    @Override
    public void onSaveInstanceState(Bundle state) {
        if (getView() == null) {
            state.putBundle(_FRAGMENT_STATE, savedState);
        } else {
            Bundle bundle = saved ? savedState : getStateToSave();

            state.putBundle(_FRAGMENT_STATE, bundle);
        }

        saved = false;

        super.onSaveInstanceState(state);
    }

    @Override
    public void onCreate(Bundle state) {
        super.onCreate(state);

        if (state != null) {
            savedState = state.getBundle(_FRAGMENT_STATE);
        }
    }

    @Override
    public void onDestroyView() {
        savedState = getStateToSave();
        saved = true;

        super.onDestroyView();
    }

    protected Bundle getSavedState() {
        return savedState;
    }

    protected abstract boolean hasSavedState();

    protected abstract Bundle getStateToSave();

}

2) En tu Fragmento, debes tener esto:

@Override
protected boolean hasSavedState() {
    Bundle state = getSavedState();

    if (state == null) {
        return false;
    }

    //restore your data here

    return true;
}

3) Por ejemplo, puede llamar a hasSavedState en onActivityCreated:

@Override
public void onActivityCreated(Bundle state) {
    super.onActivityCreated(state);

    if (hasSavedState()) {
        return;
    }

    //your code here
}

final FragmentTransaction ft = getFragmentManager().beginTransaction();
ft.hide(currentFragment);
ft.add(R.id.content_frame, newFragment.newInstance(context), "Profile");
ft.addToBackStack(null);
ft.commit();