回顾

上一篇分析了当应用进程创建过后，反射执行到应用进程的入口方法ActivityThread.main()方法中启动topAcitivy的流程，最终会执行到ActivityStackSupervisor类的realStartActivityLocked()方法，并且分析了后续的调用流程，直到回调到我们熟悉的Activity的onCreate()方法。

前面的分析的流程是由开机后，SystemServer进程启动其他服务的代码块中调用到AMS的systemReady方法，去创建进程和执行进程的main()方法，都不是由我们写的代码逻辑去调用执行的，为了跟开发场景挂钩，还得去分析一下开发过程中去启动Activity调用startActivity(Intent)这样的方式是怎么创建一个Activity的

点击桌面图标，其实就是由launcher进程去启动其他的应用进程，当进程不存在的时候，也是跟前面分析的通过socket通信，zygote孵化进程并执行ActivityThread.main()方法，并执行<intent-filter>中配置的android.intent.category.LAUNCHER对应的Activity

startActivity

//Activity.java
    @Override
    public void startActivity(Intent intent) {
        //一般会将需要传递的参数直接附带在intent对象中，options常为null
        this.startActivity(intent, null);
    }
    
    @Override
    public void startActivity(Intent intent, @Nullable Bundle options) {
        if (mIntent != null && mIntent.hasExtra(AutofillManager.EXTRA_RESTORE_SESSION_TOKEN)
                && mIntent.hasExtra(AutofillManager.EXTRA_RESTORE_CROSS_ACTIVITY)) {
        if (options != null) {
            startActivityForResult(intent, -1, options);
        } else {
            //最终会执行到ForResult方法
            startActivityForResult(intent, -1);
        }
    }

应用开发中也有直接使用startActivityForResult的情况，会传入自定义的requestCode，在使用startActivity方法也是走到同一个流程，requestCode传了-1

    public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
            @Nullable Bundle options) {
        //这个mParent基本都是null,会执行这个逻辑
        if (mParent == null) {
            //生成一个bundle
            options = transferSpringboardActivityOptions(options);
            //通过Instrumentation去启动Activity
            Instrumentation.ActivityResult ar =
                mInstrumentation.execStartActivity(
                    this, mMainThread.getApplicationThread(), mToken, this,
                    intent, requestCode, options);
            //ForResult有返回结果的情况
            if (ar != null) {
                mMainThread.sendActivityResult(
                    mToken, mEmbeddedID, requestCode, ar.getResultCode(),
                    ar.getResultData());
            }
            if (requestCode >= 0) {
                mStartedActivity = true;
            }
                        //开始activity的退出动画
            cancelInputsAndStartExitTransition(options);
        } else {
            if (options != null) {
                mParent.startActivityFromChild(this, intent, requestCode, options);
            } else {
                mParent.startActivityFromChild(this, intent, requestCode);
            }
        }
    }

Activity的方法执行基本都是通过Instrumentation类去操作，上一篇Activity的onCreate执行也是Instrumentation去执行performCreate方法

那么对于这个mParent==null的判断，还是需要去跟一下为啥mParent为null

mParent为null

public class Activity extends ... {
      //mParent也是一个Activity类型的对象
      Activity mParent;
  
      //赋值的位置
      final void attach(Context context, ActivityThread aThread,
            Instrumentation instr, IBinder token, int ident,
            Application application, Intent intent, ActivityInfo info,
            CharSequence title, Activity parent, _) {
        //在attach方法中，引用第10个参数
        mParent = parent;
      }
}

//继续往前追溯,上一篇中分析Activity的创建过程中，调用了performLaunchActivity
//ActivityThread.java
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
  //在onCreate方法调用之前，会先调用attach方法
  //对应的参数就是r.parent
  //r是方法的传入参数，继续往前追溯
  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,
           r.assistToken);
  //上一篇文章分析调用onCreate的位置
  if (r.isPersistable()) {
      mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
     } else {
       mInstrumentation.callActivityOnCreate(activity, r.state);
     }
}

//上一篇分析中，在execute方法中实例化了ActivityClientRecord
//LaunchActivityItem.java
public class LaunchActivityItem extends ClientTransactionItem {
      @Override
    public void execute(ClientTransactionHandler client, IBinder token,
            PendingTransactionActions pendingActions) {
        //将一些列的参数封装成ActivityClientRecord对象用于启动后续获取参数
        ActivityClientRecord r = new ActivityClientRecord(token, mIntent, mIdent, mInfo,
                mOverrideConfig, mCompatInfo, mReferrer, mVoiceInteractor, mState, mPersistentState,
                mPendingResults, mPendingNewIntents, mIsForward,
                mProfilerInfo, client, mAssistToken, mFixedRotationAdjustments);
        client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
    }
}

//然后在ActivityClientRecord.java的构造函数中
public static final class ActivityClientRecord {
                Activity parent;
  
          public ActivityClientRecord(IBinder token, Intent intent, int ident,
                ActivityInfo info, Configuration overrideConfig, CompatibilityInfo compatInfo,
                String referrer, IVoiceInteractor voiceInteractor, Bundle state,
                PersistableBundle persistentState, List<ResultInfo> pendingResults,
                List<ReferrerIntent> pendingNewIntents, boolean isForward,
                ProfilerInfo profilerInfo, ClientTransactionHandler client,
                IBinder assistToken, FixedRotationAdjustments fixedRotationAdjustments) {
                //...没有对parent赋值
            init();
        }
  
          private void init() {
            //这里将parent设置了null
            parent = null;
        }
}

通过一系列的调用追踪，发现mParent参数初始的时候为null,在调用过程中没有赋值，查看了部分网上的资料，这个属性是Activity的父Activity，类似于Activity管理Fragment,属于基本已经弃用的属性，毕竟Fragment不需要Window对象更加的轻量级，所以也就不继续纠结这个属性了，继续往后分析源码

既然知道了mParent为null，那后续流程就进入了Instrumentation的execStartActivity()方法了

//Instrumentation.java
    public ActivityResult execStartActivity(
            Context who, IBinder contextThread, IBinder token, Activity target,
            Intent intent, int requestCode, Bundle options) {
           try {
             //调用到了ATMS的startActivity方法
            int result = ActivityTaskManager.getService().startActivity(whoThread,
                    who.getBasePackageName(), who.getAttributionTag(), intent,
                    intent.resolveTypeIfNeeded(who.getContentResolver()), token,
                    target != null ? target.mEmbeddedID : null, requestCode, 0, null, options);
            checkStartActivityResult(result, intent);
        }
    }

//ActivityTaskManagerService.java
    public final int startActivity() {
        return startActivityAsUser();
    }

    @Override
    public int startActivityAsUser() {
        return startActivityAsUser();
    }

    private int startActivityAsUser(I) {
        //调用到了ActivityStarter.java
        return getActivityStartController().obtainStarter(intent, "startActivityAsUser")
                /*省略了一些列赋值操作*/
                .execute();
    }

到了这一步，如果看了前面几篇流程的朋友应该会感到很熟悉，在launcher进程启动的文章中，调用startHomeActivity也是通过obtainStarter获取到ActivityStarter实例，并且调用其execute()方法

#ActivityStartController.java
void startHomeActivity(Intent intent, ActivityInfo aInfo, String reason,
            TaskDisplayArea taskDisplayArea) {
            //获取ActivityStarter的实例，去执行execute方法
        mLastHomeActivityStartResult = obtainStarter(intent, "startHomeActivity: " + reason)
                                /*省略了一些列赋值操作*/
                .execute();
    }
//通过obtainStarter去获取一个ActivityStarter实例
ActivityStarter obtainStarter(Intent intent, String reason) {
        return mFactory.obtain().setIntent(intent).setReason(reason);
    }

这就到了前面熟悉的流程，后续会继续调用到ActivityStackSupervisor.java的startSpecificActivity()方法，因为进程的存在，往后就会调用到realStartActivityLocked()这个非常熟悉的方法，一直执行到Activity的onCreate()方法

小结

到了这一步，我们就能对Activity的创建和启动中涉及到的类的调用链有了一个概念，也能知道我们应用开发中启动一个Activity是调用的startActivity()方法，然后在Activity中的入口执行代码是写在onCreate()回调中

除了这两个方法去处理业务逻辑，启动一个activity我们还需要在manifest中进行声明注册，可以对其配置一些启动模式，如"android:launchMode="singleTask""等，还可以指定Activity的任务栈”android:taskAffinity="bitibaba"等操作，这些操作的处理和验证就在上面分析的调用方法过程中

接下来的文章就会针对Activity的这些属性的处理进一步分析，以便能更加清晰的认知Activity这个打交道最多的四大组件