Comment empêcher les vues personnalisées de perdre leur état lors des changements d'orientation de l'écran

J'ai réussi à implémenter onRetainNonConfigurationInstance()mon principal Activitypour enregistrer et restaurer certains composants critiques lors des changements d'orientation d'écran.

Mais il semble que mes vues personnalisées soient recréées à partir de zéro lorsque l'orientation change. Cela a du sens, bien que dans mon cas, cela ne soit pas pratique car la vue personnalisée en question est un tracé X / Y et les points tracés sont stockés dans la vue personnalisée.

Existe-t-il un moyen astucieux d'implémenter quelque chose de similaire à onRetainNonConfigurationInstance()une vue personnalisée, ou dois-je simplement implémenter des méthodes dans la vue personnalisée qui me permettent d'obtenir et de définir son "état"?

Pour ce faire , la mise en œuvre View#onSaveInstanceStateet View#onRestoreInstanceStateet l' extension de la View.BaseSavedStateclasse.

public class CustomView extends View {

  private int stateToSave;

  ...

  @Override
  public Parcelable onSaveInstanceState() {
    //begin boilerplate code that allows parent classes to save state
    Parcelable superState = super.onSaveInstanceState();

    SavedState ss = new SavedState(superState);
    //end

    ss.stateToSave = this.stateToSave;

    return ss;
  }

  @Override
  public void onRestoreInstanceState(Parcelable state) {
    //begin boilerplate code so parent classes can restore state
    if(!(state instanceof SavedState)) {
      super.onRestoreInstanceState(state);
      return;
    }

    SavedState ss = (SavedState)state;
    super.onRestoreInstanceState(ss.getSuperState());
    //end

    this.stateToSave = ss.stateToSave;
  }

  static class SavedState extends BaseSavedState {
    int stateToSave;

    SavedState(Parcelable superState) {
      super(superState);
    }

    private SavedState(Parcel in) {
      super(in);
      this.stateToSave = in.readInt();
    }

    @Override
    public void writeToParcel(Parcel out, int flags) {
      super.writeToParcel(out, flags);
      out.writeInt(this.stateToSave);
    }

    //required field that makes Parcelables from a Parcel
    public static final Parcelable.Creator<SavedState> CREATOR =
        new Parcelable.Creator<SavedState>() {
          public SavedState createFromParcel(Parcel in) {
            return new SavedState(in);
          }
          public SavedState[] newArray(int size) {
            return new SavedState[size];
          }
    };
  }
}

Le travail est divisé entre la classe View et la classe SavedState de la vue. Vous devriez faire tout le travail de lecture et d'écriture vers et depuis Parcelle SavedStatecours. Ensuite, votre classe View peut effectuer le travail d'extraction des membres de l'état et effectuer le travail nécessaire pour ramener la classe à un état valide.

Remarques: View#onSavedInstanceStateet View#onRestoreInstanceStatesont appelés automatiquement pour vous si View#getIdrenvoie une valeur> = 0. Cela se produit lorsque vous lui donnez un identifiant en xml ou appelez setIdmanuellement. Sinon , vous devez appeler View#onSaveInstanceStateet écrire le Parcelable retourné au colis que vous obtenez dans Activity#onSaveInstanceStated'enregistrer l'état et de lire la suite et le transmettre à View#onRestoreInstanceStatepartir Activity#onRestoreInstanceState.

Un autre exemple simple de ceci est le CompoundButton

Je pense que c'est une version beaucoup plus simple. Bundleest un type intégré qui implémenteParcelable

public class CustomView extends View
{
  private int stuff; // stuff

  @Override
  public Parcelable onSaveInstanceState()
  {
    Bundle bundle = new Bundle();
    bundle.putParcelable("superState", super.onSaveInstanceState());
    bundle.putInt("stuff", this.stuff); // ... save stuff 
    return bundle;
  }

  @Override
  public void onRestoreInstanceState(Parcelable state)
  {
    if (state instanceof Bundle) // implicit null check
    {
      Bundle bundle = (Bundle) state;
      this.stuff = bundle.getInt("stuff"); // ... load stuff
      state = bundle.getParcelable("superState");
    }
    super.onRestoreInstanceState(state);
  }
}

Voici une autre variante qui utilise un mélange des deux méthodes ci-dessus. Combiner la vitesse et la justesse de Parcelableavec la simplicité d'un Bundle:

@Override
public Parcelable onSaveInstanceState() {
    Bundle bundle = new Bundle();
    // The vars you want to save - in this instance a string and a boolean
    String someString = "something";
    boolean someBoolean = true;
    State state = new State(super.onSaveInstanceState(), someString, someBoolean);
    bundle.putParcelable(State.STATE, state);
    return bundle;
}

@Override
public void onRestoreInstanceState(Parcelable state) {
    if (state instanceof Bundle) {
        Bundle bundle = (Bundle) state;
        State customViewState = (State) bundle.getParcelable(State.STATE);
        // The vars you saved - do whatever you want with them
        String someString = customViewState.getText();
        boolean someBoolean = customViewState.isSomethingShowing());
        super.onRestoreInstanceState(customViewState.getSuperState());
        return;
    }
    // Stops a bug with the wrong state being passed to the super
    super.onRestoreInstanceState(BaseSavedState.EMPTY_STATE); 
}

protected static class State extends BaseSavedState {
    protected static final String STATE = "YourCustomView.STATE";

    private final String someText;
    private final boolean somethingShowing;

    public State(Parcelable superState, String someText, boolean somethingShowing) {
        super(superState);
        this.someText = someText;
        this.somethingShowing = somethingShowing;
    }

    public String getText(){
        return this.someText;
    }

    public boolean isSomethingShowing(){
        return this.somethingShowing;
    }
}

Les réponses ici sont déjà excellentes, mais ne fonctionnent pas nécessairement pour les ViewGroups personnalisés. Pour que toutes les vues personnalisées conservent leur état, vous devez remplacer onSaveInstanceState()et onRestoreInstanceState(Parcelable state)dans chaque classe. Vous devez également vous assurer qu'ils ont tous des identifiants uniques, qu'ils soient gonflés à partir de XML ou ajoutés par programme.

Ce que j'ai trouvé ressemblait remarquablement à la réponse de Kobor42, mais l'erreur est restée parce que j'ajoutais les vues à un ViewGroup personnalisé par programme et que je n'attribuais pas d'identifiants uniques.

Le lien partagé par mato fonctionnera, mais cela signifie qu'aucune des vues individuelles ne gère son propre état - l'état entier est enregistré dans les méthodes ViewGroup.

Le problème est que lorsque plusieurs de ces ViewGroups sont ajoutés à une mise en page, les identifiants de leurs éléments du XML ne sont plus uniques (s'ils sont définis en XML). Au moment de l'exécution, vous pouvez appeler la méthode statique View.generateViewId()pour obtenir un identifiant unique pour une vue. Ceci n'est disponible qu'à partir de l'API 17.

Voici mon code du ViewGroup (il est abstrait et mOriginalValue est une variable de type):

public abstract class DetailRow<E> extends LinearLayout {

    private static final String SUPER_INSTANCE_STATE = "saved_instance_state_parcelable";
    private static final String STATE_VIEW_IDS = "state_view_ids";
    private static final String STATE_ORIGINAL_VALUE = "state_original_value";

    private E mOriginalValue;
    private int[] mViewIds;

// ...

    @Override
    protected Parcelable onSaveInstanceState() {

        // Create a bundle to put super parcelable in
        Bundle bundle = new Bundle();
        bundle.putParcelable(SUPER_INSTANCE_STATE, super.onSaveInstanceState());
        // Use abstract method to put mOriginalValue in the bundle;
        putValueInTheBundle(mOriginalValue, bundle, STATE_ORIGINAL_VALUE);
        // Store mViewIds in the bundle - initialize if necessary.
        if (mViewIds == null) {
            // We need as many ids as child views
            mViewIds = new int[getChildCount()];
            for (int i = 0; i < mViewIds.length; i++) {
                // generate a unique id for each view
                mViewIds[i] = View.generateViewId();
                // assign the id to the view at the same index
                getChildAt(i).setId(mViewIds[i]);
            }
        }
        bundle.putIntArray(STATE_VIEW_IDS, mViewIds);
        // return the bundle
        return bundle;
    }

    @Override
    protected void onRestoreInstanceState(Parcelable state) {

        // We know state is a Bundle:
        Bundle bundle = (Bundle) state;
        // Get mViewIds out of the bundle
        mViewIds = bundle.getIntArray(STATE_VIEW_IDS);
        // For each id, assign to the view of same index
        if (mViewIds != null) {
            for (int i = 0; i < mViewIds.length; i++) {
                getChildAt(i).setId(mViewIds[i]);
            }
        }
        // Get mOriginalValue out of the bundle
        mOriginalValue = getValueBackOutOfTheBundle(bundle, STATE_ORIGINAL_VALUE);
        // get super parcelable back out of the bundle and pass it to
        // super.onRestoreInstanceState(Parcelable)
        state = bundle.getParcelable(SUPER_INSTANCE_STATE);
        super.onRestoreInstanceState(state);
    } 
}

J'ai eu le problème que onRestoreInstanceState a restauré toutes mes vues personnalisées avec l'état de la dernière vue. Je l'ai résolu en ajoutant ces deux méthodes à ma vue personnalisée:

@Override
protected void dispatchSaveInstanceState(SparseArray<Parcelable> container) {
    dispatchFreezeSelfOnly(container);
}

@Override
protected void dispatchRestoreInstanceState(SparseArray<Parcelable> container) {
    dispatchThawSelfOnly(container);
}

Au lieu d'utiliser onSaveInstanceStateet onRestoreInstanceState, vous pouvez également utiliser a ViewModel. Faites étendre votre modèle de données ViewModel, puis vous pouvez utiliser ViewModelProviderspour obtenir la même instance de votre modèle chaque fois que l'activité est recréée:

class MyData extends ViewModel {
    // have all your properties with getters and setters here
}

public class MyActivity extends FragmentActivity {
    @Override
    public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // the first time, ViewModelProvider will create a new MyData
        // object. When the Activity is recreated (e.g. because the screen
        // is rotated), ViewModelProvider will give you the initial MyData
        // object back, without creating a new one, so all your property
        // values are retained from the previous view.
        myData = ViewModelProviders.of(this).get(MyData.class);

        ...
    }
}

Pour l'utiliser ViewModelProviders, ajoutez les éléments suivants dependenciesdans app/build.gradle:

implementation "android.arch.lifecycle:extensions:1.1.1"
implementation "android.arch.lifecycle:viewmodel:1.1.1"

Notez que votre MyActivityétend FragmentActivityau lieu de simplement s'étendre Activity.

Vous pouvez en savoir plus sur ViewModels ici:

• Guide du développeur Android, gérer les modifications de configuration
• Guide du développeur Android, Enregistrement des états de l'interface utilisateur, Utilisez ViewModel pour gérer les modifications de configuration
• Tutoriel ViewModels: un exemple simple

Je l'ai trouvé cette réponse provoquait des plantages sur les versions 9 et 10 d'Android. Je pense que c'est une bonne approche mais quand j'ai regardé du code Android, j'ai découvert qu'il manquait un constructeur. La réponse est assez ancienne, donc à l'époque, elle n'était probablement pas nécessaire. Quand j'ai ajouté le constructeur manquant et l'ai appelé du créateur, le crash a été corrigé.

Voici donc le code édité:

public class CustomView extends View {

    private int stateToSave;

    ...

    @Override
    public Parcelable onSaveInstanceState() {
        Parcelable superState = super.onSaveInstanceState();
        SavedState ss = new SavedState(superState);

        // your custom state
        ss.stateToSave = this.stateToSave;

        return ss;
    }

    @Override
    protected void dispatchSaveInstanceState(SparseArray<Parcelable> container)
    {
        dispatchFreezeSelfOnly(container);
    }

    @Override
    public void onRestoreInstanceState(Parcelable state) {
        SavedState ss = (SavedState) state;
        super.onRestoreInstanceState(ss.getSuperState());

        // your custom state
        this.stateToSave = ss.stateToSave;
    }

    @Override
    protected void dispatchRestoreInstanceState(SparseArray<Parcelable> container)
    {
        dispatchThawSelfOnly(container);
    }

    static class SavedState extends BaseSavedState {
        int stateToSave;

        SavedState(Parcelable superState) {
            super(superState);
        }

        private SavedState(Parcel in) {
            super(in);
            this.stateToSave = in.readInt();
        }

        // This was the missing constructor
        @RequiresApi(Build.VERSION_CODES.N)
        SavedState(Parcel in, ClassLoader loader)
        {
            super(in, loader);
            this.stateToSave = in.readInt();
        }

        @Override
        public void writeToParcel(Parcel out, int flags) {
            super.writeToParcel(out, flags);
            out.writeInt(this.stateToSave);
        }    

        public static final Creator<SavedState> CREATOR =
            new ClassLoaderCreator<SavedState>() {

            // This was also missing
            @Override
            public SavedState createFromParcel(Parcel in, ClassLoader loader)
            {
                return Build.VERSION.SDK_INT >= Build.VERSION_CODES.N ? new SavedState(in, loader) : new SavedState(in);
            }

            @Override
            public SavedState createFromParcel(Parcel in) {
                return new SavedState(in, null);
            }

            @Override
            public SavedState[] newArray(int size) {
                return new SavedState[size];
            }
        };
    }
}

Pour augmenter les autres réponses - si vous avez plusieurs vues composées personnalisées avec le même ID et qu'elles sont toutes en cours de restauration avec l'état de la dernière vue lors d'un changement de configuration, tout ce que vous devez faire est de dire à la vue de ne distribuer que les événements de sauvegarde / restauration à lui-même en remplaçant un couple de méthodes.

class MyCompoundView : ViewGroup {

    ...

    override fun dispatchSaveInstanceState(container: SparseArray<Parcelable>) {
        dispatchFreezeSelfOnly(container)
    }

    override fun dispatchRestoreInstanceState(container: SparseArray<Parcelable>) {
        dispatchThawSelfOnly(container)
    }
}

Pour une explication de ce qui se passe et pourquoi cela fonctionne, consultez cet article de blog . Fondamentalement, les ID de vue des enfants de votre vue composée sont partagés par chaque vue composée et la restauration de l'état est confuse. En ne répartissant l'état que pour la vue composée elle-même, nous empêchons leurs enfants d'obtenir des messages mixtes provenant d'autres vues composées.