Activity启动源码分析

背景

今天一如既往的“啃食”源码，学习Activity的启动流程，startActivity( )这个方法我们经常使用到，但是系统是如何新建Activity并启动的呢？今天带着这个问题，一起来看源码吧！（本文源码API 25）

开个小差，看完可能会身心不适应，最好准备一杯咖啡~为了便于阅读重点代码，其中会省略部分源码

源码

1、直接进入Activity.java源码

@Override
    public void startActivity(Intent intent) {
        this.startActivity(intent, null);
    }

@Override
    public void startActivity(Intent intent, @Nullable Bundle options) {
        if (options != null) {
            startActivityForResult(intent, -1, options);
        } else {
            startActivityForResult(intent, -1);
        }
    }

2、此处无须解释，直接进入startActivityForResult（），位于Activity.java；

public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
            @Nullable Bundle options) {
        //mParent一般为null，该字段用于ActivityGroup
        if (mParent == null) {
            //......
            //启动工作转到了execStartActivity（）这个方法
            Instrumentation.ActivityResult ar =
                mInstrumentation.execStartActivity(
                    this, mMainThread.getApplicationThread(), mToken, this,
                    intent, requestCode, options);
            //......
        } else {
            //......
        }
    }

3、进入execStartActivity（），位于Instrumentation.java；

 public ActivityResult execStartActivity(
            Context who, IBinder contextThread, IBinder token, Activity target,
            Intent intent, int requestCode, Bundle options) {
        IApplicationThread whoThread = (IApplicationThread) contextThread;
        //......
        //遍历Activity
        if (mActivityMonitors != null) {
            synchronized (mSync) {
                final int N = mActivityMonitors.size();
                for (int i=0; i<N; i++) {
                    final ActivityMonitor am = mActivityMonitors.get(i);
                    if (am.match(who, null, intent)) {
                        am.mHits++;
                        if (am.isBlocking()) {
                            //如果当前Activity不可用，直接返回
                            return requestCode >= 0 ? am.getResult() : null;
                        }
                        break;
                    }
                }
            }
        }
        try {
            //......
            //调用了ActivityManagerProxy这个代理类的startActivity（）方法
            int result = ActivityManagerNative.getDefault()
                .startActivity(whoThread, who.getBasePackageName(), intent,
                        intent.resolveTypeIfNeeded(who.getContentResolver()),
                        token, target != null ? target.mEmbeddedID : null,
                        requestCode, 0, null, options);
            //......
        } catch (RemoteException e) {
            throw new RuntimeException("Failure from system", e);
        }
        return null;
    }

4、进入startActivity（），ActivityManagerProxy是ActivityManagerNative一个内部代理类，位于ActivityManagerNative.java；

public int startActivity(IApplicationThread caller, String callingPackage, Intent intent,
            String resolvedType, IBinder resultTo, String resultWho, int requestCode,
            int startFlags, ProfilerInfo profilerInfo, Bundle options) throws RemoteException {
        //......
        //transact（）是IBinder接口的一个方法，mRemote是IBinder对象，最终会通过IBinder机制调用
        //ActivityManagerService.claas的内部类的AppTaskImpl的startActivity（）方法
        mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);
        //......
        return result;
    }

5、进入startActivity（），位于ActivityManagerService.java的内部类AppTaskImpl.class；

        @Override
        public int startActivity(IBinder whoThread, String callingPackage,
                Intent intent, String resolvedType, Bundle bOptions) {
            //......
            //然后调用ActivityStarter的startActivityMayWait()方法
            return mActivityStarter.startActivityMayWait(appThread, -1, callingPackage, intent,
                    resolvedType, null, null, null, null, 0, 0, null, null,
                    null, bOptions, false, callingUser, null, tr);
        }

6、进入startActivityMayWait（），位于ActivityStarter.java；

final int startActivityMayWait(IApplicationThread caller, int callingUid,
            String callingPackage, Intent intent, String resolvedType,
            IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
            IBinder resultTo, String resultWho, int requestCode, int startFlags,
            ProfilerInfo profilerInfo, IActivityManager.WaitResult outResult, Configuration config,
            Bundle bOptions, boolean ignoreTargetSecurity, int userId,
            IActivityContainer iContainer, TaskRecord inTask) {
            //......
            //接着调用了startActivityLocked（）方法
            final ActivityRecord[] outRecord = new ActivityRecord[1];
            int res = startActivityLocked(caller, intent, ephemeralIntent, resolvedType,
                    aInfo, rInfo, voiceSession, voiceInteractor,
                    resultTo, resultWho, requestCode, callingPid,
                    callingUid, callingPackage, realCallingPid, realCallingUid, startFlags,
                    options, ignoreTargetSecurity, componentSpecified, outRecord, container,
                    inTask);
            //......
    }

7、进入startActivityLocked（），位于ActivityStarter.java；

final int startActivityLocked(IApplicationThread caller, Intent intent, Intent ephemeralIntent,
            String resolvedType, ActivityInfo aInfo, ResolveInfo rInfo,
            IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
            IBinder resultTo, String resultWho, int requestCode, int callingPid, int callingUid,
            String callingPackage, int realCallingPid, int realCallingUid, int startFlags,
            ActivityOptions options, boolean ignoreTargetSecurity, boolean componentSpecified,
            ActivityRecord[] outActivity, ActivityStackSupervisor.ActivityContainer container,
            TaskRecord inTask) {
        int err = ActivityManager.START_SUCCESS;
        //......
        try {
            mService.mWindowManager.deferSurfaceLayout();
            //......
            //接着调用startActivityUnchecked（)方法
            err = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor, 
            startFlags, true, options, inTask);
        } finally {
            mService.mWindowManager.continueSurfaceLayout();
        }
        //......
        return err;
    }

8、进入startActivityUnchecked（），位于ActivityStarter.java；

private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
            IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
            int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask) {

        //......
        if (mDoResume) {
            if (!mLaunchTaskBehind) {
                //......
                mService.setFocusedActivityLocked(mStartActivity, "startedActivity");
            }
            final ActivityRecord topTaskActivity = mStartActivity.task.topRunningActivityLocked();
            if (!mTargetStack.isFocusable()
                    || (topTaskActivity != null && topTaskActivity.mTaskOverlay
                    && mStartActivity != topTaskActivity)) {
                //......
            } else {
                //接着调用resumeFocusedStackTopActivityLocked()方法
                mSupervisor.resumeFocusedStackTopActivityLocked(mTargetStack,   
                mStartActivity, mOptions);
            }
        } else {
            mTargetStack.addRecentActivityLocked(mStartActivity);
        }
        //......
        return START_SUCCESS;
    }

9、进入resumeFocusedStackTopActivityLocked（），位于ActivityStackSupervisor.java；

 boolean resumeFocusedStackTopActivityLocked(
            ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
        if (targetStack != null && isFocusedStack(targetStack)) {
            //接着调用resumeTopActivityUncheckedLocked（）方法
            return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
        }
        final ActivityRecord r = mFocusedStack.topRunningActivityLocked();
        if (r == null || r.state != RESUMED) {
            mFocusedStack.resumeTopActivityUncheckedLocked(null, null);
        }
        return false;
    }

10、进入resumeTopActivityUncheckedLocked（），位于ActivityStack.java；

boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
        if (mStackSupervisor.inResumeTopActivity) {
            // Don't even start recursing.
            return false;
        }

        boolean result = false;
        try {
            // Protect against recursion.
            mStackSupervisor.inResumeTopActivity = true;
            if (mService.mLockScreenShown == ActivityManagerService.LOCK_SCREEN_LEAVING) {
                mService.mLockScreenShown = ActivityManagerService.LOCK_SCREEN_HIDDEN;
                mService.updateSleepIfNeededLocked();
            }
            //接着调用resumeTopActivityInnerLocked（）方法
            result = resumeTopActivityInnerLocked(prev, options);
        } finally {
            mStackSupervisor.inResumeTopActivity = false;
        }
        return result;
    }

11、进入resumeTopActivityInnerLocked（），位于ActivityStack.java；

private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
    //......
     if (mResumedActivity != null) {
            if (DEBUG_STATES) Slog.d(TAG_STATES,"resumeTopActivityLocked: Pausing " + mResumedActivity);
            //接着调用startPausingLocked（）方法
            pausing |= startPausingLocked(userLeaving, false, next, dontWaitForPause);
        }
    //......
    return true;
}

12、进入startPausingLocked（），位于ActivityStack.java；

final boolean startPausingLocked(boolean userLeaving, boolean uiSleeping,
            ActivityRecord resuming, boolean dontWait) {
        //......
        if (prev.app != null && prev.app.thread != null) {
            if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Enqueueing pending pause: " + prev);
            try {
                //......
                //重点来啦，prev.app.thread是ActivityThread的一个实例
                prev.app.thread.schedulePauseActivity(prev.appToken, prev.finishing,
                        userLeaving, prev.configChangeFlags, dontWait);
            } catch (Exception e) {
               //......
            }
        } else {
            //......
        }
        //......
    }

13、进入schedulePauseActivity（），位于ActivityThread.java内部类ApplicationThread.class的方法；

public final void schedulePauseActivity(IBinder token, boolean finished,
                boolean userLeaving, int configChanges, boolean dontReport) {
            int seq = getLifecycleSeq();
            if (DEBUG_ORDER) Slog.d(TAG, "pauseActivity " + ActivityThread.this
                    + " operation received seq: " + seq);
            sendMessage(
                    finished ? H.PAUSE_ACTIVITY_FINISHING : H.PAUSE_ACTIVITY,
                    token,
                    (userLeaving ? USER_LEAVING : 0) | (dontReport ? DONT_REPORT : 0),
                    configChanges,
                    seq);
        }

private class H extends Handler {
    public void handleMessage(Message msg) {
        case PAUSE_ACTIVITY_FINISHING: {
                   //......
                   //接着调用handlePauseActivity（）方法
                    handlePauseActivity((IBinder) args.arg1, true, (args.argi1 & USER_LEAVING) != 0,
                            args.argi2, (args.argi1 & DONT_REPORT) != 0, args.argi3);
                    //......
                } break;
    }
}

13、进入handlePauseActivity（），位于ActivityThread.java；

private void handlePauseActivity(IBinder token, boolean finished,
            boolean userLeaving, int configChanges, boolean dontReport, int seq) {
        ActivityClientRecord r = mActivities.get(token);
        //......
        if (r != null) {
            //Slog.v(TAG, "userLeaving=" + userLeaving + " handling pause of " + r);
            performPauseActivity(token, finished, r.isPreHoneycomb(), "handlePauseActivity");
            //......
        }
    }

14、进入performPauseActivity（），位于ActivityThread.java；

    final Bundle performPauseActivity(IBinder token, boolean finished,
            boolean saveState, String reason) {
        ActivityClientRecord r = mActivities.get(token);
        return r != null ? performPauseActivity(r, finished, saveState, reason) : null;
    }

    final Bundle performPauseActivity(ActivityClientRecord r, boolean finished,
            boolean saveState, String reason) {
        //......
        performPauseActivityIfNeeded(r, reason);
       //......
        return !r.activity.mFinished && saveState ? r.state : null;
    }

14、进入performPauseActivityIfNeeded（），位于ActivityThread.java；

private void performPauseActivityIfNeeded(ActivityClientRecord r, String reason) {
       //......
        try {
            //......
            mInstrumentation.callActivityOnPause(r.activity);
            //......
        } catch (SuperNotCalledException e) {
            throw e;
        } catch (Exception e) {
            //......
        }
        r.paused = true;
    }

15、进入callActivityOnPause（），位于Instrumentation.java；

    /**
     * Perform calling of an activity's {@link Activity#onPause} method.  The
     * default implementation simply calls through to that method.
     * 
     * @param activity The activity being paused.
     */
    public void callActivityOnPause(Activity activity) {
        activity.performPause();
    }

16、回到Activity的performPause( )方法，位于Activity.java；

final void performPause() {
        mDoReportFullyDrawn = false;
        mFragments.dispatchPause();
        mCalled = false;
        //最终，调用了Activity的onPause()方法。
        onPause();
        mResumed = false;
        if (!mCalled && getApplicationInfo().targetSdkVersion
                >= android.os.Build.VERSION_CODES.GINGERBREAD) {
            throw new SuperNotCalledException(
                    "Activity " + mComponent.toShortString() +
                    " did not call through to super.onPause()");
        }
        mResumed = false;
    }

【PS】至此，我们看完了启动Activity的第一步，结束之前的Activity，方能启动新的Activity

17、重新回到第11步，resumeTopActivityInnerLocked（），位于ActivityStack.java；

private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
    //......
     if (mResumedActivity != null) {
            if (DEBUG_STATES) Slog.d(TAG_STATES,"resumeTopActivityLocked: Pausing " + mResumedActivity);
            //接着调用startPausingLocked（）方法，这里刚才分析过了，接下去是一系列停止之前的Activity的操作。
            pausing |= startPausingLocked(userLeaving, false, next, dontWaitForPause);
        }
    //......
    //通知开启新的Activity的开始
    mStackSupervisor.startSpecificActivityLocked(next, true, true);
    //......
    return true;
}

18、进入startSpecificActivityLocked（），位于ActivityStackSupervisor.java的内部类startSpecificActivityLocked.class里面

void startSpecificActivityLocked(ActivityRecord r,
            boolean andResume, boolean checkConfig) {
       //......
        if (app != null && app.thread != null) {
            try {
                //......
                //接着调用了realStartActivityLocked（）方法
                realStartActivityLocked(r, app, andResume, checkConfig);
                return;
            } catch (RemoteException e) {
                //......
            }

            //......
        }
        //......
    }

19、进入realStartActivityLocked（），位于ActivityStackSupervisor

 final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
            boolean andResume, boolean checkConfig) throws RemoteException {
             //......
             //接着掉用了ActivityThread的scheduleLaunchActivity（）分发消息，开启新的Activity
    app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,
                    System.identityHashCode(r), r.info, new Configuration(mService.mConfiguration),
                    new Configuration(task.mOverrideConfig), r.compat, r.launchedFromPackage,
                    task.voiceInteractor, app.repProcState, r.icicle, r.persistentState, results,
                    newIntents, !andResume, mService.isNextTransitionForward(), profilerInfo);
           //......
}

20、进入scheduleLaunchActivity（），位于ActivityThread.java

        @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) {
            //......
            ActivityClientRecord r = new ActivityClientRecord();
            //......
            //发送开启新的Activity的LAUNCH_ACTIVITY消息
            sendMessage(H.LAUNCH_ACTIVITY, r);
        }

21、进入scheduleLaunchActivity（），位于ActivityThread.java的内部类H.class，看看H的消息出来部分

 public void handleMessage(Message msg) {
     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);
                    handleLaunchActivity(r, null, "LAUNCH_ACTIVITY");
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                }
 }

22、进入handleLaunchActivity（），位于ActivityThread.java

private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {
        //......
        //可见，跟前面暂停Activity一样，分发处理消息
        Activity a = performLaunchActivity(r, customIntent);
        //......
    }

23、进入performLaunchActivity（），位于ActivityThread.java

private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {

        // 取出Activity的相关信息
        ActivityInfo aInfo = r.activityInfo;
        Activity activity = null;
        try {
            // 可见，Activity 是通过反射创建的一个实例对象
            java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
            activity = mInstrumentation.newActivity(
                    cl, component.getClassName(), r.intent);
            //......
        } catch (Exception e) {
            //......
        }

        try {
            Application app = r.packageInfo.makeApplication(false, mInstrumentation);
            //......
            if (activity != null) {
                //......
                //调用了activity的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);

                //......
                // 设置主题
                int theme = r.activityInfo.getThemeResource();
                if (theme != 0) {
                    activity.setTheme(theme);
                }

                //......
                // 在Activity创建后，调用了callActivityOnCreate（）方法
                if (r.isPersistable()) {
                    mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
                } else {
                    mInstrumentation.callActivityOnCreate(activity, r.state);
                }

        } catch (SuperNotCalledException e) {
            throw e;
        } catch (Exception e) {
            //......
        }
        return activity;
    }

24、进入callActivityOnCreate（），位于Instrumentation.java

    /**
     * Perform calling of an activity's {@link Activity#onCreate}
     * method.  The default implementation simply calls through to that method.
     *  @param activity The activity being created.
     * @param icicle The previously frozen state (or null) to pass through to
     * @param persistentState The previously persisted state (or null)
     */
    public void callActivityOnCreate(Activity activity, Bundle icicle,
            PersistableBundle persistentState) {
        prePerformCreate(activity);
        //调用performCreate（）调用OnCreate（）声明周期的方法
        activity.performCreate(icicle, persistentState);
        postPerformCreate(activity);
    }

24、进入performCreate（），位于Activity .java

final void performCreate(Bundle icicle, PersistableBundle persistentState) {
        restoreHasCurrentPermissionRequest(icicle);
        //看到这里，Activity终于启动了
        onCreate(icicle, persistentState);
        mActivityTransitionState.readState(icicle);
        performCreateCommon();
    }

下面的内容不扯了，以此类推的，看到onCreate（）这里应该很激动了，不说了，两只眼睛已经看不见东西了，o(╯□╰)o

* 后续再完善文章吧，眼睛已瞎，无奈不能继续看了*