Android 系列：Activity

1.Activity启动流程

1.1 Activity -> AMS

 public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
            @Nullable Bundle options) {
        if (mParent == null) {
            options = transferSpringboardActivityOptions(options);
            Instrumentation.ActivityResult ar =
                mInstrumentation.execStartActivity(
                    this, mMainThread.getApplicationThread(), mToken, this,
                    intent, requestCode, options);
          
}    

Instrumentation#execStartActivity

  public ActivityResult execStartActivity(
            Context who, IBinder contextThread, IBinder token, Activity target,
            Intent intent, int requestCode, Bundle options) {
                IApplicationThread whoThread = (IApplicationThread) contextThread;
                //拿到AMS的代理类，这里有IPC
             int result = ActivityManager.getService()
                 .startActivity(whoThread, who.getBasePackageName(), intent,
                        intent.resolveTypeIfNeeded(who.getContentResolver()),
                        token, target != null ? target.mEmbeddedID : null,
                        requestCode, 0, null, options);
            //检验启动后的结果，比如该Activity是否在Activity里面注册了
            checkStartActivityResult(result, intent);
            }

经过上面的两步后，启动的任务交给了AMS

1.2 AMS -> ActivityThread

这里假设应用进程已经启动， 在AMS经过一系列参数传递后，最终会调用到ActivityStackSupervisor

    void startSpecificActivityLocked(ActivityRecord r,
            boolean andResume, boolean checkConfig) {
        // Is this activity's application already running?
        ProcessRecord app = mService.getProcessRecordLocked(r.processName,
                r.info.applicationInfo.uid, true);

        r.getStack().setLaunchTime(r);
        // 需要启动的Activity所在进程存在，并且ApplicationThread准备就绪
        if (app != null && app.thread != null) {
            try {
                //启动Activity
                realStartActivityLocked(r, app, andResume, checkConfig);
                return;
            } catch (RemoteException e) {

            }

        }
        //如果进程不存在，去调用AMS的startProcessLocked 去创建进程，再启动Activity
        mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,
                "activity", r.intent.getComponent(), false, false, true);
                
        
    }

 final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
            boolean andResume, boolean checkConfig) throws RemoteException {
            //IPC 调用ApplicationThread的方法
            app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,
                        System.identityHashCode(r));
            }

从上面可以看出，不管是Activity到AMS，还是AMS到ActivityThread，都是用了IPC机制，并且都是使用ApplicationThread来沟通App进程和AMS所在的SystemServer进程，也就是说==ApplicationThread是APP进程和SystemServer进行IPC的桥梁==

接下来就是在ActivityThread中进行Activity的启动了

1.3 冷启动

如果应用程序进程没有被创建，我们就要去创建，创建完毕后，ActivityThread会向AMS汇报 请求创建Application，Application创建完毕后，再启动根Activity

private final boolean attachApplicationLocked(IApplicationThread thread,
            int pid) {
            //创建Application
                 thread.bindApplication();
            // 再去启动Activity
            realStartActivityLocked(activity, app,top == activity /* andResume */, true /*）
            }

1.3 ActivityThread -> Activity(onCreate)

 private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
    //创建context
     ContextImpl appContext = createBaseContextForActivity(r);
    //new Activity
     java.lang.ClassLoader cl = appContext.getClassLoader();
     activity = mInstrumentation.newActivity(
                    cl, component.getClassName(), r.intent);
    
    //直接去拿Application信息，这里不需要再次创建，因为application已经创建完毕了
    Application app = r.packageInfo.makeApplication(false, mInstrumentation);
    
    //
    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);
 }
 //将context 赋予给父类的mBase 
  final void attach(Context context, ActivityThread aThread,
            Instrumentation instr) {
            
        attachBaseContext(context);
        }

小结：

• 创建Activity对象
• 准备好Application
• 创建context
• attach上下文
• 生命周期回调