Android原理——SavedState

引言

还在用public static T 保存View状态？
Android官方早已想到了：
使用View.BaseSavedState来保存状态。

1. 在一个activity被销毁前，不一定会调用onSaveInstanceState()这个方法，因为不是所有情况都需要去存储activity的状态（例如当用户按回退键退出你的activity的时候，因为用户指定关掉这个activity）。

2. 如果这个方法被调用，它一定会在 onStop()方法之前，可能会在onPause()方法之前。

3. 布局中的每一个View默认实现了onSaveInstanceState()方法，这样的话，这个UI的任何改变都会自动的存储和在activity重新创建的时候自动的恢复。但是这种情况只有在你为这个UI提供了唯一的ID之后才起作用，如果没有提供ID，将不会存储它的状态。

4. 由于默认的onSaveInstanceState()方法的实现帮助UI存储它的状态，所以如果你需要覆盖这个方法去存储额外的状态信息时，你应该在执行任何代码之前都调用父类的onSaveInstanceState()方法（super.onSaveInstanceState()）。

5. 由于onSaveInstanceState()方法调用的不确定性，你应该只使用这个方法去记录activity的瞬间状态（UI的状态）。不应该用这个方法去存储持久化数据。当用户离开这个activity的时候应该在onPause()方法中存储持久化数据（例如应该被存储到数据库中的数据）。

---

类概述

BaseSavedState
Base class for derived classes that want to save and restore their own state in onSaveInstanceState().

直接子类

TextView.SavedState
ViewPager.SavedState

---

How To Use

读取保存状态
onRestoreInstanceState(Parcelable state)
保存状态
Parcelable onSaveInstanceState()

举个ViewPager.SavedState的示例

    /**
     * 读取保存状态
     * */
    @Override
    public void onRestoreInstanceState(Parcelable state) {
        SavedState savedState = (SavedState)state;
        super.onRestoreInstanceState(savedState.getSuperState());
        mCurrentPage = savedState.currentPage;
        mSnapPage = savedState.currentPage;
        requestLayout();
    }
    /**
     * 保存状态
     * */
    @Override
    public Parcelable onSaveInstanceState() {
        Parcelable superState = super.onSaveInstanceState();
        SavedState savedState = new SavedState(superState);
        savedState.currentPage = mCurrentPage;
        return savedState;
    }

    /**
     * 保存界面状态
     * */
    static class SavedState extends BaseSavedState {
        //当前页
        int currentPage;

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

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

        @Override
        public void writeToParcel(Parcel dest, int flags) {
            super.writeToParcel(dest, flags);
            dest.writeInt(currentPage);
        }

        public static final Parcelable.Creator<SavedState> CREATOR = new Parcelable.Creator<SavedState>() {
            @Override
            public SavedState createFromParcel(Parcel in) {
                return new SavedState(in);
            }

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

---

BaseSavedState源码

我们看一下它的构造方法

public static class BaseSavedState extends AbsSavedState {
        /**
         * Constructor used when reading from a parcel. Reads the state of the superclass.
         *
         * @param source
         */
        public BaseSavedState(Parcel source) {
            super(source);
        }

        /**
         * Constructor called by derived classes when creating their SavedState objects
         *
         * @param superState The state of the superclass of this view
         */
        public BaseSavedState(Parcelable superState) {
            super(superState);
        }

        public static final Parcelable.Creator<BaseSavedState> CREATOR =
                new Parcelable.Creator<BaseSavedState>() {
            public BaseSavedState createFromParcel(Parcel in) {
                return new BaseSavedState(in);
            }

            public BaseSavedState[] newArray(int size) {
                return new BaseSavedState[size];
            }
        };
    }

而其父类实现了Parcelable借口

/**
 * A {@link Parcelable} implementation that should be used by inheritance
 * hierarchies to ensure the state of all classes along the chain is saved.
 */
public abstract class AbsSavedState implements Parcelable {
    public static final AbsSavedState EMPTY_STATE = new AbsSavedState() {};

    private final Parcelable mSuperState;

    /**
     * Constructor used to make the EMPTY_STATE singleton
     */
    private AbsSavedState() {
        mSuperState = null;
    }

    /**
     * Constructor called by derived classes when creating their SavedState objects
     * 
     * @param superState The state of the superclass of this view
     */
    protected AbsSavedState(Parcelable superState) {
        if (superState == null) {
            throw new IllegalArgumentException("superState must not be null");
        }
        mSuperState = superState != EMPTY_STATE ? superState : null;
    }

    /**
     * Constructor used when reading from a parcel. Reads the state of the superclass.
     * 
     * @param source
     */
    protected AbsSavedState(Parcel source) {
        // FIXME need class loader
        Parcelable superState = source.readParcelable(null);

        mSuperState = superState != null ? superState : EMPTY_STATE;
    }

    final public Parcelable getSuperState() {
        return mSuperState;
    }

    public int describeContents() {
        return 0;
    }

    public void writeToParcel(Parcel dest, int flags) {
         dest.writeParcelable(mSuperState, flags);
    }

    public static final Parcelable.Creator<AbsSavedState> CREATOR 
        = new Parcelable.Creator<AbsSavedState>() {

        public AbsSavedState createFromParcel(Parcel in) {
            Parcelable superState = in.readParcelable(null);
            if (superState != null) {
                throw new IllegalStateException("superState must be null");
            }
            return EMPTY_STATE;
        }

        public AbsSavedState[] newArray(int size) {
            return new AbsSavedState[size];
        }
    };
}

---

补充

最后再举一个定义SeekBar的

3   import android.content.Context;
4   import android.content.res.TypedArray;
5   import android.os.Parcel;
6   import android.os.Parcelable;
7   import android.util.AttributeSet;
8   import android.view.View;
9   import android.view.ViewGroup;
10  import android.view.ViewParent;
11  
12  import com.WazaBe.HoloEverywhere.LayoutInflater;
13  import com.WazaBe.HoloEverywhere.R;
14  import com.WazaBe.HoloEverywhere.widget.SeekBar;
15  
16  public class SeekBarDialogPreference extends DialogPreference {
17      private static class SavedState extends BaseSavedState {
18          @SuppressWarnings("unused")
19          public static final Parcelable.Creator<SavedState> CREATOR = new Parcelable.Creator<SavedState>() {
20              @Override
21              public SavedState createFromParcel(Parcel in) {
22                  return new SavedState(in);
23              }
24  
25              @Override
26              public SavedState[] newArray(int size) {
27                  return new SavedState[size];
28              }
29          };
30  
31          protected int mValue, mMaxValue;
32  
33          public SavedState(Parcel source) {
34              super(source);
35              mValue = source.readInt();
36              mMaxValue = source.readInt();
37          }
38  
39          public SavedState(Parcelable superState) {
40              super(superState);
41          }
42  
43          @Override
44          public void writeToParcel(Parcel dest, int flags) {
45              super.writeToParcel(dest, flags);
46              dest.writeInt(mValue);
47              dest.writeInt(mMaxValue);
48          }
49      }
50  
51      private final SeekBar mSeekBar;
52      private int mValue = Integer.MIN_VALUE, mMaxValue = Integer.MIN_VALUE;
53  
54      public SeekBarDialogPreference(Context context) {
55          this(context, null);
56      }
57  
58      public SeekBarDialogPreference(Context context, AttributeSet attrs) {
59          this(context, attrs, R.attr.seekBarDialogPreferenceStyle);
60      }
61  
62      public SeekBarDialogPreference(Context context, AttributeSet attrs,
63              int defStyle) {
64          super(context, attrs, defStyle);
65          TypedArray a = context.obtainStyledAttributes(attrs,
66                  R.styleable.SeekBarDialogPreference, defStyle,
67                  R.style.Holo_PreferenceDialog_SeekBarDialogPreference);
68          int maxValue = a.getInt(R.styleable.SeekBarDialogPreference_max, 100);
69          a.recycle();
70          mSeekBar = onCreateSeekBar();
71          setMaxValue(maxValue);
72      }
73  
74      public int getMaxValue() {
75          return mMaxValue;
76      }
77  
78      public SeekBar getSeekBar() {
79          return mSeekBar;
80      }
81  
82      public int getValue() {
83          return mValue;
84      }
85  
86      @Override
87      protected void onBindDialogView(View view) {
88          super.onBindDialogView(view);
89          synchronized (mSeekBar) {
90              ViewParent oldParent = mSeekBar.getParent();
91              if (oldParent != view) {
92                  if (oldParent != null) {
93                      ((ViewGroup) oldParent).removeView(mSeekBar);
94                  }
95                  ((ViewGroup) view).addView(mSeekBar);
96              }
97          }
98      }
99  
100     protected SeekBar onCreateSeekBar() {
101         return (SeekBar) LayoutInflater.inflate(getContext(),
102                 R.layout.preference_dialog_seekbar_widget);
103     }
104 
105     @Override
106     protected void onDialogClosed(boolean positiveResult) {
107         super.onDialogClosed(positiveResult);
108         final int value;
109         synchronized (mSeekBar) {
110             value = mSeekBar.getProgress();
111         }
112         if (positiveResult && callChangeListener(value)) {
113             setValue(value);
114         }
115     }
116 
117     @Override
118     protected Integer onGetDefaultValue(TypedArray a, int index) {
119         return a.getInt(index, 0);
120     }
121 
122     @Override
123     protected void onRestoreInstanceState(Parcelable state) {
124         if (state == null || !(state instanceof SavedState)) {
125             super.onRestoreInstanceState(state);
126             return;
127         }
128         SavedState ss = (SavedState) state;
129         super.onRestoreInstanceState(ss.getSuperState());
130         setValue(ss.mValue);
131         setMaxValue(ss.mMaxValue);
132     }
133 
134     @Override
135     protected Parcelable onSaveInstanceState() {
136         final Parcelable superState = super.onSaveInstanceState();
137         if (isPersistent()) {
138             return superState;
139         }
140         final SavedState myState = new SavedState(superState);
141         myState.mValue = mValue;
142         myState.mMaxValue = mMaxValue;
143         return myState;
144     }
145 
146     @Override
147     protected void onSetInitialValue(boolean restoreValue, Object defaultValue) {
148         int def = defaultValue instanceof Integer ? (Integer) defaultValue
149                 : defaultValue == null ? 0 : Integer.parseInt(defaultValue
150                         .toString());
151         mSeekBar.setProgress(restoreValue ? getPersistedInt(def) : def);
152     }
153 
154     public void setMaxValue(int maxValue) {
155         if (mMaxValue == maxValue) {
156             return;
157         }
158         final boolean wasBlocking = shouldDisableDependents();
159         mMaxValue = maxValue;
160         mSeekBar.setMax(maxValue);
161         if (shouldDisableDependents() != wasBlocking) {
162             notifyDependencyChange(!wasBlocking);
163         }
164     }
165 
166     public void setValue(int value) {
167         if (mValue == value) {
168             return;
169         }
170         final boolean wasBlocking = shouldDisableDependents();
171         mValue = value;
172         mSeekBar.setProgress(value);
173         persistInt(value);
174         if (shouldDisableDependents() != wasBlocking) {
175             notifyDependencyChange(!wasBlocking);
176         }
177     }
178 }