android - tutorial - fragment lifecycle callbacks




使用“保存实例状态”保存Android活动状态 (18)

将LiveData(Android架构组件)添加到项目中

添加以下依赖项

implementation "android.arch.lifecycle:extensions:1.1.0"

LiveData接收观察者并仅在数据更改处于STARTED或RESUMED状态时通知它。与LiveData的好处是,当你的活动进入其他比任何国家已启动会不会调用调用onChanged的方法观测

private TextView mTextView;
private MutableLiveData<String> mMutableLiveData;

@Override
protected void onCreate(Bundle savedInstanceState) {
    mTextView = (TextView) findViewById(R.id.textView);
    mMutableLiveData = new MutableLiveData<>();
    mMutableLiveData.observe(this, new Observer<String>() {
        @Override
        public void onChanged(@Nullable String s) {
            mTextView.setText(s);
        }
    });

}

我一直在研究Android SDK平台,有点不清楚如何保存应用程序的状态。 因此,考虑到'Hello,Android'示例的这种小型重新设计:

package com.android.hello;

import android.app.Activity;
import android.os.Bundle;
import android.widget.TextView;

public class HelloAndroid extends Activity {

  private TextView mTextView = null;

  /** Called when the activity is first created. */
  @Override
  public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    mTextView = new TextView(this);

    if (savedInstanceState == null) {
       mTextView.setText("Welcome to HelloAndroid!");
    } else {
       mTextView.setText("Welcome back.");
    }

    setContentView(mTextView);
  }
}

我认为这对于最简单的情况就足够了,但无论我如何离开应用程序,它总是会响应第一条消息。

我确信解决方案就像覆盖onPause或类似的东西一样简单,但我已经在文档中捅了大约30分钟左右并且没有找到任何明显的东西。


onSaveInstanceState()用于瞬态数据(在onCreate() / onRestoreInstanceState()恢复), onPause()用于持久数据(在onResume()恢复)。 来自Android技术资源:

如果Activity被停止并且可能在恢复之前被杀死,则Android会调用onSaveInstanceState() ! 这意味着它应该存储重新启动Activity时重新初始化为相同条件所需的任何状态。 它与onCreate()方法相对应,实际上传入onCreate()的savedInstanceState Bundle与onSaveInstanceState()方法中构造为outState的Bundle相同。

onPause()onResume()也是免费的方法。当Activity结束时总是调用onPause(),即使我们发起了这个(例如使用finish()调用)。我们将使用它将当前注释保存回数据库。好的做法是释放在onPause()期间可以释放的任何资源,以便在处于被动状态时占用更少的资源。


重新创建活动

在某些情况下,您的活动会因应用程序的正常行为而被销毁,例如当用户按下“返回”按钮或您的活动通过调用finish()发出自己的破坏信号时。 如果系统当前已停止且未长时间使用或前台活动需要更多资源,系统也可能会破坏您的活动,因此系统必须关闭后台进程才能恢复内存。

当您的activity因用户按下Back或activity自行完成而被销毁时,系统对该Activity实例的概念将永远消失,因为该行为表明不再需要该活动。 但是,如果系统因系统约束(而不是正常的应用程序行为)而破坏活动,那么虽然实际的Activity实例已经消失,但系统会记住它存在,如果用户导航回到它,系统会创建一个新的活动的实例,使用一组保存的数据来描述destroyed时的活动状态。 系统用于恢复先前状态的已保存数据称为“实例状态”,是存储在Bundle对象中的键值对的集合。

要保存有关活动状态的其他数据,必须覆盖onSaveInstanceState()回调方法。 系统在用户离开您的活动时调用此方法,并向其传递Bundle对象,该对象将在您的活动意外销毁时保存。 如果系统必须稍后重新创建活动实例,它会将相同的Bundle对象传递给onRestoreInstanceState()onCreate()方法。

当系统开始停止活动时,它会调用onSaveInstanceState() (1),这样您就可以指定要保存的其他状态数据,以防必须重新创建Activity实例。 如果活动被销毁并且必须重新创建相同的实例,则系统会将(1)中定义的状态数据传递给onCreate()方法(2)和onRestoreInstanceState()方法(3)。

保存您的Activity状态

当您的活动开始停止时,系统会调用onSaveInstanceState()以便您的活动可以使用一组键值对来保存状态信息。 此方法的默认实现保存有关活动视图层次结构状态的信息,例如EditText小部件中的文本或ListView的滚动位置。

要保存活动的其他状态信息,必须实现onSaveInstanceState()并将键值对添加到Bundle对象。 例如:

  static final String STATE_SCORE = "playerScore";
  static final String STATE_LEVEL = "playerLevel";

  @Override
  public void onSaveInstanceState(Bundle savedInstanceState) {
  // Save the user's current game state
  savedInstanceState.putInt(STATE_SCORE, mCurrentScore);
  savedInstanceState.putInt(STATE_LEVEL, mCurrentLevel);

  // Always call the superclass so it can save the view hierarchy state
  super.onSaveInstanceState(savedInstanceState);
}

警告:始终调用onSaveInstanceState()的超类实现,以便默认实现可以保存视图层次结构的状态。

恢复您的Activity状态

在先前销毁活动之后重新创建活动时,您可以从系统传递活动的Bundle中恢复已保存的状态。 onCreate()onRestoreInstanceState()回调方法都接收包含实例状态信息的相同Bundle

因为无论系统是创建活动的新实例还是重新创建前一个实例,都会调用onCreate()方法,因此在尝试读取之前必须检查状态Bundle是否为null。 如果它为null,则系统正在创建活动的新实例,而不是恢复已销毁的先前实例。

例如,以下是如何在onCreate()恢复某些状态数据:

 @Override
 protected void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState); // Always call the superclass first

 // Check whether we're recreating a previously destroyed instance
 if (savedInstanceState != null) {
    // Restore value of members from saved state
    mCurrentScore = savedInstanceState.getInt(STATE_SCORE);
    mCurrentLevel = savedInstanceState.getInt(STATE_LEVEL);
 } else {
    // Probably initialize members with default values for a new instance
 }

 }

您可以选择实现onRestoreInstanceState() ,系统在onStart()方法之后调用onRestoreInstanceState()而不是在onCreate()期间恢复状态。 仅当存在要恢复的已保存状态时,系统才会调用onRestoreInstanceState() ,因此您无需检查Bundle是否为null:

  public void onRestoreInstanceState(Bundle savedInstanceState) {
  // Always call the superclass so it can restore the view hierarchy
  super.onRestoreInstanceState(savedInstanceState);

  // Restore state members from saved instance
  mCurrentScore = savedInstanceState.getInt(STATE_SCORE);
  mCurrentLevel = savedInstanceState.getInt(STATE_LEVEL);
}

Kotlin代码:

保存:

override fun onSaveInstanceState(outState: Bundle) {
    super.onSaveInstanceState(outState.apply {
        putInt("intKey", 1)
        putString("stringKey", "String Value")
        putParcelable("parcelableKey", parcelableObject)
    })
}

然后在onCreate()onRestoreInstanceState()

    val restoredInt = savedInstanceState?.getInt("intKey") ?: 1 //default int
    val restoredString = savedInstanceState?.getString("stringKey") ?: "default string"
    val restoredParcelable = savedInstanceState?.getParcelable<ParcelableClass>("parcelableKey") ?: ParcelableClass() //default parcelable

如果您不想拥有Optionals,请添加默认值


同时我一般不再使用

Bundle savedInstanceState & Co

对于大多数活动而言,生活周期过于复杂且不必要。谷歌声称自己,它甚至不可靠。

我的方法是立即保存首选项中的任何更改

 SharedPreferences p;
 p.edit().put(..).commit()

在某种程度上,SharedPreferences的工作方式与Bundles类似。并且自然而且首先这些值必须是偏好的。

在复杂数据的情况下,您可以使用Sqlite而不是使用首选项。

应用此概念时,活动将继续使用上次保存的状态,无论它是初始打开还是重新启动,或者由于后端堆栈而重新打开。


实现此更改基本上有两种方法。

  1. 使用onSaveInstanceState()onRestoreInstanceState()
  2. 在清单中android:configChanges="orientation|screenSize"

我真的不建议使用第二种方法。因为在我的一次经验中,它导致设备屏幕的一半在从纵向旋转到横向时变黑,反之亦然。

使用上面提到的第一种方法,我们可以在方向更改或任何配置更改发生时保留数据。我知道一种可以在savedInstance状态对象中存储任何类型数据的方法。

示例:如果要保留Json对象,请考虑一个案例。使用getter和setter创建一个模型类。

class MyModel extends Serializable{
JSONObject obj;

setJsonObject(JsonObject obj)
{
this.obj=obj;
}

JSONObject getJsonObject()
return this.obj;
} 
}

现在在onCreate和onSaveInstanceState方法的活动中执行以下操作。它看起来像这样:

@override
onCreate(Bundle savedInstaceState){
MyModel data= (MyModel)savedInstaceState.getSerializable("yourkey")
JSONObject obj=data.getJsonObject();
//Here you have retained JSONObject and can use.
}


@Override
protected void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
//Obj is some json object 
MyModel dataToSave= new MyModel();
dataToSave.setJsonObject(obj);
oustate.putSerializable("yourkey",dataToSave); 

}

当系统需要内存并杀死应用程序时,会调用onSaveInstanceState 。 用户刚刚关闭应用程序时不会调用它。 所以我认为应用程序状态也应该保​​存在onPause它应该保存到一些持久存储器,如PreferencesSqlite


您需要覆盖onSaveInstanceState(Bundle savedInstanceState)并将要更改的应用程序状态值写入Bundle参数,如下所示:

@Override
public void onSaveInstanceState(Bundle savedInstanceState) {
  super.onSaveInstanceState(savedInstanceState);
  // Save UI state changes to the savedInstanceState.
  // This bundle will be passed to onCreate if the process is
  // killed and restarted.
  savedInstanceState.putBoolean("MyBoolean", true);
  savedInstanceState.putDouble("myDouble", 1.9);
  savedInstanceState.putInt("MyInt", 1);
  savedInstanceState.putString("MyString", "Welcome back to Android");
  // etc.
}

Bundle本质上是一种存储NVP(“名称 - 值对”)映射的方式,它将被传递到onCreate()onRestoreInstanceState() ,在那里你可以像这样提取值:

@Override
public void onRestoreInstanceState(Bundle savedInstanceState) {
  super.onRestoreInstanceState(savedInstanceState);
  // Restore UI state from the savedInstanceState.
  // This bundle has also been passed to onCreate.
  boolean myBoolean = savedInstanceState.getBoolean("MyBoolean");
  double myDouble = savedInstanceState.getDouble("myDouble");
  int myInt = savedInstanceState.getInt("MyInt");
  String myString = savedInstanceState.getString("MyString");
}

您通常会使用此技术来存储应用程序的实例值(选择,未保存的文本等)。


我的同事写了一篇文章解释Android设备上的应用程序状态,包括对活动生命周期和状态信息的解释,如何存储状态信息,以及保存到State BundleSharedPreferences在此处查看

本文介绍了三种方法:

使用Instance State Bundle存储应用程序生命周期(即临时)的本地varible / UI控制数据

[Code sample – Store State in State Bundle]
@Override
public void onSaveInstanceState(Bundle savedInstanceState) 
{
  // Store UI state to the savedInstanceState.
  // This bundle will be passed to onCreate on next call.  EditText txtName = (EditText)findViewById(R.id.txtName);
  String strName = txtName.getText().toString();

  EditText txtEmail = (EditText)findViewById(R.id.txtEmail);
  String strEmail = txtEmail.getText().toString();

  CheckBox chkTandC = (CheckBox)findViewById(R.id.chkTandC);
  boolean blnTandC = chkTandC.isChecked();

  savedInstanceState.putString(“Name”, strName);
  savedInstanceState.putString(“Email”, strEmail);
  savedInstanceState.putBoolean(“TandC”, blnTandC);

  super.onSaveInstanceState(savedInstanceState);
}

使用共享首选项在应用程序实例之间(即永久地)存储本地变量/ UI控制数据

[Code sample – Store State in SharedPreferences]
@Override
protected void onPause() 
{
  super.onPause();

  // Store values between instances here
  SharedPreferences preferences = getPreferences(MODE_PRIVATE);
  SharedPreferences.Editor editor = preferences.edit();  // Put the values from the UI
  EditText txtName = (EditText)findViewById(R.id.txtName);
  String strName = txtName.getText().toString();

  EditText txtEmail = (EditText)findViewById(R.id.txtEmail);
  String strEmail = txtEmail.getText().toString();

  CheckBox chkTandC = (CheckBox)findViewById(R.id.chkTandC);
  boolean blnTandC = chkTandC.isChecked();

  editor.putString(“Name”, strName); // value to store
  editor.putString(“Email”, strEmail); // value to store
  editor.putBoolean(“TandC”, blnTandC); // value to store    
  // Commit to storage
  editor.commit();
}

使用保留的非配置实例,在应用程序生命周期内的活动之间保持对象实例在内存中存活

[Code sample – store object instance]
private cMyClassType moInstanceOfAClass;// Store the instance of an object
@Override
public Object onRetainNonConfigurationInstance() 
{
  if (moInstanceOfAClass != null) // Check that the object exists
      return(moInstanceOfAClass);
  return super.onRetainNonConfigurationInstance();
}

请注意,根据developer.android.com/reference/android/app/Activity.html有关活动状态的文档, 对于持久数据使用onSaveInstanceStateonRestoreInstanceState是不安全的。

该文件陈述(在“活动生命周期”部分):

请注意,将持久数据保存在onPause()而不是onSaveInstanceState(Bundle)非常重要,因为后者不是生命周期回调的一部分,因此不会在其文档中描述的每种情况下调用。

换句话说,将持久数据的保存/恢复代码放在onPause()onResume()

编辑 :为了进一步说明,这里是onSaveInstanceState()文档:

在活动可能被杀死之前调用此方法,以便在将来某个时间返回时它可以恢复其状态。 例如,如果活动B在活动A前面启动,并且在某些时候活动A被杀死以回收资源,活动A将有机会通过此方法保存其用户界面的当前状态,以便在用户返回时对于活动A,可以通过onCreate(Bundle)onRestoreInstanceState(Bundle)恢复用户界面的状态。


这是Android开发的经典“问题”。 这里有两个问题:

  • 有一个微妙的Android Framework错误,它使开发过程中的应用程序堆栈管理变得非常复杂,至少在旧版本上是这样(不完全确定是否/何时/如何修复)。 我将在下面讨论这个错误。
  • 管理此问题的“正常”或预期方式本身相当复杂,具有onPause / onResume和onSaveInstanceState / onRestoreInstanceState的二元性

浏览所有这些线程,我怀疑开发人员大多数时间同时讨论这两个不同的问题......因此所有混淆和报告“这对我不起作用”。

首先,澄清“预期”行为:onSaveInstance和onRestoreInstance是脆弱的,仅适用于瞬态。 预期用途(afaict)用于在电话旋转(方向改变)时处理活动娱乐。 换句话说,预期的用法是当您的Activity仍然在逻辑上“在顶部”时,但仍然必须由系统重新实例化。 保存的Bundle不会在进程/ memory / gc之外保留,因此如果您的活动进入后台,则无法真正依赖它。 是的,也许你的Activity的记忆将在它的背景之旅中存活并逃脱GC,但这不可靠(也不可预测)。

因此,如果您的某个场景中存在有意义的“用户进度”或应该在应用程序的“启动”之间保留的状态,则指导是使用onPause和onResume。 您必须自己选择并准备持久性商店。

但是 - 有一个非常混乱的错误使所有这一切变得复杂。 细节在这里:

http://code.google.com/p/android/issues/detail?id=2373

http://code.google.com/p/android/issues/detail?id=5277

基本上,如果您的应用程序是使用SingleTask标志启动的,然后您从主屏幕或启动器菜单启动它,那么后续调用将创建一个新任务...您将有效地拥有两个不同的应用实例居住在同一堆栈中......这非常快速地变得非常奇怪。 当您在开发期间(即从Eclipse或Intellij)启动应用程序时,这似乎会发生,因此开发人员会遇到这种情况。 但也通过一些应用程序商店更新机制(因此它也会影响您的用户)。

在我意识到我的主要问题是这个错误,而不是预期的框架行为之前,我在这些线程中奋战了几个小时。 一个伟大的写作和 解决方法 (更新:见下文)似乎来自用户@kaciula在这个答案中:

主页按键行为

更新2013年6月 :几个月后,我终于找到了“正确”的解决方案。 您不需要自己管理任何有状态的startupApp标记,您可以从框架中检测到这一点并适当地保释。 我在LauncherActivity.onCreate的开头附近使用它:

if (!isTaskRoot()) {
    Intent intent = getIntent();
    String action = intent.getAction();
    if (intent.hasCategory(Intent.CATEGORY_LAUNCHER) && action != null && action.equals(Intent.ACTION_MAIN)) {
        finish();
        return;
    }
}

onSaveInstance当活动进入后台时,确实说明了callen

从文档引用:“ onSaveInstanceState(Bundle)在将活动置于这样的背景状态之前调用该方法”


为了帮助减少样板,我使用以下内容interfaceclass读取/写入以Bundle保存实例状态。

首先,创建一个用于注释实例变量的接口:

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({
        ElementType.FIELD
})
public @interface SaveInstance {

}

然后,创建一个类,其中将使用反射将值保存到包中:

import android.app.Activity;
import android.app.Fragment;
import android.os.Bundle;
import android.os.Parcelable;
import android.util.Log;

import java.io.Serializable;
import java.lang.reflect.Field;

/**
 * Save and load fields to/from a {@link Bundle}. All fields should be annotated with {@link
 * SaveInstance}.</p>
 */
public class Icicle {

    private static final String TAG = "Icicle";

    /**
     * Find all fields with the {@link SaveInstance} annotation and add them to the {@link Bundle}.
     *
     * @param outState
     *         The bundle from {@link Activity#onSaveInstanceState(Bundle)} or {@link
     *         Fragment#onSaveInstanceState(Bundle)}
     * @param classInstance
     *         The object to access the fields which have the {@link SaveInstance} annotation.
     * @see #load(Bundle, Object)
     */
    public static void save(Bundle outState, Object classInstance) {
        save(outState, classInstance, classInstance.getClass());
    }

    /**
     * Find all fields with the {@link SaveInstance} annotation and add them to the {@link Bundle}.
     *
     * @param outState
     *         The bundle from {@link Activity#onSaveInstanceState(Bundle)} or {@link
     *         Fragment#onSaveInstanceState(Bundle)}
     * @param classInstance
     *         The object to access the fields which have the {@link SaveInstance} annotation.
     * @param baseClass
     *         Base class, used to get all superclasses of the instance.
     * @see #load(Bundle, Object, Class)
     */
    public static void save(Bundle outState, Object classInstance, Class<?> baseClass) {
        if (outState == null) {
            return;
        }
        Class<?> clazz = classInstance.getClass();
        while (baseClass.isAssignableFrom(clazz)) {
            String className = clazz.getName();
            for (Field field : clazz.getDeclaredFields()) {
                if (field.isAnnotationPresent(SaveInstance.class)) {
                    field.setAccessible(true);
                    String key = className + "#" + field.getName();
                    try {
                        Object value = field.get(classInstance);
                        if (value instanceof Parcelable) {
                            outState.putParcelable(key, (Parcelable) value);
                        } else if (value instanceof Serializable) {
                            outState.putSerializable(key, (Serializable) value);
                        }
                    } catch (Throwable t) {
                        Log.d(TAG, "The field '" + key + "' was not added to the bundle");
                    }
                }
            }
            clazz = clazz.getSuperclass();
        }
    }

    /**
     * Load all saved fields that have the {@link SaveInstance} annotation.
     *
     * @param savedInstanceState
     *         The saved-instance {@link Bundle} from an {@link Activity} or {@link Fragment}.
     * @param classInstance
     *         The object to access the fields which have the {@link SaveInstance} annotation.
     * @see #save(Bundle, Object)
     */
    public static void load(Bundle savedInstanceState, Object classInstance) {
        load(savedInstanceState, classInstance, classInstance.getClass());
    }

    /**
     * Load all saved fields that have the {@link SaveInstance} annotation.
     *
     * @param savedInstanceState
     *         The saved-instance {@link Bundle} from an {@link Activity} or {@link Fragment}.
     * @param classInstance
     *         The object to access the fields which have the {@link SaveInstance} annotation.
     * @param baseClass
     *         Base class, used to get all superclasses of the instance.
     * @see #save(Bundle, Object, Class)
     */
    public static void load(Bundle savedInstanceState, Object classInstance, Class<?> baseClass) {
        if (savedInstanceState == null) {
            return;
        }
        Class<?> clazz = classInstance.getClass();
        while (baseClass.isAssignableFrom(clazz)) {
            String className = clazz.getName();
            for (Field field : clazz.getDeclaredFields()) {
                if (field.isAnnotationPresent(SaveInstance.class)) {
                    String key = className + "#" + field.getName();
                    field.setAccessible(true);
                    try {
                        Object fieldVal = savedInstanceState.get(key);
                        if (fieldVal != null) {
                            field.set(classInstance, fieldVal);
                        }
                    } catch (Throwable t) {
                        Log.d(TAG, "The field '" + key + "' was not retrieved from the bundle");
                    }
                }
            }
            clazz = clazz.getSuperclass();
        }
    }

}

用法示例:

public class MainActivity extends Activity {

    @SaveInstance
    private String foo;

    @SaveInstance
    private int bar;

    @SaveInstance
    private Intent baz;

    @SaveInstance
    private boolean qux;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Icicle.load(savedInstanceState, this);
    }

    @Override
    public void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        Icicle.save(outState, this);
    }

}

注意:此代码改编自名为AndroidAutowire的库项目,该项目根据MIT许可证获得许可


仅在旋转屏幕(方向改变)时,onSaveInstanceState(bundle)onRestoreInstanceState(bundle)方法对于数据持久性是有用的。
他们不是在应用程序之间切换(因为即使是好的onSaveInstanceState()方法被调用,但onCreate(bundle)onRestoreInstanceState(bundle)没有再次调用。
欲了解更多持久使用共享偏好。阅读这篇文章


尽管接受的答案是正确的,但是使用名为Icepick的库在Android上保存活动状态的方法更快更容易。Icepick是一个注释处理器,负责处理为您保存和恢复状态时使用的所有样板代码。

用Icepick做这样的事情:

class MainActivity extends Activity {
  @State String username; // These will be automatically saved and restored
  @State String password;
  @State int age;

  @Override public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    Icepick.restoreInstanceState(this, savedInstanceState);
  }

  @Override public void onSaveInstanceState(Bundle outState) {
    super.onSaveInstanceState(outState);
    Icepick.saveInstanceState(this, outState);
  }
}

这样做是一样的:

class MainActivity extends Activity {
  String username;
  String password;
  int age;

  @Override
  public void onSaveInstanceState(Bundle savedInstanceState) {
    super.onSaveInstanceState(savedInstanceState);
    savedInstanceState.putString("MyString", username);
    savedInstanceState.putString("MyPassword", password);
    savedInstanceState.putInt("MyAge", age); 
    /* remember you would need to actually initialize these variables before putting it in the
    Bundle */
  }

  @Override
  public void onRestoreInstanceState(Bundle savedInstanceState) {
    super.onRestoreInstanceState(savedInstanceState);
    username = savedInstanceState.getString("MyString");
    password = savedInstanceState.getString("MyPassword");
    age = savedInstanceState.getInt("MyAge");
  }
}

Icepick将使用任何保存其状态的对象Bundle


我的问题是我只在应用程序生命周期中需要持久性(即单个执行包括在同一个应用程序中启动其他子活动并旋转设备等)。我尝试了上述答案的各种组合,但在所有情况下都没有得到我想要的东西。最后,对我有用的是在onCreate期间获取对savedInstanceState的引用:

mySavedInstanceState=savedInstanceState;

并在我需要时使用它来获取变量的内容,类似于:

if (mySavedInstanceState !=null) {
   boolean myVariable = mySavedInstanceState.getBoolean("MyVariable");
}

我使用onSaveInstanceStateonRestoreInstanceState如上所述,但我想我也可以或者使用我的方法来保存变量(例如使用putBoolean


直接回答原始问题。savedInstancestate为null,因为永远不会重新创建Activity。

只有在以下情况下,才会使用州捆绑包重新创建您的活动:

  • 配置更改,例如更改方向或电话语言,这可能需要创建新的活动实例。
  • 操作系统销毁活动后,您将从后台返回应用程序。

Android会在内存压力下或在长时间处于后台后销毁后台活动。

在测试hello world示例时,有几种方法可以离开并返回Activity。

  • 当您按后退按钮时,活动结束。重新启动应用程序是一个全新的实例。你根本没有从后台恢复。
  • 当您按主页按钮或使用任务切换器时,活动将进入后台。导航回应用程序时,只有在必须销毁活动时才会调用onCreate。

在大多数情况下,如果您只是按下主页然后再次启动应用程序,则无需重新创建活动。它已经存在于内存中,因此不会调用onCreate()。

“设置” - >“开发者选项”下有一个名为“不要保留活动”的选项。当它启用时,Android将始终销毁活动并在它们背景时重新创建它们。这是在开发时保持启用的一个很好的选项,因为它模拟了最坏的情况。(低内存设备一直在回收您的活动)。

其他答案是有价值的,因为他们教你正确的存储状态的方法,但我不觉得他们真的回答为什么你的代码没有以你预期的方式工作。


简单快速解决这个问题就是使用Icepick

首先,设置库 app/build.gradle

repositories {
  maven {url "https://clojars.org/repo/"}
}
dependencies {
  compile 'frankiesardo:icepick:3.2.0'
  provided 'frankiesardo:icepick-processor:3.2.0'
}

现在,让我们查看下面的示例如何在Activity中保存状态

public class ExampleActivity extends Activity {
  @State String username; // This will be automatically saved and restored

  @Override public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    Icepick.restoreInstanceState(this, savedInstanceState);
  }

  @Override public void onSaveInstanceState(Bundle outState) {
    super.onSaveInstanceState(outState);
    Icepick.saveInstanceState(this, outState);
  }
}

它适用于活动,碎片或任何需要在Bundle上序列化其状态的对象(例如迫击炮的ViewPresenters)

Icepick还可以为自定义视图生成实例状态代码:

class CustomView extends View {
  @State int selectedPosition; // This will be automatically saved and restored

  @Override public Parcelable onSaveInstanceState() {
    return Icepick.saveInstanceState(this, super.onSaveInstanceState());
  }

  @Override public void onRestoreInstanceState(Parcelable state) {
    super.onRestoreInstanceState(Icepick.restoreInstanceState(this, state));
  }

  // You can put the calls to Icepick into a BaseCustomView and inherit from it
  // All Views extending this CustomView automatically have state saved/restored
}




application-state