写在前面的话

最近高产似母猪，每天都会写点关于这个系列的总结。周一了，又开始忙碌的一天。项目赶赶赶，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可以说是个小秘书，我可以替大老板执行任务，并且在执行任务前后悄悄的做点事情，这感觉就是代理模式啊！！

写在后面的话

有完没完了啊。好吧，真的结束了。后面还是会有分析，整理整理思路，赶明再出发。