Come salvare correttamente lo stato di istanza dei frammenti nello stack posteriore?

Ho trovato molti casi di una domanda simile su SO ma purtroppo nessuna risposta soddisfa i miei requisiti.

Ho diversi layout per verticale e orizzontale e sto usando back stack, che mi impedisce sia di usare setRetainState()che trucchi usando le routine di modifica della configurazione.

Mostro determinate informazioni all'utente in TextViews, che non vengono salvate nel gestore predefinito. Quando ho scritto la mia applicazione esclusivamente utilizzando Attività, ha funzionato bene:

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, questo funziona solo in situazioni molto specifiche. In particolare, ciò che si rompe in modo orribile è la sostituzione di un frammento, lo mette nella pila posteriore e quindi ruota lo schermo mentre viene mostrato il nuovo frammento. Da quello che ho capito, il vecchio frammento non riceve una chiamata a onSaveInstanceState()quando viene sostituito, ma rimane in qualche modo collegato al Activitye questo metodo viene chiamato più tardi quando Viewnon esiste più, quindi cerca uno qualsiasi dei miei TextViewrisultati in a NullPointerException.

Inoltre, ho scoperto che mantenere il riferimento al mio TextViewsnon è una buona idea con Fragments, anche se è stato OK con Activity. In tal caso, in onSaveInstanceState()realtà salva lo stato ma il problema riappare se ruoto lo schermo due volte quando il frammento è nascosto, poiché onCreateView()non viene chiamato nella nuova istanza.

Ho pensato di salvare lo stato in onDestroyView()in qualche Bundleelemento membro della classe di tipo (in realtà più dati, non solo uno TextView) e risparmio che in onSaveInstanceState()ma ci sono altri inconvenienti. In primo luogo, se il frammento è attualmente mostrato, l'ordine di chiamare le due funzioni è invertito, quindi dovrei tenere conto di due diverse situazioni. Ci deve essere una soluzione più pulita e corretta!

Per salvare correttamente lo stato dell'istanza, Fragmentè necessario:

1. Nel frammento, salva lo stato dell'istanza eseguendo l'override onSaveInstanceState()e il ripristino in 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. E il punto importante , nell'attività, è necessario salvare l'istanza del frammento onSaveInstanceState()e ripristinarla 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);
    }

}

Spero che sia di aiuto.

Questo è il modo in cui sto usando in questo momento ... è molto complicato ma almeno gestisce tutte le possibili situazioni. Nel caso qualcuno fosse interessato.

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

    /* (...) */

}

In alternativa , è sempre possibile mantenere i dati visualizzati in Views passivi in variabili e usare Views solo per visualizzarli, mantenendo le due cose in sincronia. Tuttavia, non considero l'ultima parte molto pulita.

Nell'ultima libreria di supporto nessuna delle soluzioni discusse qui è più necessaria. Puoi giocare con i tuoi Activityframmenti come preferisci usando FragmentTransaction. Assicurati solo che i tuoi frammenti possano essere identificati con un ID o un tag.

I frammenti verranno ripristinati automaticamente finché non si tenta di ricrearli ad ogni chiamata onCreate(). Invece, dovresti controllare se savedInstanceStatenon è null e trovare i vecchi riferimenti ai frammenti creati in questo caso.

Ecco un esempio:

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

Si noti tuttavia che esiste attualmente un bug durante il ripristino dello stato nascosto di un frammento. Se nascondi frammenti nella tua attività, in questo caso dovrai ripristinare questo stato manualmente.

Voglio solo dare la soluzione che mi è venuta in mente che gestisce tutti i casi presentati in questo post che ho derivato da Vasek e devconsole. Questa soluzione gestisce anche il caso speciale quando il telefono viene ruotato più di una volta mentre i frammenti non sono visibili.

Ecco dove immagazzino il bundle per un uso successivo poiché onCreate e onSaveInstanceState sono le uniche chiamate che vengono fatte quando il frammento non è visibile

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

Dato che destroyView non viene chiamato nella situazione di rotazione speciale, possiamo essere certi che se crea lo stato dovremmo usarlo.

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

Questa parte sarebbe la stessa.

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

Ora ecco la parte difficile. Nel mio metodo onActivityCreated ho un'istanza della variabile "myObject" ma la rotazione avviene suActivity e onCreateView non vengono chiamati. Pertanto, myObject sarà nullo in questa situazione quando l'orientamento ruota più di una volta. Mi aggiro riutilizzando lo stesso bundle che è stato salvato in onCreate come bundle in uscita.

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

Ora, ovunque tu voglia ripristinare lo stato, usa semplicemente il pacchetto saveState

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

Grazie a DroidT , ho fatto questo:

Mi rendo conto che se il frammento non viene eseguito suCreateView (), la sua vista non viene istanziata. Quindi, se il frammento sul back stack non ha creato le sue viste, salvo l'ultimo stato memorizzato, altrimenti creo il mio pacchetto con i dati che voglio salvare / ripristinare.

1) Estendi questa classe:

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) Nel tuo frammento, devi avere questo:

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

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

    //restore your data here

    return true;
}

3) Ad esempio, puoi chiamare hasSavedState in 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();