Activity详情——Android8.0中Activity的启动流程

每个Android开发者都知道，可以用startActivity()或者startActivityForResult()来启动一个Activity。那么startActivity()这个方法到底是通过什么样的调用流程来启动Activity的呢？

下面我们从源码的角度来看一下调用流程：

读源码前的准备

android的服务端和客户端
- 客户端：和各个App紧密相关的部分，比如Activity、ActivityThread、ApplicationThread，也就是常说的系统应用层。
- 服务端：同意管理各个应用的系统类。比如ActivityManagerService、PackageManagerService等，也就是我们常说的FrameWork层。这些服务都是被所有的App公用的，当某个App想实现某个操作的时候，要告诉这些系统服务。
- 客户端与服务端通讯：客户端和服务端分属于不同的进程，他们之间的通讯是通过bundle来进行通讯的。比如启动一个Activity时，客户端会通过调用本地的一个代理方法，来把启动Activity的信息传递给服务端，服务端收到此信息后，经过一系列方法后，也会调用服务端的代理方法，告诉客户端可以显示了。
ActivityThread、Instrumentation、ActivityManagerService介绍
- ActivityThread:可以把它认为是我们常说的主线程。主要负责与AMS交互，并且管理Activity、Service等系统组件。一个App启动时候会创建一个ActivityThread，每个App也只有一个ActivityThread。
- ActivityManagerService:一般被简称为AMS，是贯穿Android系统组件的核心服务，负责了系统中四大组件的启动、切换、调度以及应用进程管理和调度工作。

大体的流程设计

由于整个流程的方法调用比较多，所以这里画了一个调用流程。图比较大，大家可以点击去看大图：

Activity启动流程图.png

详细调用步骤

这里主要从源码的角度出发，带领大家过一遍整体的方法调用流程。

客户端方法调用

Activity的startActivity()方法开始：

@Override
public void startActivity(Intent intent, @Nullable Bundle options) {
    if (options != null) {
        startActivityForResult(intent, -1, options);
    } else {
        
        // 默认会调用startActivityForResult(intent,-1)的方法
        startActivityForResult(intent, -1);
    }
}

可以看出，不论怎样都会调用startActivityForResult()方法，所以这里可以看出，如果这样startActivityForResult(intent,RESULT_OK)启动一个Activity的话，是收不到任何回传的值的。

接下来进入startActivityForResult方法

public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
                                       @Nullable Bundle options) {
        if (mParent == null) {
            //...
            options = transferSpringboardActivityOptions(options);
            //这里调用instrumentation的execStartActivity()方法
            Instrumentation.ActivityResult ar =
                    mInstrumentation.execStartActivity(
                            this, mMainThread.getApplicationThread(), mToken, this,
                            intent, requestCode, options);
        } else {
            //...
        }
}

startActivityForResult会调用Instrumentation中的execStartActivity()方法。

Instrumentation这个类就是完成对Application和Activity初始化和生命周期的工具类。每个Activity都持有Instrumentation对象的一个引用，但是整个进程只会存在一个Instrumentation对象，着个Instrumentation对象存放在ActivityThread中。

继续进入execStartActivity()方法：

public ActivityResult execStartActivity(
        Context who, IBinder contextThread, IBinder token, Activity target,
        Intent intent, int requestCode, Bundle options) {
    //...
    try {
        intent.migrateExtraStreamToClipData();
        intent.prepareToLeaveProcess(who);
        //主要是这段代码，可以看出这里会获取Service，然后调用startActivity方法
        int result = ActivityManager.getService()
            .startActivity(whoThread, who.getBasePackageName(), intent,
                    intent.resolveTypeIfNeeded(who.getContentResolver()),
                    token, target != null ? target.mEmbeddedID : null,
                    requestCode, 0, null, options);
        checkStartActivityResult(result, intent);
    } catch (RemoteException e) {
        throw new RuntimeException("Failure from system", e);
    }
    return null;
}

就如上面注释中说明的那样execStartActivity()会通过ActivityManager.getService()获取一个类，来调用startActivity()方法。

那么这个类是什么呢？我们继续往下看：

调用客户端代理方法和服务端通讯：

//这里会调用下面成员变量的方法
public static IActivityManager getService() {
    return IActivityManagerSingleton.get();
}

private static final Singleton<IActivityManager> IActivityManagerSingleton =
        new Singleton<IActivityManager>() {
            @Override
            protected IActivityManager create() {
                final IBinder b = ServiceManager.getService(Context.ACTIVITY_SERVICE);
              //可以看出，这里创建了一个IActivityManager.Stub的实现类，也就是客户端代理类
                final IActivityManager am = IActivityManager.Stub.asInterface(b);
                return am;
            }
        };

接下来我们可以看看Singleton的get()方法

public abstract class Singleton<T> {  
    private T mInstance;  
  
    protected abstract T create();  
      //get方法会返回对应的泛型，也就是上段代码中onCreate创建的IActivityManager的实现类
    public final T get() {  
        synchronized (this) {  
            if (mInstance == null) {  
                mInstance = create();  
            }  
            return mInstance;  
        }  
    }  
}

从Binder机制来说，客户端有个基于IActivityManager.Stub代理类，那么这个代理类会调用服务端的，同样实现了这个接口的类的对应的方法。然后去服务端查看，发现ActivityManagerService果然实现了IActivityManager.Stub类。

所以，这个ActivityManager.getService().startActivity()的调用，会通过Binder机制，调用到ActivityManagerService的startActivity()方法。也就完成了客户端与服务端的交流。

服务端方法调用

再从startActivity()开始

上一段客户端的流程结束后，我们的启动流程走到了ActivityManagerService.startActivity()方法，接下来看一下这个方法干了些什么：

@Override
public final int startActivity(IApplicationThread caller, String callingPackage,
        Intent intent, String resolvedType, IBinder resultTo, String resultWho, 
        int requestCode,int startFlags, ProfilerInfo profilerInfo, Bundle bOptions) {
    //...
    //这里调用当前类的startActivityAsUser方法
    return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
            resultWho, requestCode, startFlags, profilerInfo, bOptions,
            UserHandle.getCallingUserId());
}

@Override
public final int startActivityAsUser(IApplicationThread caller, String callingPackage,
    //...
    //这里调用ActivityStarter的startActivityMayWait方法
    return mActivityStarter.startActivityMayWait(caller, -1, callingPackage, intent,
            resolvedType, null, null, resultTo, resultWho, requestCode, startFlags,
            profilerInfo, null, null, bOptions, false, userId, null, null,
            "startActivityAsUser");
}

跟着代码，我们到达了ActivityStarter类，这个类负责处理Activity的Intent和Flags的逻辑, 还有管理Stack和TaskRecord。

进入ActivityStarter.startActivityMayWait()方法：

    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, WaitResult outResult,
            Configuration globalConfig, Bundle bOptions, boolean ignoreTargetSecurity, int userId,
            IActivityContainer iContainer, TaskRecord inTask, String reason) {
        //...
        
        // 通过PKMS 查找匹配该Intent的ActivityInfo。
        ActivityInfo aInfo = mSupervisor.resolveActivity(intent, rInfo, startFlags, profilerInfo);

          //...
        //获取调用者的pid 和 uid
        synchronized (mService) {
          
            //...此处省略100行代码
            
            //启动Activity的核心函数startActivityLocked
            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, reason);

          //... 此处省略120行左右代码
            
            return res;
        }
    }

这里可以看到，startActivityMayWait会调用startActivityLocked方法来继续启动Activity。

继续查看startActivityLocked方法

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, String reason) {

    //...
    //在哪android8.0中,这里单独提取了一个startActivity方法,来处理各种逻辑,
    //且这个方法只会在这里调用
    mLastStartActivityResult = startActivity(caller, intent, ephemeralIntent, resolvedType,
            aInfo, rInfo, voiceSession, voiceInteractor, resultTo, resultWho, requestCode,
            callingPid, callingUid, callingPackage, realCallingPid, realCallingUid, startFlags,
            options, ignoreTargetSecurity, componentSpecified, mLastStartActivityRecord,
            container, inTask);
    //...
    return mLastStartActivityResult;
}

然后我们研究下这个提取出的startActivity()方法

private int startActivity(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) {
    //...省略了三百来行
    //下一步查看这个方法
    doPendingActivityLaunchesLocked(false);
    //这里调用的也是下面的startActivity方法
    return startActivity(r, sourceRecord, voiceSession, voiceInteractor, startFlags, true,
            options, inTask, outActivity);
}

//跟进到这里:
final void doPendingActivityLaunchesLocked(boolean doResume) {
    //...
    //再次调用另一个startActivity方法
    startActivity(pal.r, pal.sourceRecord, null, null, pal.startFlags, resume, null,
            null, null /*outRecords*/);
    //...
}

//继续跟进
private int startActivity(final ActivityRecord r, ActivityRecord sourceRecord,
                          IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
                          int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
                          ActivityRecord[] outActivity) {
    //...
    result = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor,
            startFlags, doResume, options, inTask, outActivity);
    //...

    return result;
}

经过一连串的方法调用后，我们来到了较为关键的startActivityUnchecked()方法

private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
                                   IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
                                   int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
                                   ActivityRecord[] outActivity) {
    //1. 初始化环境和lunchModeFlags
    setInitialState(r, options, inTask, doResume, startFlags, sourceRecord, voiceSession,
            voiceInteractor);
    computeLaunchingTaskFlags();
    computeSourceStack();
    mIntent.setFlags(mLaunchFlags);

    //2. 复用activity逻辑
    ActivityRecord reusedActivity = getReusableIntentActivity();

    //...

    //3.singleTop 或者singleInstance的处理
    if (dontStart) {
        ActivityStack.logStartActivity(AM_NEW_INTENT, top, top.getTask());
        // For paranoia, make sure we have correctly resumed the top activity.
        topStack.mLastPausedActivity = null;
        if (mDoResume) {
            //***********************************************
            mSupervisor.resumeFocusedStackTopActivityLocked();
        }
        ActivityOptions.abort(mOptions);
        if ((mStartFlags & START_FLAG_ONLY_IF_NEEDED) != 0) {
            // We don't need to start a new activity, and the client said not to do
            // anything if that is the case, so this is it!
            return START_RETURN_INTENT_TO_CALLER;
        }
        top.deliverNewIntentLocked(
                mCallingUid, mStartActivity.intent, mStartActivity.launchedFromPackage);

        // Don't use mStartActivity.task to show the toast. We're not starting a new activity
        // but reusing 'top'. Fields in mStartActivity may not be fully initialized.
        mSupervisor.handleNonResizableTaskIfNeeded(top.getTask(), preferredLaunchStackId,
                preferredLaunchDisplayId, topStack.mStackId);

        return START_DELIVERED_TO_TOP;
    }

    //...

    //4. 设置对应task并带到前台
    int result = START_SUCCESS;
    if (mStartActivity.resultTo == null && mInTask == null && !mAddingToTask
            && (mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) != 0) {
        newTask = true;
        result = setTaskFromReuseOrCreateNewTask(
                taskToAffiliate, preferredLaunchStackId, topStack);
    } else if (mSourceRecord != null) {
        result = setTaskFromSourceRecord();
    } else if (mInTask != null) {
        result = setTaskFromInTask();
    } else {
        // This not being started from an existing activity, and not part of a new task...
        // just put it in the top task, though these days this case should never happen.
        setTaskToCurrentTopOrCreateNewTask();
    }
    if (result != START_SUCCESS) {
        return result;
    }

    //...

    //5. 启动Activity
    mTargetStack.startActivityLocked(mStartActivity, topFocused, newTask, mKeepCurTransition,
            mOptions);

    //6. 使Activity可见
    if (mDoResume) {
        final ActivityRecord topTaskActivity =
                mStartActivity.getTask().topRunningActivityLocked();
        if (!mTargetStack.isFocusable()
                || (topTaskActivity != null && topTaskActivity.mTaskOverlay
                && mStartActivity != topTaskActivity)) {
            mTargetStack.ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
            mWindowManager.executeAppTransition();
        } else {
            if (mTargetStack.isFocusable() && !mSupervisor.isFocusedStack(mTargetStack)) {
                mTargetStack.moveToFront("startActivityUnchecked");
            }
            //***********************************************
            mSupervisor.resumeFocusedStackTopActivityLocked(mTargetStack, mStartActivity,
                    mOptions);
        }
    } else {
        mTargetStack.addRecentActivityLocked(mStartActivity);
    }

    //...

    return START_SUCCESS;
}

如注释中所示，这个方法主要负责让Activity显示出来。在启动Activity之后我们需要经过一些调用来使Activity可见，这时会调用上面代码中*下面的方法，也就是resumeFocusedStackTopActivityLocked()

查看ActivityStackSupervisor类中的resumeFocusedStackTopActivityLocked方法：

boolean resumeFocusedStackTopActivityLocked() {
    return resumeFocusedStackTopActivityLocked(null, null, null);
}

boolean resumeFocusedStackTopActivityLocked(
        ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
    if (targetStack != null && isFocusedStack(targetStack)) {
          //发现调用的ActivityStack中的方法
        return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
    }
    final ActivityRecord r = mFocusedStack.topRunningActivityLocked();
    if (r == null || r.state != RESUMED) {
        //同样调用的ActivityStack中的方法
        mFocusedStack.resumeTopActivityUncheckedLocked(null, null);
    } else if (r.state == RESUMED) {
        // Kick off any lingering app transitions form the MoveTaskToFront operation.
        mFocusedStack.executeAppTransition(targetOptions);
    }
    return false;
}

这个方法有调用了的ActivityStack中的方法resumeTopActivityUncheckedLocked，我们继续跟进：

boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
    //...
    boolean result = false;
    try {
        //...
        //继续跟进此方法
        result = resumeTopActivityInnerLocked(prev, options);
    } finally {
        mStackSupervisor.inResumeTopActivity = false;
    }

    //...

    return result;
}

//继续跟进
private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
    //...
    //此方法中代码巨多,我们暂时先关心这行:
    mStackSupervisor.startSpecificActivityLocked(next, true, true);
    //...
    return true;
}

上述代码有回调到了ActivityStackSupervisor类中，所以我们继续进入查看

void startSpecificActivityLocked(ActivityRecord r,
                                 boolean andResume, boolean checkConfig) {
    //...

    if (app != null && app.thread != null) {
        //...
        //看方法,我们好像终于找到真正的启动点了
        //跟进这个方法
        realStartActivityLocked(r, app, andResume, checkConfig);
        return;
        //...
    }
    //...
}

//继续跟进
final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
                                      boolean andResume, boolean checkConfig) throws RemoteException {

    //省略大约两百行代码
    //这里终于看上去像是回调客户端了,没错,他就是回调客户端的方法
    app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,
            System.identityHashCode(r), r.info,
            // TODO: Have this take the merged configuration instead of separate global and
            // override configs.
            mergedConfiguration.getGlobalConfiguration(),
            mergedConfiguration.getOverrideConfiguration(), r.compat,
            r.launchedFromPackage, task.voiceInteractor, app.repProcState, r.icicle,
            r.persistentState, results, newIntents, !andResume,
            mService.isNextTransitionForward(), profilerInfo);
    //...
    
    return true;
}

变量app是一个ProcessRecord对象，它的成员变量thread是IApplicationThread类型，因此app.thread是一个IApplicationThread的代理对象。

和之前客户端调用服务端类似，通过Binder机制，会使ApplicationThread$scheduleLaunchActivity方法被调用。

于是，基于Binder机制，又实现了一次进程间的通信，将启动Activity的操作交给了ActivityThread的内部类ApplicationThread类。

服务端回调后，客户端处理流程

现在我们再次回到了客户端，进入ApplicationThread.schedulelaunchActivity()

private class ApplicationThread extends IApplicationThread.Stub {
    //...省略其余方法
    @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) {
        //更新进程状态
        updateProcessState(procState, false);
        //客户端的各种信息
        ActivityClientRecord r = new ActivityClientRecord();

        //...省略个给r赋值的一系列方法

        //这里回调ActivityThread的sendMessage的方法
        sendMessage(H.LAUNCH_ACTIVITY, r);
    }
    //...省略其余方法
}

//继续跟进
private void sendMessage(int what, Object obj) {
    sendMessage(what, obj, 0, 0, false);
}

//继续跟进
private void sendMessage(int what, Object obj, int arg1, int arg2, boolean async) {

    Message msg = Message.obtain();
    //...省略msg赋值过程

    //调用ActivityThread的Handler开始启动消息队列
    mH.sendMessage(msg);
}

mH是ActivityThread的一个成员变量，mH的handleMessage()会处理上一步发出的消息，现在看看它是怎么处理消息的

private class H extends Handler {
    //...省略无关方法
    public void handleMessage(Message msg) {
        switch (msg.what) {
            case LAUNCH_ACTIVITY: {
                Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
                //取出消息中的ActivityClientRecord(客户端信息记录)
                final ActivityClientRecord r = (ActivityClientRecord) msg.obj;

                r.packageInfo = getPackageInfoNoCheck(
                        r.activityInfo.applicationInfo, r.compatInfo);
                //调用此方法继续启动Activity
                handleLaunchActivity(r, null, "LAUNCH_ACTIVITY");
                Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
            }
            break;
            //... 省略其余case语句
        }
        //...
    }
    //...省略无关方法
}

//继续跟进
private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {
    //...
    //根据参数r,初始化出一个Activity
    Activity a = performLaunchActivity(r, customIntent);

    if (a != null) {
        //...

        //如果Activity不为空,调用onResume()方法
        handleResumeActivity(r.token, false, r.isForward,
                !r.activity.mFinished && !r.startsNotResumed, r.lastProcessedSeq, reason);
        //...
    } else {
        // 如果Activity为空,也就是创建出错,交给服务端进行一些Activity结束的操作
        try {
            ActivityManager.getService()
                    .finishActivity(r.token, Activity.RESULT_CANCELED, null,
                            Activity.DONT_FINISH_TASK_WITH_ACTIVITY);
        } catch (RemoteException ex) {
            throw ex.rethrowFromSystemServer();
        }
    }
}

接下来就进入客户端较为关键的performLaunchActivity()方法了

private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
    //...
    //1.获取要启动的Activity的ComponentName对象：里面包含了包名，类名相关的信息；
    ComponentName component = r.intent.getComponent();
    if (component == null) {
        component = r.intent.resolveActivity(
                mInitialApplication.getPackageManager());
        r.intent.setComponent(component);
    }

    //..

    //2.创建Activity的上下文环境：即创建了ContextImpl对象；
    ContextImpl appContext = createBaseContextForActivity(r);
    
    Activity activity = null;
    try {
        java.lang.ClassLoader cl = appContext.getClassLoader();
        
        //3.创建Activity的实例：调用Instrumentation$newActivity方法，并使用类加载器创建Activity对象；
        activity = mInstrumentation.newActivity(
                cl, component.getClassName(), r.intent);

        //...
    } catch (Exception e) {
        //...省略抛异常
    }

    try {
        //4.创建Application对象；
        Application app = r.packageInfo.makeApplication(false, mInstrumentation);

        //...

        if (activity != null) {
            //...

            //5.调用Activity$attach方法：初始化Activity类里的一些数据
            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, r.configCallback);

            //...

            //6.启动Activity：调用Instrumentation$callActivityOnCreate方法；
            activity.mCalled = false;
            if (r.isPersistable()) {
                mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
            } else {
                mInstrumentation.callActivityOnCreate(activity, r.state);
            }
            
            //... 省略别的生命周期的调用
        }
        //..

    } catch (SuperNotCalledException e) {
        //...
    }
    //...

    return activity;
}

在performLaunchActivity方法中，启动的过程大概会经过上述的六步调用，这时，Activity就进入用户视线中了，上述六步中的后面五个步骤在流程图中都有体现。

我们这里再来分开看这五步是如何调用的

创建Activity的上下文环境：即创建了ContextImpl对象，也就是平时使用的context

private ContextImpl createBaseContextForActivity(ActivityClientRecord r) {
    //...

    //进入ContextImpl的createActivityContext方法
    ContextImpl appContext = ContextImpl.createActivityContext(
            this, r.packageInfo, r.activityInfo, r.token, displayId, r.overrideConfig);

    //...
    return appContext;
}

//进入ContextImpl的createActivityContext方法
static ContextImpl createActivityContext(ActivityThread mainThread,
                                         LoadedApk packageInfo, ActivityInfo activityInfo, IBinder activityToken, int displayId,
                                         Configuration overrideConfiguration) {
    //...

    //此处调用构造方法,构造出context
    ContextImpl context = new ContextImpl(null, mainThread, packageInfo, activityInfo.splitName,
            activityToken, null, 0, classLoader);

    //...
    return context;
}

截止到createActivityContext方法，context创建完成

创建Activity的实例：调用Instrumentation$newActivity方法，并使用类加载器创建Activity对象；

public Activity newActivity(ClassLoader cl, String className,
        Intent intent)
        throws InstantiationException, IllegalAccessException,
        ClassNotFoundException {
    //这里通过ClassLoader创建了Activity的实例
    return (Activity)cl.loadClass(className).newInstance();
}

创建Application对象；

public Application makeApplication(boolean forceDefaultAppClass,
                                   Instrumentation instrumentation) {
    //1. 不为空时候直接返回,显然,是个单例,所以一个应用只有一个Application
    if (mApplication != null) {
        return mApplication;
    }

    //...

    Application app = null;

    //...
    //2. 当为空时候,创建,这里和Activity类似,也是实用类加载器来创建的,有兴趣的可以继续查看
    app = mActivityThread.mInstrumentation.newApplication(
            cl, appClass, appContext);

    //...

    //将app赋值到当前Application
    mApplication = app;

    //...

    //这里会调用Application的onCreate方法,接下来查看此方法
    instrumentation.callApplicationOnCreate(app);

    //...

    return app;
}
//这里确实会调用Application的onCreate方法
public void callApplicationOnCreate(Application app) {
    app.onCreate();
}

到这里Application的onCreate方法也调用了。表明Application创建成功

调用Activity$attach方法：初始化Activity类里的一些数据；

final void attach(Context context, ActivityThread aThread,
                  Instrumentation instr, IBinder token, int ident,
                  Application application, Intent intent, ActivityInfo info,
                  CharSequence title, Activity parent, String id,
                  NonConfigurationInstances lastNonConfigurationInstances,
                  Configuration config, String referrer, IVoiceInteractor voiceInteractor,
                  Window window, ActivityConfigCallback activityConfigCallback) {
    //..
    //创建了窗口对象PhoneWindow
    mWindow = new PhoneWindow(this, window, activityConfigCallback);
    //给窗口对象注册监听接口
    mWindow.setWindowControllerCallback(this);
    mWindow.setCallback(this);
    mWindow.setOnWindowDismissedCallback(this);
    mWindow.getLayoutInflater().setPrivateFactory(this);

    //...
    
    //通过窗口Window创建WindowManagerImpl的实例
    mWindow.setWindowManager(
            (WindowManager) context.getSystemService(Context.WINDOW_SERVICE),
            mToken, mComponent.flattenToString(),
            (info.flags & ActivityInfo.FLAG_HARDWARE_ACCELERATED) != 0);
    //...
}

启动Activity：调用Instrumentation$callActivityOnCreate方法；

public void callActivityOnCreate(Activity activity, Bundle icicle,
                                 PersistableBundle persistentState) {
    prePerformCreate(activity);
    //此处调用Activity的方法,里面进行了onCreate操作
    activity.performCreate(icicle, persistentState);
    postPerformCreate(activity);
}

//跟进performCreate方法
final void performCreate(Bundle icicle, PersistableBundle persistentState) {
    restoreHasCurrentPermissionRequest(icicle);
    
    //此处调用onCreate,整个流程分析终于结束
    onCreate(icicle, persistentState);
    mActivityTransitionState.readState(icicle);
    performCreateCommon();
}

至此Activity的启动了流程完成。

通过上面的调用，我们发现虽然调用的方法比较多，但整体流程还是比较清晰的。不过有的方法体会很多，看着不太符合代码整洁之道，可能也是是在不好起名字了吧🤣

Over

最后编辑于：2018.05.24 16:17:16

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 159,569评论 4赞 363
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 67,499评论 1赞 294
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 109,271评论 0赞 244
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 44,087评论 0赞 209
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 52,474评论 3赞 287
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 40,670评论 1赞 222
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 31,911评论 2赞 313
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 30,636评论 0赞 202
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 34,397评论 1赞 246
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 30,607评论 2赞 246
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 32,093评论 1赞 261
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 28,418评论 2赞 254
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 33,074评论 3赞 237
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 26,092评论 0赞 8
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 26,865评论 0赞 196
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 35,726评论 2赞 276
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 35,627评论 2赞 270

Activity详情——Android8.0中Activity的启动流程

读源码前的准备

android的服务端和客户端

ActivityThread、Instrumentation、ActivityManagerService介绍

大体的流程设计

详细调用步骤

客户端方法调用

服务端方法调用

服务端回调后，客户端处理流程

Over

推荐阅读更多精彩内容