写在前面的话
最近高产似母猪，每天都会写点关于这个系列的总结。周一了，又开始忙碌的一天。项目赶赶赶，bug改改改，盼望着盼望着，终于下班了。突然想起小时候学过的一篇课文《和时间赛跑》，越来越觉得“光阴似箭，日月如梭”了。还以为是那个刚刚来到魔都的毛头小子，突然间发现，现在已然变成了“猥琐大叔”了。
虽然我并不猥琐，虽然我并不是大叔。噢！又想起大学宿舍的猥琐小哥了，那猥琐的样子.....
哎~不扯了，再扯就不用写了。
1. 关于Activity的生命周期
自从开始入Android的坑的时候，就一直念叨着Activity启动时先onCreate，再onStart，最后onResume。各个阶段是啥含义具体不讲了（我不会说我也不知道）。
但是，自从开始做Android就想过，这几个方法究竟是什么时候调用的？又是谁去调用的他？以前呢，自己太菜了（虽然现在也是。。），根本没有好好去看，最近有时间好好总结下关于这方面的知识。
在前面的Android的luncher启动过程中已经讲到，Activity启动的时候会调用ApplicationThread的scheduleLaunchActivity方法。下面从这个地方开始分析整个过程。
2. scheduleLaunchActivity方法
这个方法其实不想说的，这里面只做了一个操作，就是通过Handler发送
LAUNCH_ACTIVITY消息。
@Override
public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,
ActivityInfo info, Configuration curConfig, Configuration overrideConfig,
CompatibilityInfo compatInfo, String referrer, IVoiceInteractor voiceInteractor,
int procState, Bundle state, PersistableBundle persistentState,
List<ResultInfo> pendingResults, List<ReferrerIntent> pendingNewIntents,
boolean notResumed, boolean isForward, ProfilerInfo profilerInfo) {
//对变量各种赋值
......
//发送LAUNCH_ACTIVITY消息，并把数据传入
sendMessage(H.LAUNCH_ACTIVITY, r);
}
这里简单看下这个H是何方神圣
private class H extends Handler，好了看完了。这就够了，这就是个Handler。
3. Handler处理LAUNCH_ACTIVITY消息
这里面处理也是很简单的，调用了
handleLaunchActivity(r, null, "LAUNCH_ACTIVITY");方法。
public void handleMessage(Message msg) {
if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
switch (msg.what) {
case LAUNCH_ACTIVITY: {
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
final ActivityClientRecord r = (ActivityClientRecord) msg.obj;
r.packageInfo = getPackageInfoNoCheck(
r.activityInfo.applicationInfo, r.compatInfo);
//调用ActivityThread的handleLaunchActivity方法。
handleLaunchActivity(r, null, "LAUNCH_ACTIVITY");
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
} break;
｝
......
｝
4. handleLaunchActivity方法和performLaunchActivity方法
handleLaunchActivity又调用了performLaunchActivity方法去创建，并启动Activity。
private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {
......
// Initialize before creating the activity
WindowManagerGlobal.initialize();
Activity a = performLaunchActivity(r, customIntent);
if (a != null) {
r.createdConfig = new Configuration(mConfiguration);
reportSizeConfigurations(r);
Bundle oldState = r.state;
//这里调用Activity的onResume方法
handleResumeActivity(r.token, false, r.isForward,
!r.activity.mFinished && !r.startsNotResumed, r.lastProcessedSeq, reason);
......
} else {
//Activity为null，则代表启动出现问题，需要关闭
try {
ActivityManagerNative.getDefault()
.finishActivity(r.token, Activity.RESULT_CANCELED, null,
Activity.DONT_FINISH_TASK_WITH_ACTIVITY);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
}
}
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
// System.out.println("##### [" + System.currentTimeMillis() + "] ActivityThread.performLaunchActivity(" + r + ")");
ActivityInfo aInfo = r.activityInfo;
//对各种信息的非空判断以及为空的时候赋值
......
Activity activity = null;
try {
java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
//通过Instrumentation创建新的Activity
activity = mInstrumentation.newActivity(
cl, component.getClassName(), r.intent);
StrictMode.incrementExpectedActivityCount(activity.getClass());
r.intent.setExtrasClassLoader(cl);
r.intent.prepareToEnterProcess();
if (r.state != null) {
r.state.setClassLoader(cl);
}
} catch (Exception e) {
......
}
try {
//创建Application
Application app = r.packageInfo.makeApplication(false, mInstrumentation);
......
if (activity != null) {
//创建Context
Context appContext = createBaseContextForActivity(r, activity);
CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
Configuration config = new Configuration(mCompatConfiguration);
if (r.overrideConfig != null) {
config.updateFrom(r.overrideConfig);
}
//这个Window是我们显示的窗体
Window window = null;
if (r.mPendingRemoveWindow != null && r.mPreserveWindow) {
window = r.mPendingRemoveWindow;
r.mPendingRemoveWindow = null;
r.mPendingRemoveWindowManager = null;
}
//调用attach方法
activity.attach(appContext, this, getInstrumentation(), r.token,
r.ident, app, r.intent, r.activityInfo, title, r.parent,
r.embeddedID, r.lastNonConfigurationInstances, config,
r.referrer, r.voiceInteractor, window);
if (customIntent != null) {
activity.mIntent = customIntent;
}
r.lastNonConfigurationInstances = null;
activity.mStartedActivity = false;
int theme = r.activityInfo.getThemeResource();
if (theme != 0) {
activity.setTheme(theme);
}
activity.mCalled = false;
//判断是不是持久化的，可以理解为新的现场保存，查了下说是5.0及以上有的一种更加坚固的保存数据方式
//true会调用onCreate(@Nullable Bundle savedInstanceState,@Nullable PersistableBundle persistentState)
//false会调用onCreate(@Nullable Bundle savedInstanceState)
if (r.isPersistable()) {
mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
} else {
mInstrumentation.callActivityOnCreate(activity, r.state);
}
if (!activity.mCalled) {
throw new SuperNotCalledException(
"Activity " + r.intent.getComponent().toShortString() +
" did not call through to super.onCreate()");
}
r.activity = activity;
r.stopped = true;
//这里会调用onStart方法
if (!r.activity.mFinished) {
activity.performStart();
r.stopped = false;
}
//调用onRestoreInstanceState方法，当然这个是在re-initialized状态下，即重新初始化
if (!r.activity.mFinished) {
if (r.isPersistable()) {
if (r.state != null || r.persistentState != null) {
mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state,
r.persistentState);
}
} else if (r.state != null) {
mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);
}
}
//onPostCreate这个会在程序完全运行起来调用，onStart以后。好像很少用
if (!r.activity.mFinished) {
activity.mCalled = false;
if (r.isPersistable()) {
mInstrumentation.callActivityOnPostCreate(activity, r.state,
r.persistentState);
} else {
mInstrumentation.callActivityOnPostCreate(activity, r.state);
}
if (!activity.mCalled) {
throw new SuperNotCalledException(
"Activity " + r.intent.getComponent().toShortString() +
" did not call through to super.onPostCreate()");
}
}
}
r.paused = true;
mActivities.put(r.token, r);
} catch (SuperNotCalledException e) {
throw e;
} catch (Exception e) {
......
}
return activity;
}
Instrumentation.java
public Activity newActivity(ClassLoader cl, String className,
Intent intent)
throws InstantiationException, IllegalAccessException,
ClassNotFoundException {
//通过反射创建Activity
return (Activity)cl.loadClass(className).newInstance();
}
从上面的分析来看，我们显示使用Instrumentation.newActivity方法，通过反射创建一个Activity对象，接着会调用attach这个隐藏方法。之后根据是否是异常状态恢复，去掉用onCreate方法，接着调用onStart方法，如果是在重新初始化的时候，则会调用callActivityOnRestoreInstanceState方法，最后在程序完全运行起来调调用Activity的callActivityOnPostCreate（这个很少用到啊）。
5. 还是先说下 onResume
在上面的代码中，我们在执行完performLaunchActivity方法会执行handleResumeActivity方法。在这里，我们是执行了Activity的onResume方法。
final void handleResumeActivity(IBinder token,
boolean clearHide, boolean isForward, boolean reallyResume, int seq, String reason) {
ActivityClientRecord r = mActivities.get(token);
......
//执行onResume方法
r = performResumeActivity(token, clearHide, reason);
//onResume是activity与用户能进行交互时被执行，用户可以获得activity的焦点，能够与用户交互
if (r != null) {
final Activity a = r.activity;
final int forwardBit = isForward ?
WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION : 0;
boolean willBeVisible = !a.mStartedActivity;
......
//通过ViewManager或者说WindowManager将要显示的Activity显示出来，这里以后应该会分析，不急不急
if (r.window == null && !a.mFinished && willBeVisible) {
r.window = r.activity.getWindow();
View decor = r.window.getDecorView();
decor.setVisibility(View.INVISIBLE);
ViewManager wm = a.getWindowManager();
WindowManager.LayoutParams l = r.window.getAttributes();
a.mDecor = decor;
l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION;
l.softInputMode |= forwardBit;
if (r.mPreserveWindow) {
a.mWindowAdded = true;
r.mPreserveWindow = false;
ViewRootImpl impl = decor.getViewRootImpl();
if (impl != null) {
impl.notifyChildRebuilt();
}
}
if (a.mVisibleFromClient && !a.mWindowAdded) {
a.mWindowAdded = true;
wm.addView(decor, l);
}
} else if (!willBeVisible) {
if (localLOGV) Slog.v(
TAG, "Launch " + r + " mStartedActivity set");
r.hideForNow = true;
}
......
if (!r.onlyLocalRequest) {
r.nextIdle = mNewActivities;
mNewActivities = r;
Looper.myQueue().addIdleHandler(new Idler());
}
r.onlyLocalRequest = false;
// Tell the activity manager we have resumed.
if (reallyResume) {
try {
//通过AMS设置状态
ActivityManagerNative.getDefault().activityResumed(token);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
}
} else {
//和启动一样，如果有问题则结束掉
try {
ActivityManagerNative.getDefault()
.finishActivity(token, Activity.RESULT_CANCELED, null,
Activity.DONT_FINISH_TASK_WITH_ACTIVITY);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
}
}
6. 总结
咦？好像有点不对，如果是启动新的Activity时，会调用上一个页面的onStop方法啊？不对啊，看看怎么编下去吧。
7. 迟到的onStop
其实这个onStop调用时机我在上面的代码也展示出来了，只不过没有标明。就在这段代码中：
Looper.myQueue().addIdleHandler(new Idler());
private class Idler implements MessageQueue.IdleHandler {
@Override
public final boolean queueIdle() {
ActivityClientRecord a = mNewActivities;
boolean stopProfiling = false;
if (mBoundApplication != null && mProfiler.profileFd != null
&& mProfiler.autoStopProfiler) {
stopProfiling = true;
}
if (a != null) {
mNewActivities = null;
IActivityManager am = ActivityManagerNative.getDefault();
ActivityClientRecord prev;
do {
if (a.activity != null && !a.activity.mFinished) {
try {
//通过AMS调用activityIdle方法，最终会执行onStop方法
am.activityIdle(a.token, a.createdConfig, stopProfiling);
a.createdConfig = null;
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
}
prev = a;
a = a.nextIdle;
prev.nextIdle = null;
} while (a != null);
}
......
return false;
}
}
AMS:
@Override
public final void activityIdle(IBinder token, Configuration config, boolean stopProfiling) {
final long origId = Binder.clearCallingIdentity();
synchronized (this) {
ActivityStack stack = ActivityRecord.getStackLocked(token);
//调用StackSupervisor.activityIdleInternalLocked方法
if (stack != null) {
ActivityRecord r =
mStackSupervisor.activityIdleInternalLocked(token, false, config);
if (stopProfiling) {
if ((mProfileProc == r.app) && (mProfileFd != null)) {
try {
mProfileFd.close();
} catch (IOException e) {
}
clearProfilerLocked();
}
}
}
}
Binder.restoreCallingIdentity(origId);
}
ActivityStackSupervisor.java
final ActivityRecord activityIdleInternalLocked(final IBinder token, boolean fromTimeout,
Configuration config) {
......
for (int i = 0; i < NS; i++) {
r = stops.get(i);
final ActivityStack stack = r.task.stack;
if (stack != null) {
if (r.finishing) {
stack.finishCurrentActivityLocked(r, ActivityStack.FINISH_IMMEDIATELY, false);
} else {
//这里去真正stop Activity
stack.stopActivityLocked(r);
}
}
}
......
return r;
}
ActivityStack.java
final void stopActivityLocked(ActivityRecord r) {
if (r.app != null && r.app.thread != null) {
adjustFocusedActivityLocked(r, "stopActivity");
r.resumeKeyDispatchingLocked();
try {
......
//调用ApplicationThread的scheduleStopActivity方法，真正stop activity
r.app.thread.scheduleStopActivity(r.appToken, r.visible, r.configChangeFlags);
......
} catch (Exception e) {
}
}
}
上面一大部分就是关于onStop的大体过程，先是将Activity resume后将Idler（这个意思懒汉，无所事事的人）放到消息队列中，当消息进行执行是，会执行其中的方法，并通过AMS调用activityIdle方法，AMS又调用ActivityStackSupervisor的activityIdleInternalLocked方法，而activityIdleInternalLocked方法又会调用ActivityStack的stopActivityLocked方法，又跑到ApplicationThread中的scheduleStopActivity方法去真正stop activity。下面简单看下这个方法执行过程。
8. onStop真正执行过程
这里就简单看下，无非还是通过Handler发送消息，在消息执行是调用ActivityThread的方法去执行stop。下面看下源码：
public final void scheduleStopActivity(IBinder token, boolean showWindow,
int configChanges) {
int seq = getLifecycleSeq();
if (DEBUG_ORDER) Slog.d(TAG, "stopActivity " + ActivityThread.this
+ " operation received seq: " + seq);
sendMessage(
showWindow ? H.STOP_ACTIVITY_SHOW : H.STOP_ACTIVITY_HIDE,
token, 0, configChanges, seq);
}
private void handleStopActivity(IBinder token, boolean show, int configChanges, int seq) {
......
//真正执行stop
performStopActivityInner(r, info, show, true, "handleStopActivity");
......
}
private void performStopActivityInner(ActivityClientRecord r,
StopInfo info, boolean keepShown, boolean saveState, String reason) {
......
//如果有必要先执行pause方法
performPauseActivityIfNeeded(r, reason);
......
// Next have the activity save its current state and managed dialogs...
if (!r.activity.mFinished && saveState) {
if (r.state == null) {
callCallActivityOnSaveInstanceState(r);
}
}
if (!keepShown) {
try {
// 执行onStop方法
r.activity.performStop(false /*preserveWindow*/);
} catch (Exception e) {
if (!mInstrumentation.onException(r.activity, e)) {
throw new RuntimeException(
"Unable to stop activity "
+ r.intent.getComponent().toShortString()
+ ": " + e.toString(), e);
}
}
r.stopped = true;
}
}
}
整个流程大概就这样，Activity的生命周期基本执行完成了。
9. 我还有话说
关于Instrumentation的各种方法，举个例子来说，例如
Instrumentation.callActivityOnCreate(activity, r.state)方法，这里会执行
public void callActivityOnCreate(Activity activity, Bundle icicle) {
//创建前
prePerformCreate(activity);
//执行onCreate方法
activity.performCreate(icicle);
//创建完成
postPerformCreate(activity);
}
Activity.java
final void performCreate(Bundle icicle) {
restoreHasCurrentPermissionRequest(icicle);
//真正执行onCreate
onCreate(icicle);
mActivityTransitionState.readState(icicle);
performCreateCommon();
}
这个Instrumentation可以说是个小秘书，我可以替大老板执行任务，并且在执行任务前后悄悄的做点事情，这感觉就是代理模式啊！！
写在后面的话
有完没完了啊。好吧，真的结束了。后面还是会有分析，整理整理思路，赶明再出发。
网友评论