在这篇文章中，我们将带领您了解使用ActivityLifecycleCallbacks自动记录Android生命周期事件？的全貌，包括androidactivity生命周期状态的相关情况。同时，我们还
在这篇文章中，我们将带领您了解使用ActivityLifecycleCallbacks自动记录Android生命周期事件？的全貌，包括android activity生命周期 状态的相关情况。同时，我们还将为您介绍有关Activity Lifecycle、ActivityLifecycleCallbacks、ActivityLifecycleCallbacks 管理 Activity 栈（监听 home 键）、ActivityLifeCycle详解android Activity生命周期的知识，以帮助您更好地理解这个主题。
本文目录一览：- 使用ActivityLifecycleCallbacks自动记录Android生命周期事件？（android activity生命周期 状态）
- Activity Lifecycle
- ActivityLifecycleCallbacks
- ActivityLifecycleCallbacks 管理 Activity 栈（监听 home 键）
- ActivityLifeCycle详解android Activity生命周期
使用ActivityLifecycleCallbacks自动记录Android生命周期事件？（android activity生命周期 状态）
我正在尝试使用ActivityLifecycleCallbacks自动捕获和记录Android生命周期事件，但是至少可以说，有关此问题的文档非常少：
public void registerActivityLifecycleCallbacks (Application.ActivityLifecycleCallbacks callback)我不想扩展Activity类或重写现有的生命周期方法（onCreate，onResume等）。我希望有一个单独的类来监听这些事件并采取相应的行动。
有没有人在这方面有任何经验，或者有链接到有效的可靠文档或教程？具体来说，如何注册ActivityLifecycleCallbacks，以及如何处理它们？
答案1
小编典典我对做了自己的实现Application.ActivityLifecycleCallbacks。我正在使用SherlockActivity，但对于正常的Activity类可能有效。
首先，我正在创建一个接口，该接口具有用于跟踪活动生命周期的所有方法：
public interface ActivityLifecycleCallbacks{ public void onActivityStopped(Activity activity); public void onActivityStarted(Activity activity); public void onActivitySaveInstanceState(Activity activity, Bundle outState); public void onActivityResumed(Activity activity); public void onActivityPaused(Activity activity); public void onActivityDestroyed(Activity activity); public void onActivityCreated(Activity activity, Bundle savedInstanceState);}其次，我在应用程序的类中实现了此接口：
public class MyApplication extends Application implements my.package.ActivityLifecycleCallbacks{ @Override public void onCreate() { super.onCreate(); } @Override public void onActivityStopped(Activity activity) { Log.i("Tracking Activity Stopped", activity.getLocalClassName()); } @Override public void onActivityStarted(Activity activity) { Log.i("Tracking Activity Started", activity.getLocalClassName()); } @Override public void onActivitySaveInstanceState(Activity activity, Bundle outState) { Log.i("Tracking Activity SaveInstanceState", activity.getLocalClassName()); } @Override public void onActivityResumed(Activity activity) { Log.i("Tracking Activity Resumed", activity.getLocalClassName()); } @Override public void onActivityPaused(Activity activity) { Log.i("Tracking Activity Paused", activity.getLocalClassName()); } @Override public void onActivityDestroyed(Activity activity) { Log.i("Tracking Activity Destroyed", activity.getLocalClassName()); } @Override public void onActivityCreated(Activity activity, Bundle savedInstanceState) { Log.i("Tracking Activity Created", activity.getLocalClassName()); }}第三，我正在创建一个继承自SherlockActivity的类：
public class MySherlockActivity extends SherlockActivity { protected MyApplication nMyApplication; protected void onCreate(Bundle savedInstanceState) { // TODO Auto-generated method stub super.onCreate(savedInstanceState); nMyApplication = (MyApplication) getApplication(); nMyApplication.onActivityCreated(this, savedInstanceState); } protected void onResume() { // TODO Auto-generated method stub super.onResume(); nMyApplication.onActivityResumed(this); } @Override protected void onPause() { // TODO Auto-generated method stub super.onPause(); nMyApplication.onActivityPaused(this); } @Override protected void onDestroy() { // TODO Auto-generated method stub super.onDestroy(); nMyApplication.onActivityDestroyed(this); } @Override protected void onStart() { super.onStart(); nMyApplication.onActivityStarted(this); } @Override protected void onStop() { super.onStop(); nMyApplication.onActivityStopped(this); } @Override protected void onSaveInstanceState(Bundle outState) { super.onSaveInstanceState(outState); nMyApplication.onActivitySaveInstanceState(this, outState); } }第四，所有从SherlockActivity扩展的类，我都替换为MySherlockActivity：
public class MainActivity extends MySherlockActivity{ @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); }}现在，在logcat中，您将看到MyApplication中实现的Interface实现中编程的日志。
更新
此实现已通过API级别9（姜饼），API级别12（蜂窝）和API级别17（果冻豆）进行了测试，并且运行良好。可能适用于Android的旧版本。
Activity Lifecycle
官方介绍网址：http://developer.android.com/reference/android/app/Activity.html
大家好，今天给大家详解一下 Android 中 Activity 的生命周期，我在前面也曾经讲过这方面的内容，但是像网上大多数文章一样，基本都是翻译 Android API，过于笼统，相信大家看了，会有一点点的帮助，但是还不能完全吃透，所以我今天特意在重新总结一下.
首先看一下 Android api 中所提供的 Activity 生命周期图 (不明白的，可以看完整篇文章，在回头看一下这个图，你会明白的):
Activity 其实是继承了 ApplicationContext 这个类，我们可以重写以下方法，如下代码:
view plaincopy to clipboardprint?
public class Activity extends ApplicationContext {
protected void onCreate(Bundle savedInstanceState);
protected void onStart();
protected void onRestart();
protected void onResume();
protected void onPause();
protected void onStop();
protected void onDestroy();
}第一步：新建一个 Android 工程，我这里命名为 ActivityDemo.
第二步：修改 ActivityDemo.java (我这里重新写了以上的七种方法，主要用 Log 打印), 代码如下:
package com.tutor.activitydemo;
import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
public class ActivityDemo extends Activity {
private static final String TAG = "ActivityDemo";
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
Log.e(TAG, "start onCreate~~~");
}
@Override
protected void onStart() {
super.onStart();
Log.e(TAG, "start onStart~~~");
}
@Override
protected void onRestart() {
super.onRestart();
Log.e(TAG, "start onRestart~~~");
}
@Override
protected void onResume() {
super.onResume();
Log.e(TAG, "start onResume~~~");
}
@Override
protected void onPause() {
super.onPause();
Log.e(TAG, "start onPause~~~");
}
@Override
protected void onStop() {
super.onStop();
Log.e(TAG, "start onStop~~~");
}
@Override
protected void onDestroy() {
super.onDestroy();
Log.e(TAG, "start onDestroy~~~");
}
} 
核心在 Logcat 视窗里，如果你还不会用 Logcat 你可以看一下我的这篇文章 Log 图文详解 (Log.v,Log.d,Log.i,Log.w,Log.e)，我们打开应用时先后执行了 onCreate ()->onStart ()->onResume 三个方法，看一下 LogCat 视窗如下:
BACK 键：
当我们按 BACK 键时，我们这个应用程序将结束，这时候我们将先后调用 onPause ()->onStop ()->onDestory () 三个方法，如下图所示:
HOME 键:
当我们打开应用程序时，比如浏览器，我正在浏览 NBA 新闻，看到一半时，我突然想听歌，这时候我们会选择按 HOME 键，然后去打开音乐应用程 序，而当我们按 HOME 的时候，Activity 先后执行了 onPause ()->onStop () 这两个方法，这时候应用程序并没有销毁。如下图 所示:
而当我们再次启动 ActivityDemo 应用程序时，则先后分别执行了 onRestart ()->onStart ()->onResume () 三个方法，如下图所示:
这里我们会引出一个问题，当我们按 HOME 键，然后再进入 ActivityDemo 应用时，我们的应用的状态应该是和按 HOME 键之前的状态是一样的，同样为了方便理解，在这里我将 ActivityDemo 的代码作一些修改，就是增加一个 EditText。
第四步：修改 main.xml 布局文件（增加了一个 EditText), 代码如下:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
>
<TextView
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="@string/hello"
/>
<EditText
android:id="@+id/editText"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
/>
</LinearLayout>第五步：然后其他不变，运行 ActivityDemo 程序，在 EditText 里输入如 "Frankie" 字符串 (如下图：)
这时候，大家可以按一下 HOME 键，然后再次启动 ActivityDemo 应用程序，这时候 EditText 里并没有我们输入的 "Frankie" 字样，如下图:
这显然不能称得一个合格的应用程序，所以我们需要在 Activity 几个方法里自己实现，如下第六步所示:
第六步修改 ActivityDemo.java 代码如下:
package com.tutor.activitydemo;
import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
import android.widget.EditText;
public class ActivityDemo extends Activity {
private static final String TAG = "ActivityDemo";
private EditText mEditText;
//定义一个String 类型用来存取我们EditText输入的值
private String mString;
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
mEditText = (EditText)findViewById(R.id.editText);
Log.e(TAG, "start onCreate~~~");
}
@Override
protected void onStart() {
super.onStart();
Log.e(TAG, "start onStart~~~");
}
//当按HOME键时，然后再次启动应用时，我们要恢复先前状态
@Override
protected void onRestart() {
super.onRestart();
mEditText.setText(mString);
Log.e(TAG, "start onRestart~~~");
}
@Override
protected void onResume() {
super.onResume();
Log.e(TAG, "start onResume~~~");
}
//当我们按HOME键时，我在onPause方法里，将输入的值赋给mString
@Override
protected void onPause() {
super.onPause();
mString = mEditText.getText().toString();
Log.e(TAG, "start onPause~~~");
}
@Override
protected void onStop() {
super.onStop();
Log.e(TAG, "start onStop~~~");
}
@Override
protected void onDestroy() {
super.onDestroy();
Log.e(TAG, "start onDestroy~~~");
}
}第七步：重新运行 ActivityDemo 程序，重复第五步操作，当我们按 HOME 键时，再次启动应用程序时，EditText 里有上次输入的 "Frankie" 字样，如下图如示:
OK, 大功基本告成，这时候大家可以在回上面看一下 Activity 生命周期图，我想大家应该完全了解了 Activity 的生命周期了，不知道你了解了没？
ActivityLifecycleCallbacks
ActivityLifecycleCallbacks是什么？
- Application通过此接口提供了一套回调方法，用于让开发者对Activity的生命周期事件进行集中处理。
为什么用ActivityLifecycleCallbacks？
- 以往若需监测Activity的生命周期事件代码，你可能是这样做的，重写每一个Acivity的onResume()，然后作统计和处理：
@Override
protected void onResume() {
super.onResume();
//TODO 处理和统计代码
Log.v(TAG, "onResume");
} - ActivityLifecycleCallbacks接口回调可以简化这一繁琐过程，在一个类中作统一处理
ActivityLifecycleCallbacks怎么用？
- android.app.Application.ActivityLifecycleCallbacks
- 要求API 14+ （Android 4.0+）
- 继承Application
- 重写Application的onCreate()方法，或在Application的无参构造方法内，调用Application.registerActivityLifecycleCallbacks()方法，并实现ActivityLifecycleCallbacks接口
public void onCreate() {
super.onCreate();
this.registerActivityLifecycleCallbacks(new ActivityLifecycleCallbacks() {
@Override
public void onActivityStopped(Activity activity) {
Logger.v(activity, "onActivityStopped");
}
@Override
public void onActivityStarted(Activity activity) {
Logger.v(activity, "onActivityStarted");
}
@Override
public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
Logger.v(activity, "onActivitySaveInstanceState");
}
@Override
public void onActivityResumed(Activity activity) {
Logger.v(activity, "onActivityResumed");
}
@Override
public void onActivityPaused(Activity activity) {
Logger.v(activity, "onActivityPaused");
}
@Override
public void onActivityDestroyed(Activity activity) {
Logger.v(activity, "onActivityDestroyed");
}
@Override
public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
Logger.v(activity, "onActivityCreated");
}
});
};
ActivityLifecycleCallbacks的拓展用法
-
本次初探仅尝试使用Log日志工具作简要测试，如需满足较复杂的统计或调试需求时，此法可能会大大减少插入代码量，提高效率
-
在Fragment也可以提供类似方法的开源库 https://github.com/soarcn/AndroidLifecyle
ActivityLifecycleCallbacks 管理 Activity 栈（监听 home 键）
Android 在 API14 之后添加了用于监听应用 Activity 生命周期的回调接口 ActivityLifecycleCallbacks，使用时需要在 Application 中进行注册。 
可以看到 ActivityLifecycleCallbacks 中的方法跟 Activity 生命周期方法基本是一致的。
注册与取消注册
public class MyApplication extends Application {
public static final String TAG = MyApplication.class.getSimpleName();
/** Activity监听回调 */
private ActivityLifecycleCallbacks activityLifecycleCallbacks = new ActivityLifecycleCallbacks() {
....
};
@Override
public void onCreate() {
super.onCreate();
//可注册多次，注册多个生命周期回调
registerActivityLifecycleCallbacks(activityLifecycleCallbacks);
//Activity管理
registerActivityLifecycleCallbacks(ActivityManager.getInstance());
}
@Override
public void onTerminate() {
super.onTerminate();
//Android API中没有对此方法的过多解释，不过通常此方法会在app退出是被调用（并不是100%）
unregisterActivityLifecycleCallbacks(activityLifecycleCallbacks);
}
}
需要注意的是 Android 允许注册多个 ActivityLifecycleCallbacks，并且同时生效。
优雅的管理 Activity
实现 ActivityLifecycleCallbacks 接口，并创建 Activity 的任务栈，通过监听回调实现 Activity 的进栈和出栈。需要在 Application 中进行注册。
/**
* Activity管理类<br/>
* 需要在Application中调用registerActivityLifecycleCallbacks注册
*/
public class ActivityManager implements Application.ActivityLifecycleCallbacks {
//Activity栈
private Stack<Activity> activities = new Stack<>();
private static ActivityManager activityManager;
private ActivityManager(){
}
/**
* 单例
* @return activityManager instance
*/
public static ActivityManager getInstance(){
if(activityManager == null){
synchronized (ActivityManager.class){
if(activityManager == null){
activityManager = new ActivityManager();
}
}
}
return activityManager;
}
/**
* 获取Activity任务栈
* @return activity stack
*/
public Stack<Activity> getActivityStack(){
return activities;
}
/**
* Activity 入栈
* @param activity Activity
*/
public void addActivity(Activity activity){
activities.add(activity);
}
/**
* Activity出栈
* @param activity Activity
*/
public void removeActivity(Activity activity){
if(activity != null){
activities.remove(activity);
}
}
/**
* 结束某Activity
* @param activity Activity
*/
public void finishActivity(Activity activity){
if(activity != null){
removeActivity(activity);
activity.finish();
}
}
/**
* 获取当前Activity
* @return current activity
*/
public Activity getCurrentActivity(){
return activities.lastElement();
}
/**
* 结束当前Activity
*/
public void finishActivity(){
finishActivity(activities.lastElement());
}
@Override
public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
addActivity(activity);
}
@Override
public void onActivityStarted(Activity activity) {
}
@Override
public void onActivityResumed(Activity activity) {
}
@Override
public void onActivityPaused(Activity activity) {
}
@Override
public void onActivityStopped(Activity activity) {
}
@Override
public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
}
@Override
public void onActivityDestroyed(Activity activity) {
removeActivity(activity);
}
}
通过上面的 Activity 管理栈可以扩展实现如下需求：
- 监听应用中集成的第三方 SDK 中的 Activity 的启动。
- 可以控制应用中某个 Activity 被初始化的数量，如商城应用中的商品详情页，避免无限制的创建 Activity。
- 判断应用是否处于前台可见状态，通过 onActivityResumed 和 onActivityPaused 回调方法实现。
监听 Home 键
我们在开发过程中有时候会碰到一些特殊需求需要监听 home 键，释放一些资源或者销毁 activity 等。但 Home 键事件不同于其他普通按键可以通过 OnKeyDown、dispatchKeyEvent 等按键监听方法捕获处理，Android 系统并没有提供直接监听 Home 键的方法。但是，当按下 Home 键是系统会发送 Intent.ACTION_CLOSE_SYSTEM_DIALOGS 广播（多任务键也会发送此广播）。我们可以通过监听此广播，来间接的监听 Home 键事件。
public class HomeKeyListenerBroadcast extends BroadcastReceiver {
private Context context;
private OnHomeKeyPressListener onHomeKeyPressListener;
private boolean isRegiested = false;
public HomeKeyListenerBroadcast(Context context){
this.context = context;
}
public HomeKeyListenerBroadcast(Context context, OnHomeKeyPressListener onHomeKeyPressListener){
this.context = context;
this.onHomeKeyPressListener = onHomeKeyPressListener;
}
public void setOnHomeKeyPressListener(OnHomeKeyPressListener onHomeKeyPressListener){
this.onHomeKeyPressListener = onHomeKeyPressListener;
}
/**
* 广播注册
*/
public void registerSelf(){
if(context != null){
IntentFilter filter = new IntentFilter();
filter.addAction(Intent.ACTION_CLOSE_SYSTEM_DIALOGS);
context.registerReceiver(this, filter);
isRegiested = true;
}
}
/**
* 广播UnRegister
*/
public void unRegisterSelf(){
if(isRegiested){
context.unregisterReceiver(this);
isRegiested = false;
}
}
@Override
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
if (Intent.ACTION_CLOSE_SYSTEM_DIALOGS.equals(action)) {
String reason = intent.getStringExtra("reason");
if ("homekey".equals(reason)) {
// 按下HOME健
if (onHomeKeyPressListener != null) {
onHomeKeyPressListener.onHomeKeyPress();
}
} else if ("recentapps".equals(reason)) {
// 长按HOME键
if (onHomeKeyPressListener != null) {
onHomeKeyPressListener.onRecentAppsKeyLongPress();
}
}
}
}
/**
* 事件回调接口
*/
public interface OnHomeKeyPressListener{
void onHomeKeyPress();
void onRecentAppsKeyLongPress();
}
}
代码很简单，不做过多解释了。需要注意的是此广播肯定是动态注册的，在需要的 Activity 中进行注册并监听按键事件，记得要在 onDestroy 中取消注册。
ActivityLifeCycle详解android Activity生命周期
一个简洁的Activity生命周期说明图，类似阶梯金字塔。这张图显示了Activity的各个状态到达onResume状态的回调函数（callback）。由于Activity的复杂性，我们并不需要实现生命周期里所包含的所有的方法，重要是理解每个方法并实现它，达到用户的期望。
实现生命周期里的方法能保证（1）用户在使用你的app的时候接到一个电话或者转到其他app，你的app不会崩溃。
（2）当用户不常使用的时候不会消耗珍贵的系统资源。
（3）当用户离开app再返回时不会丢失离开时的进度。
（4）当屏幕旋转时不会丢失当时的进度。除了以下三种状态，生命周期里的其他状态都是不稳定的（不长期存在，只是到达稳定状态的过度）。（1）onResume( )这个状态下，Activity处于前台，用户可以与之交互。
（2）onPause( )这个状态下，activity被另一个activity部分遮住。即另一个处于前台半透明的或没有占满全屏的activity。处于pause状态的activity不能收到用户的输入，不会执行任何代码。
（3）onStop( )这个状态下，activity被完全隐藏，用户看不到。activity的实例和成员变量都被保留，但不能执行任何代码。activity启动时，system调用onCreate( )之后快速调用onStart( )接着到达onResume( )。
以下为几种行为下的函数调用情况：
1、创建新的实例时：
这个说明图重点说明在创建实例时系统依次调用的三个主要回调函数onCreate( )、onStart( )、onResume( )。这三个函数依次调用后就到了onResume( )状态，此时用户就可以与 activity交互。
TextView mTextView; // Member variable for text view in the layout
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// Set the user interface layout for this Activity
// The layout file is defined in the project res/layout/main_activity.xml file
setContentView(R.layout.main_activity);
// Initialize member TextView so we can manipulate it later
mTextView = (TextView) findViewById(R.id.text_message);
// Make sure we''re running on Honeycomb or higher to use ActionBar APIs
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
// For the main activity, make sure the app icon in the action bar
// does not behave as a button
ActionBar actionBar = getActionBar();
actionBar.setHomeButtonEnabled(false);
}
}2、销毁一个活动，onDestroy( )
系统在调用onDestroy( )之前会先调用onPause( )、onStop( )，除非当你的activity作为一个暂时的决策者（decision maker）去启动（launch）另一个activity，你可能会在onCreate( )中调用finish( )来销毁你的activity。
@Override
public void onDestroy() {
super.onDestroy(); // Always call the superclass
// Stop method tracing that the activity started during onCreate()
android.os.Debug.stopMethodTracing();
}3、停止和恢复一个Activity，（Pausing and Resuming an Activity）
当一个半透明状态(semi-transparent)的activity模糊了你的activity，系统调用onPause( ),activity会在上图状态1等待，当处于onPause状态是用户返回activity系统调用onResume( )。例如相机：
@Override
public void onPause() {
super.onPause(); // Always call the superclass method first
// Release the Camera because we don''t need it when paused
// and other activities might need to use it.
if (mCamera != null) {
mCamera.release()
mCamera = null;
}
}当用户将activity从PauseState恢复时调用onResume( )。每当activity到前台时，或activity第一次创建时系统都会调用onResume( )。因此你需要实现onResume( )方法来初始化在onPause( )时释放掉的元素。
下面的一个例子是在onResume( )中对Pause相机释放掉的初始化：
@Override
public void onResume() {
super.onResume(); // Always call the superclass method first
// Get the Camera instance as the activity achieves full user focus
if (mCamera == null) {
initializeCamera(); // Local method to handle camera init
}
}4、停止和重新启动一个Activity（Stoping and Restarting an Activity）
当用户离开activity,系统调用onStop( ) 1来使activity停止,当activity在停止状态，用户返回，系统调用onRestart( )2,紧接着是onStart( )、onResume( ).无论何种情况系统停止一个activity,总是在调用onStop( )之前调用onPause( )。当activity接收到onStop( )方法，activity就不可见了并且释放所有当用户不使用activity时的资源。当 activity Stop时很可能会内存泄漏，因此最好use onStop( ) to perform larger，下面一个例子是onStop( )方法的实现，在存储器中保存草稿（saves the contents of a draft note to persistent storage）。
@Override
protected void onStop() {
super.onStop(); // Always call the superclass method first
// Save the note''s current draft, because the activity is stopping
// and we want to be sure the current note progress isn''t lost.
ContentValues values = new ContentValues();
values.put(NotePad.Notes.COLUMN_NAME_NOTE, getCurrentNoteText());
values.put(NotePad.Notes.COLUMN_NAME_TITLE, getCurrentNoteTitle());
getContentResolver().update(
mUri, // The URI for the note to update.
values, // The map of column names and new values to apply to them.
null, // No SELECT criteria are used.
null // No WHERE columns are used.
);
}当activity is stopped，Activity 对象会在内存中保存，当activity恢复时调用，不用重新初始化元素。系统还会记录每个View的当前状态，例如关闭前在EditText中输入的内容再次打开时会显示。
5、重新创建一个Activity
当系统停止一个activity，它调用onSaveInstanceState( ).如果activity destroyed,同样的实例再次创建的时候，系统会将在1定义的状态数据传递给2onCreate( )方法和3onRestoreInstanceState( )方法。当activity开始stop的时候，系统调用onSaveInstanceState( )，因此activity以键值对的形式收集信息。
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);
}关于使用ActivityLifecycleCallbacks自动记录Android生命周期事件？和android activity生命周期 状态的介绍已经告一段落，感谢您的耐心阅读，如果想了解更多关于Activity Lifecycle、ActivityLifecycleCallbacks、ActivityLifecycleCallbacks 管理 Activity 栈（监听 home 键）、ActivityLifeCycle详解android Activity生命周期的相关信息，请在本站寻找。
本文标签：
