android - rotación - Cómo evitar que las vistas personalizadas pierdan el estado en los cambios de orientación de la pantalla

detectar cambio de orientacion android

Question

He implementado con éxito onRetainNonConfigurationInstance() para mi Activity principal para guardar y restaurar ciertos componentes críticos en los cambios de orientación de la pantalla.

Pero parece que mis vistas personalizadas se están recreando desde cero cuando cambia la orientación. Esto tiene sentido, aunque en mi caso es inconveniente porque la vista personalizada en cuestión es un gráfico X / Y y los puntos trazados se almacenan en la vista personalizada.

¿Existe una manera onRetainNonConfigurationInstance() implementar algo similar a onRetainNonConfigurationInstance() para una vista personalizada, o necesito simplemente implementar métodos en la vista personalizada que me permitan obtener y establecer su "estado"?

Answer 1

Aquí hay otra variante que utiliza una mezcla de los dos métodos anteriores. Combinando la velocidad y la corrección de Parcelable con la simplicidad de 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;
}
}

Answer 2

Creo que esta es una versión mucho más simple. Bundle es un tipo incorporado que implementa Parcelable

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

Answer 3

Esto se hace implementando View#onSaveInstanceState y View#onRestoreInstanceState y extendiendo la clase View.BaseSavedState .

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

El trabajo se divide entre la vista y la clase SavedState de la vista. Debe hacer todo el trabajo de lectura y escritura hacia y desde la Parcel en la clase SavedState . Luego su clase de Vista puede hacer el trabajo de extraer los miembros del estado y hacer el trabajo necesario para que la clase vuelva a un estado válido.

Notas: View#onSavedInstanceState y View#onRestoreInstanceState se llaman automáticamente si View#getId devuelve un valor> = 0. Esto sucede cuando le setId un ID en xml o llama a setId manualmente. De lo contrario, debe llamar a View#onSaveInstanceState y escribir el Parcelable devuelto al paquete que obtiene en Activity#onSaveInstanceState para guardar el estado y luego leerlo y pasarlo a View#onRestoreInstanceState de Activity#onRestoreInstanceState .

Otro ejemplo simple de esto es el CompoundButton

Answer 4

Las respuestas aquí ya son excelentes, pero no necesariamente funcionan para grupos de vistas personalizados. Para que todas las Vistas personalizadas conserven su estado, debe anular onSaveInstanceState() y onRestoreInstanceState(Parcelable state) en cada clase. También debe asegurarse de que todos tengan identificadores únicos, ya sean inflados desde xml o agregados mediante programación.

Lo que se me ocurrió fue muy similar a la respuesta de Kobor42, pero el error se mantuvo porque estaba agregando las Vistas a un grupo de vistas personalizado programáticamente y no asignando identificadores únicos.

El enlace compartido por mato funcionará, pero significa que ninguna de las Vistas individuales gestiona su propio estado; todo el estado se guarda en los métodos de ViewGroup.

El problema es que cuando se agregan varios de estos ViewGroups a un diseño, los identificadores de sus elementos del xml ya no son únicos (si están definidos en xml). En tiempo de ejecución, puede llamar al método estático View.generateViewId() para obtener una ID única para una Vista. Esto solo está disponible desde la API 17.

Aquí está mi código de ViewGroup (es abstracto, y mOriginalValue es una variable de tipo):

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

Answer 5

Para aumentar otras respuestas: si tiene varias vistas compuestas personalizadas con el mismo ID y todas se están restaurando con el estado de la última vista en un cambio de configuración, todo lo que debe hacer es decirle a la vista que solo envíe eventos de guardar / restaurar a sí mismo por anular un par de métodos.

class MyCompoundView : ViewGroup {
...
override fun dispatchSaveInstanceState(container: SparseArray<Parcelable>) {
dispatchFreezeSelfOnly(container)
}
override fun dispatchRestoreInstanceState(container: SparseArray<Parcelable>) {
dispatchThawSelfOnly(container)
}
}

Para obtener una explicación de lo que está sucediendo y por qué funciona esto, consulte esta publicación del blog . Básicamente, las vistas de vista de los niños de la vista compuesta se comparten con cada vista compuesta y la restauración del estado se confunde. Al solo enviar el estado para la vista compuesta, evitamos que sus hijos reciban mensajes mixtos de otras vistas compuestas.