startActivity启动过程

基于Android10.0，分析startActivity的启动过程

一、概述

startActivity的整体流程和startService相近，启动后都是通过AMS来完成的。但相比service启动更加复杂，多了任务栈、UI、生命周期。其启动流程如下：

二、启动流程

启动Activity，一般是用startActivity。

2.1 Activity.startActivity

[->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 {
         // Note we want to go through this call for compatibility with
         // applications that may have overridden the method.
         startActivityForResult(intent, -1);
     }
 }

2.2 startActivityForResult

[->ContextImpl.java]

/**
   * @hide
   */
  @Override
  @UnsupportedAppUsage
  public void startActivityForResult(
          String who, Intent intent, int requestCode, @Nullable Bundle options) {
      Uri referrer = onProvideReferrer();
      if (referrer != null) {
          intent.putExtra(Intent.EXTRA_REFERRER, referrer);
      }
      options = transferSpringboardActivityOptions(options);
      Instrumentation.ActivityResult ar =
          mInstrumentation.execStartActivity(
              this, mMainThread.getApplicationThread(), mToken, who,
              intent, requestCode, options);
      if (ar != null) {
          mMainThread.sendActivityResult(
              mToken, who, requestCode,
              ar.getResultCode(), ar.getResultData());
      }
      cancelInputsAndStartExitTransition(options);
  }

execStartActivity方法参数：

mAppThread:类型为ApplicationThread,通过mMainThread.getApplicationThread()获取。

mToken：为Binder类型

2.3 execStartActivity

[->Instrumentation.java]

public ActivityResult execStartActivity(
      Context who, IBinder contextThread, IBinder token, String target,
      Intent intent, int requestCode, Bundle options) {
      IApplicationThread whoThread = (IApplicationThread) contextThread;
      if (mActivityMonitors != null) {
          synchronized (mSync) {
              final int N = mActivityMonitors.size();
              for (int i=0; i<N; i++) {
                  final ActivityMonitor am = mActivityMonitors.get(i);
                  ActivityResult result = null;
                  if (am.ignoreMatchingSpecificIntents()) {
                      result = am.onStartActivity(intent);
                  }
                  if (result != null) {
                      am.mHits++;
                      return result;
                  } else if (am.match(who, null, intent)) {
                      am.mHits++;
                      //如果am阻塞activity启动，则返回
                      if (am.isBlocking()) {
                          return requestCode >= 0 ? am.getResult() : null;
                      }
                      break;
                  }
              }
          }
      }
      try {
          intent.migrateExtraStreamToClipData();
          intent.prepareToLeaveProcess(who);
          int result = ActivityManager.getService()
              .startActivity(whoThread, who.getBasePackageName(), intent,
                      intent.resolveTypeIfNeeded(who.getContentResolver()),
                      token, target, requestCode, 0, null, options);
          checkStartActivityResult(result, intent);
      } catch (RemoteException e) {
          throw new RuntimeException("Failure from system", e);
      }
      return null;
  }

2.3.1 AM.getService

和Android6.0不同的是Android10.0直接通过AIDL的方式生成了AMS的代理。

/**
    * @hide
    */
   @UnsupportedAppUsage
   public static IActivityManager getService() {
       return IActivityManagerSingleton.get();
   }
   public abstract class Singleton<T> {
   @UnsupportedAppUsage
   private T mInstance;

   protected abstract T create();

   @UnsupportedAppUsage
   public final T get() {
       synchronized (this) {
           if (mInstance == null) {
               mInstance = create();
           }
           return mInstance;
       }
   }
 }  
   @UnsupportedAppUsage
   private static final Singleton<IActivityManager> IActivityManagerSingleton =
           new Singleton<IActivityManager>() {
               @Override
               protected IActivityManager create() {
                   final IBinder b = ServiceManager.getService(Context.ACTIVITY_SERVICE);
                   //获取AMS的代理
                   final IActivityManager am = IActivityManager.Stub.asInterface(b);
                   return am;
               }
           };

2.4 IActivityManager.startActivity

通过AIDL生成的代理类调用AMS的startActivity，其代理类在编译的时候，会自动生成。

startActivity共有10个参数，参数对应值如下：

• caller：当前应用的Application对象mAppThread
• callingPackage:当前Activity所在的包名
• intent：启动Activity传过来的参数
• resolvedType：调用intent.resolveTypeIfNeeded获取
• resultTo：来自当前Activity.mToken
• resultWho： 来自当前Activity.mEmbeddedID
• requestCode:-1
• startFlags:0
• profilerInfo：null
• bOptions:null

2.5 AMS.startActivity

[->ActivityManagerService.java]

@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) {
     return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
             resultWho, requestCode, startFlags, profilerInfo, bOptions,
             UserHandle.getCallingUserId());
 }
  @Override
 public final int startActivityAsUser(IApplicationThread caller, String callingPackage,
         Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
         int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId) {
     return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
             resultWho, requestCode, startFlags, profilerInfo, bOptions, userId,
             true /*validateIncomingUser*/);
 }

2.6 AMS.startActivityAsUser

[->ActivityManagerService.java]

public final int startActivityAsUser(IApplicationThread caller, String callingPackage,
           Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
           int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId,
           boolean validateIncomingUser) {
       enforceNotIsolatedCaller("startActivity");

       userId = mActivityStartController.checkTargetUser(userId, validateIncomingUser,
               Binder.getCallingPid(), Binder.getCallingUid(), "startActivityAsUser");

       // TODO: Switch to user app stacks here.
       return mActivityStartController.obtainStarter(intent, "startActivityAsUser")
               .setCaller(caller)
               .setCallingPackage(callingPackage)
               .setResolvedType(resolvedType)
               .setResultTo(resultTo)
               .setResultWho(resultWho)
               .setRequestCode(requestCode)
               .setStartFlags(startFlags)
               .setProfilerInfo(profilerInfo)
               .setActivityOptions(bOptions)
               .setMayWait(userId)
               .execute();

   }

通过建造者模式，来设置参数，其参数在2.4节有介绍，通过execute方法最后执行。

2.6.1 ASC.obtainStarter

[->ActivityStartController.java]

/**
    * @return A starter to configure and execute starting an activity. It is valid until after
    *         {@link ActivityStarter#execute} is invoked. At that point, the starter should be
    *         considered invalid and no longer modified or used.
    */
   ActivityStarter obtainStarter(Intent intent, String reason) {
       return mFactory.obtain().setIntent(intent).setReason(reason);
   }

2.6.2 AS.setMayWait

这个方法在2.6.3节中用到，可以看到这里将mRequest.mayWait设置为true

ActivityStarter setMayWait(int userId) {
     mRequest.mayWait = true;
     mRequest.userId = userId;
     return this;
 }

2.6.3 AS.execute

[->ActivityStarter.java]

/**
    * Starts an activity based on the request parameters provided earlier.
    * @return The starter result.
    */
   int execute() {
       try {
           // TODO(b/64750076): Look into passing request directly to these methods to allow
           // for transactional diffs and preprocessing.
           //经过该方法，前面已经设置为true
           if (mRequest.mayWait) {
               return startActivityMayWait(mRequest.caller, mRequest.callingUid,
                       mRequest.callingPackage, mRequest.intent, mRequest.resolvedType,
                       mRequest.voiceSession, mRequest.voiceInteractor, mRequest.resultTo,
                       mRequest.resultWho, mRequest.requestCode, mRequest.startFlags,
                       mRequest.profilerInfo, mRequest.waitResult, mRequest.globalConfig,
                       mRequest.activityOptions, mRequest.ignoreTargetSecurity, mRequest.userId,
                       mRequest.inTask, mRequest.reason,
                       mRequest.allowPendingRemoteAnimationRegistryLookup,
                       mRequest.originatingPendingIntent);
           } else {
               return startActivity(mRequest.caller, mRequest.intent, mRequest.ephemeralIntent,
                       mRequest.resolvedType, mRequest.activityInfo, mRequest.resolveInfo,
                       mRequest.voiceSession, mRequest.voiceInteractor, mRequest.resultTo,
                       mRequest.resultWho, mRequest.requestCode, mRequest.callingPid,
                       mRequest.callingUid, mRequest.callingPackage, mRequest.realCallingPid,
                       mRequest.realCallingUid, mRequest.startFlags, mRequest.activityOptions,
                       mRequest.ignoreTargetSecurity, mRequest.componentSpecified,
                       mRequest.outActivity, mRequest.inTask, mRequest.reason,
                       mRequest.allowPendingRemoteAnimationRegistryLookup,
                       mRequest.originatingPendingIntent);
           }
       } finally {
           onExecutionComplete();
       }
   }

2.7 AS.startActivityMayWait

这个方法的参数有21个，具体重要的几个参数2.4节已经介绍过, inTask = null。

[->ActivityStarter.java]

private 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, SafeActivityOptions options, boolean ignoreTargetSecurity,
           int userId, TaskRecord inTask, String reason,
           boolean allowPendingRemoteAnimationRegistryLookup,
           PendingIntentRecord originatingPendingIntent) {
       // Refuse possible leaked file descriptors
       if (intent != null && intent.hasFileDescriptors()) {
           throw new IllegalArgumentException("File descriptors passed in Intent");
       }
       //activity开始启动日志
       mSupervisor.getActivityMetricsLogger().notifyActivityLaunching();
       boolean componentSpecified = intent.getComponent() != null;

       final int realCallingPid = Binder.getCallingPid();
       final int realCallingUid = Binder.getCallingUid();

       int callingPid;
       if (callingUid >= 0) {
           callingPid = -1;
       } else if (caller == null) {
           callingPid = realCallingPid;
           callingUid = realCallingUid;
       } else {
           callingPid = callingUid = -1;
       }

       // Save a copy in case ephemeral needs it
       final Intent ephemeralIntent = new Intent(intent);
       // Don't modify the client's object!
       intent = new Intent(intent);
       //对一些特殊的intent做处理
       if (componentSpecified
               && !(Intent.ACTION_VIEW.equals(intent.getAction()) && intent.getData() == null)
               && !Intent.ACTION_INSTALL_INSTANT_APP_PACKAGE.equals(intent.getAction())
               && !Intent.ACTION_RESOLVE_INSTANT_APP_PACKAGE.equals(intent.getAction())
               && mService.getPackageManagerInternalLocked()
                       .isInstantAppInstallerComponent(intent.getComponent())) {
           // intercept intents targeted directly to the ephemeral installer the
           // ephemeral installer should never be started with a raw Intent; instead
           // adjust the intent so it looks like a "normal" instant app launch
           intent.setComponent(null /*component*/);
           componentSpecified = false;
       }
       //处理intent信息，当存在多个activity时，弹出resolverAcitvity
       ResolveInfo rInfo = mSupervisor.resolveIntent(intent, resolvedType, userId,
               0 /* matchFlags */,
                       computeResolveFilterUid(
                               callingUid, realCallingUid, mRequest.filterCallingUid));
       if (rInfo == null) {
           UserInfo userInfo = mSupervisor.getUserInfo(userId);
           if (userInfo != null && userInfo.isManagedProfile()) {
               // Special case for managed profiles, if attempting to launch non-cryto aware
               // app in a locked managed profile from an unlocked parent allow it to resolve
               // as user will be sent via confirm credentials to unlock the profile.
               UserManager userManager = UserManager.get(mService.mContext);
               boolean profileLockedAndParentUnlockingOrUnlocked = false;
               long token = Binder.clearCallingIdentity();
               try {
                   UserInfo parent = userManager.getProfileParent(userId);
                   profileLockedAndParentUnlockingOrUnlocked = (parent != null)
                           && userManager.isUserUnlockingOrUnlocked(parent.id)
                           && !userManager.isUserUnlockingOrUnlocked(userId);
               } finally {
                   Binder.restoreCallingIdentity(token);
               }
               if (profileLockedAndParentUnlockingOrUnlocked) {
                   rInfo = mSupervisor.resolveIntent(intent, resolvedType, userId,
                           PackageManager.MATCH_DIRECT_BOOT_AWARE
                                   | PackageManager.MATCH_DIRECT_BOOT_UNAWARE,
                           computeResolveFilterUid(
                                   callingUid, realCallingUid, mRequest.filterCallingUid));
               }
           }
       }
       //收集intent所指向的activity信息
       // Collect information about the target of the Intent.
       ActivityInfo aInfo = mSupervisor.resolveActivity(intent, rInfo, startFlags, profilerInfo);

       synchronized (mService) {
           final ActivityStack stack = mSupervisor.mFocusedStack;
           stack.mConfigWillChange = globalConfig != null
                   && mService.getGlobalConfiguration().diff(globalConfig) != 0;
           if (DEBUG_CONFIGURATION) Slog.v(TAG_CONFIGURATION,
                   "Starting activity when config will change = " + stack.mConfigWillChange);

           final long origId = Binder.clearCallingIdentity();

           if (aInfo != null &&
                   (aInfo.applicationInfo.privateFlags
                           & ApplicationInfo.PRIVATE_FLAG_CANT_SAVE_STATE) != 0 &&
                   mService.mHasHeavyWeightFeature) {
               //heavy-weight进程处理流程
               // This may be a heavy-weight process!  Check to see if we already
               // have another, different heavy-weight process running.
               if (aInfo.processName.equals(aInfo.applicationInfo.packageName)) {
                   final ProcessRecord heavy = mService.mHeavyWeightProcess;
                   if (heavy != null && (heavy.info.uid != aInfo.applicationInfo.uid
                           || !heavy.processName.equals(aInfo.processName))) {
                       int appCallingUid = callingUid;
                       if (caller != null) {
                           ProcessRecord callerApp = mService.getRecordForAppLocked(caller);
                           if (callerApp != null) {
                               appCallingUid = callerApp.info.uid;
                           } else {
                               Slog.w(TAG, "Unable to find app for caller " + caller
                                       + " (pid=" + callingPid + ") when starting: "
                                       + intent.toString());
                               SafeActivityOptions.abort(options);
                               return ActivityManager.START_PERMISSION_DENIED;
                           }
                       }

                       IIntentSender target = mService.getIntentSenderLocked(
                               ActivityManager.INTENT_SENDER_ACTIVITY, "android",
                               appCallingUid, userId, null, null, 0, new Intent[] { intent },
                               new String[] { resolvedType }, PendingIntent.FLAG_CANCEL_CURRENT
                                       | PendingIntent.FLAG_ONE_SHOT, null);

                       Intent newIntent = new Intent();
                       if (requestCode >= 0) {
                           // Caller is requesting a result.
                           newIntent.putExtra(HeavyWeightSwitcherActivity.KEY_HAS_RESULT, true);
                       }
                       newIntent.putExtra(HeavyWeightSwitcherActivity.KEY_INTENT,
                               new IntentSender(target));
                       if (heavy.activities.size() > 0) {
                           ActivityRecord hist = heavy.activities.get(0);
                           newIntent.putExtra(HeavyWeightSwitcherActivity.KEY_CUR_APP,
                                   hist.packageName);
                           newIntent.putExtra(HeavyWeightSwitcherActivity.KEY_CUR_TASK,
                                   hist.getTask().taskId);
                       }
                       newIntent.putExtra(HeavyWeightSwitcherActivity.KEY_NEW_APP,
                               aInfo.packageName);
                       newIntent.setFlags(intent.getFlags());
                       newIntent.setClassName("android",
                               HeavyWeightSwitcherActivity.class.getName());
                       intent = newIntent;
                       resolvedType = null;
                       caller = null;
                       callingUid = Binder.getCallingUid();
                       callingPid = Binder.getCallingPid();
                       componentSpecified = true;
                       rInfo = mSupervisor.resolveIntent(intent, null /*resolvedType*/, userId,
                               0 /* matchFlags */, computeResolveFilterUid(
                                       callingUid, realCallingUid, mRequest.filterCallingUid));
                       aInfo = rInfo != null ? rInfo.activityInfo : null;
                       if (aInfo != null) {
                           aInfo = mService.getActivityInfoForUser(aInfo, userId);
                       }
                   }
               }
           }

           final ActivityRecord[] outRecord = new ActivityRecord[1];
           //见2.8节
           int res = startActivity(caller, intent, ephemeralIntent, resolvedType, aInfo, rInfo,
                   voiceSession, voiceInteractor, resultTo, resultWho, requestCode, callingPid,
                   callingUid, callingPackage, realCallingPid, realCallingUid, startFlags, options,
                   ignoreTargetSecurity, componentSpecified, outRecord, inTask, reason,
                   allowPendingRemoteAnimationRegistryLookup, originatingPendingIntent);

           Binder.restoreCallingIdentity(origId);

           if (stack.mConfigWillChange) {
               // If the caller also wants to switch to a new configuration,
               // do so now.  This allows a clean switch, as we are waiting
               // for the current activity to pause (so we will not destroy
               // it), and have not yet started the next activity.
               mService.enforceCallingPermission(android.Manifest.permission.CHANGE_CONFIGURATION,
                       "updateConfiguration()");
               stack.mConfigWillChange = false;
               if (DEBUG_CONFIGURATION) Slog.v(TAG_CONFIGURATION,
                       "Updating to new configuration after starting activity.");
               mService.updateConfigurationLocked(globalConfig, null, false);
           }

           // Notify ActivityMetricsLogger that the activity has launched. ActivityMetricsLogger
           // will then wait for the windows to be drawn and populate WaitResult.
           mSupervisor.getActivityMetricsLogger().notifyActivityLaunched(res, outRecord[0]);
           if (outResult != null) {
               outResult.result = res;

               final ActivityRecord r = outRecord[0];

               switch(res) {
                   case START_SUCCESS: {
                       mSupervisor.mWaitingActivityLaunched.add(outResult);
                       do {
                           try {
                               mService.wait();
                           } catch (InterruptedException e) {
                           }
                       } while (outResult.result != START_TASK_TO_FRONT
                               && !outResult.timeout && outResult.who == null);
                       if (outResult.result == START_TASK_TO_FRONT) {
                           res = START_TASK_TO_FRONT;
                       }
                       break;
                   }
                   case START_DELIVERED_TO_TOP: {
                       outResult.timeout = false;
                       outResult.who = r.realActivity;
                       outResult.totalTime = 0;
                       break;
                   }
                   case START_TASK_TO_FRONT: {
                       // ActivityRecord may represent a different activity, but it should not be
                       // in the resumed state.
                       if (r.nowVisible && r.isState(RESUMED)) {
                           outResult.timeout = false;
                           outResult.who = r.realActivity;
                           outResult.totalTime = 0;
                       } else {
                           final long startTimeMs = SystemClock.uptimeMillis();
                           mSupervisor.waitActivityVisible(r.realActivity, outResult, startTimeMs);
                           // Note: the timeout variable is not currently not ever set.
                           do {
                               try {
                                   mService.wait();
                               } catch (InterruptedException e) {
                               }
                           } while (!outResult.timeout && outResult.who == null);
                       }
                       break;
                   }
               }
           }

           return res;
       }
   }

2.7.1 PKMS.resolveIntent

[->PackageManagerService.java]

mSupervisor.resolveInten经过层层调用，通过IPC最后会调用PKMS对象中的resolveIntent。

/**
    * Normally instant apps can only be resolved when they're visible to the caller.
    * However, if {@code resolveForStart} is {@code true}, all instant apps are visible
    * since we need to allow the system to start any installed application.
    */
   private ResolveInfo resolveIntentInternal(Intent intent, String resolvedType,
           int flags, int userId, boolean resolveForStart, int filterCallingUid) {
       try {
           Trace.traceBegin(TRACE_TAG_PACKAGE_MANAGER, "resolveIntent");

           if (!sUserManager.exists(userId)) return null;
           final int callingUid = Binder.getCallingUid();
           flags = updateFlagsForResolve(flags, userId, intent, filterCallingUid, resolveForStart);
           mPermissionManager.enforceCrossUserPermission(callingUid, userId,
                   false /*requireFullPermission*/, false /*checkShell*/, "resolve intent");

           Trace.traceBegin(TRACE_TAG_PACKAGE_MANAGER, "queryIntentActivities");
           //找到相应的activity组件，并保存intent对象
           final List<ResolveInfo> query = queryIntentActivitiesInternal(intent, resolvedType,
                   flags, filterCallingUid, userId, resolveForStart, true /*allowDynamicSplits*/);
           Trace.traceEnd(TRACE_TAG_PACKAGE_MANAGER);
           //根据priority选择最佳的activity
           final ResolveInfo bestChoice =
                   chooseBestActivity(intent, resolvedType, flags, query, userId);
           return bestChoice;
       } finally {
           Trace.traceEnd(TRACE_TAG_PACKAGE_MANAGER);
       }
   }

2.7.2 ASS.resolveActivity

[->ActivityStackSupervisor.java]

ActivityInfo resolveActivity(Intent intent, ResolveInfo rInfo, int startFlags,
           ProfilerInfo profilerInfo) {
       final ActivityInfo aInfo = rInfo != null ? rInfo.activityInfo : null;
       if (aInfo != null) {
           // Store the found target back into the intent, because now that
           // we have it we never want to do this again.  For example, if the
           // user navigates back to this point in the history, we should
           // always restart the exact same activity.
           intent.setComponent(new ComponentName(
                   aInfo.applicationInfo.packageName, aInfo.name));

           // Don't debug things in the system process
           if (!aInfo.processName.equals("system")) {
               if ((startFlags & ActivityManager.START_FLAG_DEBUG) != 0) {
                   mService.setDebugApp(aInfo.processName, true, false);
               }

               if ((startFlags & ActivityManager.START_FLAG_NATIVE_DEBUGGING) != 0) {
                   mService.setNativeDebuggingAppLocked(aInfo.applicationInfo, aInfo.processName);
               }

               if ((startFlags & ActivityManager.START_FLAG_TRACK_ALLOCATION) != 0) {
                   mService.setTrackAllocationApp(aInfo.applicationInfo, aInfo.processName);
               }

               if (profilerInfo != null) {
                   mService.setProfileApp(aInfo.applicationInfo, aInfo.processName, profilerInfo);
               }
           }
           final String intentLaunchToken = intent.getLaunchToken();
           if (aInfo.launchToken == null && intentLaunchToken != null) {
               aInfo.launchToken = intentLaunchToken;
           }
       }
       return aInfo;
   }

Activity类有3个flags用于调试

• START_FLAG_DEBUG：用于调试debug app
• START_FLAG_NATIVE_DEBUGGING：用于调试native
• START_FLAG_TRACK_ALLOCATION：用于调试allocation tracking

2.8 AS.startActivity

[->ActivityStarter.java]

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,
          SafeActivityOptions options, boolean ignoreTargetSecurity, boolean componentSpecified,
          ActivityRecord[] outActivity, TaskRecord inTask, String reason,
          boolean allowPendingRemoteAnimationRegistryLookup,
          PendingIntentRecord originatingPendingIntent) {

      if (TextUtils.isEmpty(reason)) {
          throw new IllegalArgumentException("Need to specify a reason.");
      }
      mLastStartReason = reason;
      mLastStartActivityTimeMs = System.currentTimeMillis();
      mLastStartActivityRecord[0] = null;

      mLastStartActivityResult = startActivity(caller, intent, ephemeralIntent, resolvedType,
              aInfo, rInfo, voiceSession, voiceInteractor, resultTo, resultWho, requestCode,
              callingPid, callingUid, callingPackage, realCallingPid, realCallingUid, startFlags,
              options, ignoreTargetSecurity, componentSpecified, mLastStartActivityRecord,
              inTask, allowPendingRemoteAnimationRegistryLookup, originatingPendingIntent);

      if (outActivity != null) {
          // mLastStartActivityRecord[0] is set in the call to startActivity above.
          outActivity[0] = mLastStartActivityRecord[0];
      }

      return getExternalResult(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,
           SafeActivityOptions options,
           boolean ignoreTargetSecurity, boolean componentSpecified, ActivityRecord[] outActivity,
           TaskRecord inTask, boolean allowPendingRemoteAnimationRegistryLookup,
           PendingIntentRecord originatingPendingIntent) {
       int err = ActivityManager.START_SUCCESS;
       // Pull the optional Ephemeral Installer-only bundle out of the options early.
       final Bundle verificationBundle
               = options != null ? options.popAppVerificationBundle() : null;
       //获取调用者的进程记录对象
       ProcessRecord callerApp = null;
       if (caller != null) {
           callerApp = mService.getRecordForAppLocked(caller);
           if (callerApp != null) {
               callingPid = callerApp.pid;
               callingUid = callerApp.info.uid;
           } else {
               Slog.w(TAG, "Unable to find app for caller " + caller
                       + " (pid=" + callingPid + ") when starting: "
                       + intent.toString());
               err = ActivityManager.START_PERMISSION_DENIED;
           }
       }

       final int userId = aInfo != null && aInfo.applicationInfo != null
               ? UserHandle.getUserId(aInfo.applicationInfo.uid) : 0;

       if (err == ActivityManager.START_SUCCESS) {
           Slog.i(TAG, "START u" + userId + " {" + intent.toShortString(true, true, true, false)
                   + "} from uid " + callingUid);
       }

       //获取调用者所在的activity
       ActivityRecord sourceRecord = null;
       ActivityRecord resultRecord = null;
       if (resultTo != null) {
           sourceRecord = mSupervisor.isInAnyStackLocked(resultTo);
           if (DEBUG_RESULTS) Slog.v(TAG_RESULTS,
                   "Will send result to " + resultTo + " " + sourceRecord);
           if (sourceRecord != null) {
               //requestCode = -1 不会进入
               if (requestCode >= 0 && !sourceRecord.finishing) {
                   resultRecord = sourceRecord;
               }
           }
       }

       final int launchFlags = intent.getFlags();

       if ((launchFlags & Intent.FLAG_ACTIVITY_FORWARD_RESULT) != 0 && sourceRecord != null) {
           //activity执行结果的返回由源activity切换到新activity，不需要返回结果则不会进该分支  
           // Transfer the result target from the source activity to the new
           // one being started, including any failures.
           if (requestCode >= 0) {
               SafeActivityOptions.abort(options);
               return ActivityManager.START_FORWARD_AND_REQUEST_CONFLICT;
           }
           resultRecord = sourceRecord.resultTo;
           if (resultRecord != null && !resultRecord.isInStackLocked()) {
               resultRecord = null;
           }
           resultWho = sourceRecord.resultWho;
           requestCode = sourceRecord.requestCode;
           sourceRecord.resultTo = null;
           if (resultRecord != null) {
               resultRecord.removeResultsLocked(sourceRecord, resultWho, requestCode);
           }
           if (sourceRecord.launchedFromUid == callingUid) {
               // The new activity is being launched from the same uid as the previous
               // activity in the flow, and asking to forward its result back to the
               // previous.  In this case the activity is serving as a trampoline between
               // the two, so we also want to update its launchedFromPackage to be the
               // same as the previous activity.  Note that this is safe, since we know
               // these two packages come from the same uid; the caller could just as
               // well have supplied that same package name itself.  This specifially
               // deals with the case of an intent picker/chooser being launched in the app
               // flow to redirect to an activity picked by the user, where we want the final
               // activity to consider it to have been launched by the previous app activity.
               callingPackage = sourceRecord.launchedFromPackage;
           }
       }
 
       if (err == ActivityManager.START_SUCCESS && intent.getComponent() == null) {
           //从intent中无法找到相应的component
           // We couldn't find a class that can handle the given Intent.
           // That's the end of that!
           err = ActivityManager.START_INTENT_NOT_RESOLVED;
       }

       if (err == ActivityManager.START_SUCCESS && aInfo == null) {
           //从intent中无法找到相应的ActivityInfo
           // We couldn't find the specific class specified in the Intent.
           // Also the end of the line.
           err = ActivityManager.START_CLASS_NOT_FOUND;
       }

       if (err == ActivityManager.START_SUCCESS && sourceRecord != null
               && sourceRecord.getTask().voiceSession != null) {
            //启动的activity是voice session一部分
           // If this activity is being launched as part of a voice session, we need
           // to ensure that it is safe to do so.  If the upcoming activity will also
           // be part of the voice session, we can only launch it if it has explicitly
           // said it supports the VOICE category, or it is a part of the calling app.
           if ((launchFlags & FLAG_ACTIVITY_NEW_TASK) == 0
                   && sourceRecord.info.applicationInfo.uid != aInfo.applicationInfo.uid) {
               try {
                   intent.addCategory(Intent.CATEGORY_VOICE);
                   if (!mService.getPackageManager().activitySupportsIntent(
                           intent.getComponent(), intent, resolvedType)) {
                       Slog.w(TAG,
                               "Activity being started in current voice task does not support voice: "
                                       + intent);
                       err = ActivityManager.START_NOT_VOICE_COMPATIBLE;
                   }
               } catch (RemoteException e) {
                   Slog.w(TAG, "Failure checking voice capabilities", e);
                   err = ActivityManager.START_NOT_VOICE_COMPATIBLE;
               }
           }
       }

       if (err == ActivityManager.START_SUCCESS && voiceSession != null) {
           //启动是是voice session
           // If the caller is starting a new voice session, just make sure the target
           // is actually allowing it to run this way.
           try {
               if (!mService.getPackageManager().activitySupportsIntent(intent.getComponent(),
                       intent, resolvedType)) {
                   Slog.w(TAG,
                           "Activity being started in new voice task does not support: "
                                   + intent);
                   err = ActivityManager.START_NOT_VOICE_COMPATIBLE;
               }
           } catch (RemoteException e) {
               Slog.w(TAG, "Failure checking voice capabilities", e);
               err = ActivityManager.START_NOT_VOICE_COMPATIBLE;
           }
       }

       final ActivityStack resultStack = resultRecord == null ? null : resultRecord.getStack();
       //错误则返回
       if (err != START_SUCCESS) {
           if (resultRecord != null) {
               resultStack.sendActivityResultLocked(
                       -1, resultRecord, resultWho, requestCode, RESULT_CANCELED, null);
           }
           SafeActivityOptions.abort(options);
           return err;
       }

       //检查权限
       boolean abort = !mSupervisor.checkStartAnyActivityPermission(intent, aInfo, resultWho,
               requestCode, callingPid, callingUid, callingPackage, ignoreTargetSecurity,
               inTask != null, callerApp, resultRecord, resultStack);
       abort |= !mService.mIntentFirewall.checkStartActivity(intent, callingUid,
               callingPid, resolvedType, aInfo.applicationInfo);

       // Merge the two options bundles, while realCallerOptions takes precedence.
       ActivityOptions checkedOptions = options != null
               ? options.getOptions(intent, aInfo, callerApp, mSupervisor)
               : null;
       if (allowPendingRemoteAnimationRegistryLookup) {
           checkedOptions = mService.getActivityStartController()
                   .getPendingRemoteAnimationRegistry()
                   .overrideOptionsIfNeeded(callingPackage, checkedOptions);
       }
       //ActivityController不为空的情况，比如monkey测试过程
       if (mService.mController != null) {
           try {
               // The Intent we give to the watcher has the extra data
               // stripped off, since it can contain private information.
               Intent watchIntent = intent.cloneFilter();
               abort |= !mService.mController.activityStarting(watchIntent,
                       aInfo.applicationInfo.packageName);
           } catch (RemoteException e) {
               mService.mController = null;
           }
       }

       mInterceptor.setStates(userId, realCallingPid, realCallingUid, startFlags, callingPackage);
       if (mInterceptor.intercept(intent, rInfo, aInfo, resolvedType, inTask, callingPid,
               callingUid, checkedOptions)) {
           // activity被拦截
           // activity start was intercepted, e.g. because the target user is currently in quiet
           // mode (turn off work) or the target application is suspended
           intent = mInterceptor.mIntent;
           rInfo = mInterceptor.mRInfo;
           aInfo = mInterceptor.mAInfo;
           resolvedType = mInterceptor.mResolvedType;
           inTask = mInterceptor.mInTask;
           callingPid = mInterceptor.mCallingPid;
           callingUid = mInterceptor.mCallingUid;
           checkedOptions = mInterceptor.mActivityOptions;
       }

       //终止则返回
       if (abort) {
           if (resultRecord != null) {
               resultStack.sendActivityResultLocked(-1, resultRecord, resultWho, requestCode,
                       RESULT_CANCELED, null);
           }
           // We pretend to the caller that it was really started, but
           // they will just get a cancel result.
           ActivityOptions.abort(checkedOptions);
           return START_ABORTED;
       }
       //如果需要再检查权限，则启动检查activity
       // If permissions need a review before any of the app components can run, we
       // launch the review activity and pass a pending intent to start the activity
       // we are to launching now after the review is completed.
       if (mService.mPermissionReviewRequired && aInfo != null) {
           if (mService.getPackageManagerInternalLocked().isPermissionsReviewRequired(
                   aInfo.packageName, userId)) {
               IIntentSender target = mService.getIntentSenderLocked(
                       ActivityManager.INTENT_SENDER_ACTIVITY, callingPackage,
                       callingUid, userId, null, null, 0, new Intent[]{intent},
                       new String[]{resolvedType}, PendingIntent.FLAG_CANCEL_CURRENT
                               | PendingIntent.FLAG_ONE_SHOT, null);

               final int flags = intent.getFlags();
               Intent newIntent = new Intent(Intent.ACTION_REVIEW_PERMISSIONS);
               newIntent.setFlags(flags
                       | Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS);
               newIntent.putExtra(Intent.EXTRA_PACKAGE_NAME, aInfo.packageName);
               newIntent.putExtra(Intent.EXTRA_INTENT, new IntentSender(target));
               if (resultRecord != null) {
                   newIntent.putExtra(Intent.EXTRA_RESULT_NEEDED, true);
               }
               intent = newIntent;

               resolvedType = null;
               callingUid = realCallingUid;
               callingPid = realCallingPid;

               rInfo = mSupervisor.resolveIntent(intent, resolvedType, userId, 0,
                       computeResolveFilterUid(
                               callingUid, realCallingUid, mRequest.filterCallingUid));
               aInfo = mSupervisor.resolveActivity(intent, rInfo, startFlags,
                       null /*profilerInfo*/);

               if (DEBUG_PERMISSIONS_REVIEW) {
                   Slog.i(TAG, "START u" + userId + " {" + intent.toShortString(true, true,
                           true, false) + "} from uid " + callingUid + " on display "
                           + (mSupervisor.mFocusedStack == null
                           ? DEFAULT_DISPLAY : mSupervisor.mFocusedStack.mDisplayId));
               }
           }
       }

       // If we have an ephemeral app, abort the process of launching the resolved intent.
       // Instead, launch the ephemeral installer. Once the installer is finished, it
       // starts either the intent we resolved here [on install error] or the ephemeral
       // app [on install success].
       if (rInfo != null && rInfo.auxiliaryInfo != null) {
           intent = createLaunchIntent(rInfo.auxiliaryInfo, ephemeralIntent,
                   callingPackage, verificationBundle, resolvedType, userId);
           resolvedType = null;
           callingUid = realCallingUid;
           callingPid = realCallingPid;

           aInfo = mSupervisor.resolveActivity(intent, rInfo, startFlags, null /*profilerInfo*/);
       }

       //创建activity记录对象
       ActivityRecord r = new ActivityRecord(mService, callerApp, callingPid, callingUid,
               callingPackage, intent, resolvedType, aInfo, mService.getGlobalConfiguration(),
               resultRecord, resultWho, requestCode, componentSpecified, voiceSession != null,
               mSupervisor, checkedOptions, sourceRecord);
       if (outActivity != null) {
           outActivity[0] = r;
       }

       if (r.appTimeTracker == null && sourceRecord != null) {
           // If the caller didn't specify an explicit time tracker, we want to continue
           // tracking under any it has.
           r.appTimeTracker = sourceRecord.appTimeTracker;
       }

       final ActivityStack stack = mSupervisor.mFocusedStack;

      
       // If we are starting an activity that is not from the same uid as the currently resumed
       // one, check whether app switches are allowed.
       if (voiceSession == null && (stack.getResumedActivity() == null
               || stack.getResumedActivity().info.applicationInfo.uid != realCallingUid)) {
           //如果前台stack还没有resume状态的activity，则检查app是否允许切换，见2.8.1
           if (!mService.checkAppSwitchAllowedLocked(callingPid, callingUid,
                   realCallingPid, realCallingUid, "Activity start")) {
                //如果不允许切换，则把要启动的activity添加到PendingActivity，并且返回
               mController.addPendingActivityLaunch(new PendingActivityLaunch(r,
                       sourceRecord, startFlags, stack, callerApp));
               ActivityOptions.abort(checkedOptions);
               return ActivityManager.START_SWITCHES_CANCELED;
           }
       }
        
       if (mService.mDidAppSwitch) {
           //从第一次app切换到第二次允许app,允许切换时间设置为0，则表示可以任意切换app
           // This is the second allowed switch since we stopped switches,
           // so now just generally allow switches.  Use case: user presses
           // home (switches disabled, switch to home, mDidAppSwitch now true);
           // user taps a home icon (coming from home so allowed, we hit here
           // and now allow anyone to switch again).
           mService.mAppSwitchesAllowedTime = 0;
       } else {
           mService.mDidAppSwitch = true;
       }

       //处理PendingActivity的启动，由于app switch禁用从而被hold的等待的activity，见2.8.2
       mController.doPendingActivityLaunches(false);

       maybeLogActivityStart(callingUid, callingPackage, realCallingUid, intent, callerApp, r,
               originatingPendingIntent);
       //再走startActivity
       return startActivity(r, sourceRecord, voiceSession, voiceInteractor, startFlags,
               true /* doResume */, checkedOptions, inTask, outActivity);
   }

在上面这三个返回值表示启动activity失败

START_INTENT_NOT_RESOLVED：从intent中无法找到相应的component
START_CLASS_NOT_FOUND ：从intent中无法找到相应的ActivityInfo
START_NOT_VOICE_COMPATIBLE :不支持voice task

private int startActivity(final ActivityRecord r, ActivityRecord sourceRecord,
                IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
                int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
                ActivityRecord[] outActivity) {
        int result = START_CANCELED;
        try {
            mService.mWindowManager.deferSurfaceLayout();
            //见2.9节
            result = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor,
                    startFlags, doResume, options, inTask, outActivity);
        } finally {
            //不能启动则取消task关联
            // If we are not able to proceed, disassociate the activity from the task. Leaving an
            // activity in an incomplete state can lead to issues, such as performing operations
            // without a window container.
            final ActivityStack stack = mStartActivity.getStack();
            if (!ActivityManager.isStartResultSuccessful(result) && stack != null) {
                stack.finishActivityLocked(mStartActivity, RESULT_CANCELED,
                        null /* intentResultData */, "startActivity", true /* oomAdj */);
            }
            mService.mWindowManager.continueSurfaceLayout();
        }
        postStartActivityProcessing(r, result, mTargetStack);
        return result;
    }

2.8.1 AMS.checkAppSwitchAllowedLocked

[->ActivityManagerService.java]

boolean checkAppSwitchAllowedLocked(int sourcePid, int sourceUid,
          int callingPid, int callingUid, String name) {
      if (mAppSwitchesAllowedTime < SystemClock.uptimeMillis()) {
          return true;
      }
      if (mRecentTasks.isCallerRecents(sourceUid)) {
          return true;
      }
      int perm = checkComponentPermission(STOP_APP_SWITCHES, sourcePid, sourceUid, -1, true);
      if (perm == PackageManager.PERMISSION_GRANTED) {
          return true;
      }
      if (checkAllowAppSwitchUid(sourceUid)) {
          return true;
      }
      // If the actual IPC caller is different from the logical source, then
      // also see if they are allowed to control app switches.
      if (callingUid != -1 && callingUid != sourceUid) {
          perm = checkComponentPermission(STOP_APP_SWITCHES, callingPid, callingUid, -1, true);
          if (perm == PackageManager.PERMISSION_GRANTED) {
              return true;
          }
          if (checkAllowAppSwitchUid(callingUid)) {
              return true;
          }
      }
      Slog.w(TAG, name + " request from " + sourceUid + " stopped");
      return false;
  }

当mAppSwitchesAllowedTime时间小于当前时间或者具有STOP_APP_SWITCHES的权限，则允许app发生切换操作。 其中mAppSwitchesAllowedTime在AMS.stopAppSwitches的过程中会设置， mAppSwitchesAllowedTime = SystemClock.uptimeMillis()+APP_SWITCH_DELAY_TIME(=5s); 禁止app切换的timeout时间为5s。

当发送5s超时或者执行ASM.resumeAppSwitches过程会将mAppSwitchesAllowedTime 设置为0，都会开启允许app执行切换的操作。禁止app切换的操作，对于同一个app是不受影响的，可查看AMS.checkComponentPermission

2.8.1 ASC.doPendingActivityLaunches

[->ActivityStartController.java]

void doPendingActivityLaunches(boolean doResume) {
      while (!mPendingActivityLaunches.isEmpty()) {
          final PendingActivityLaunch pal = mPendingActivityLaunches.remove(0);
          final boolean resume = doResume && mPendingActivityLaunches.isEmpty();
          final ActivityStarter starter = obtainStarter(null /* intent */,
                  "pendingActivityLaunch");
          try {
              starter.startResolvedActivity(pal.r, pal.sourceRecord, null, null, pal.startFlags,
                      resume, null, null, null /* outRecords */);
          } catch (Exception e) {
              Slog.e(TAG, "Exception during pending activity launch pal=" + pal, e);
              pal.sendErrorResult(e.getMessage());
          }
      }
  }

mPendingActivityLaunches记录所有将要启动的Activity，由于在startActivity过程中时app切换功能被禁止，也就是不运行切换的Activity，就会将该Activity加入到mPendingActivityLaunches队列，该队列执行完doPendingActivityLaunches会清空。启动doPendingActivityLaunches的所有Activity，由于doResume=false，那么activity不会进入resume，而是设置delayedResume = true,延迟resume。

2.9 AS.startActivityUnchecked

[->ActivityStarter.java]

//r是本次要启动的activity，sourceRecord是调用者
// Note: This method should only be called from {@link startActivity}.
  private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
          IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
          int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
          ActivityRecord[] outActivity) {
      //设置初始化状态，见2.9.1
      setInitialState(r, options, inTask, doResume, startFlags, sourceRecord, voiceSession,
              voiceInteractor);
      //确定启动taskflag，见2.9.2
      computeLaunchingTaskFlags();
      //确定调用者栈，见2.9.3
      computeSourceStack();

      mIntent.setFlags(mLaunchFlags);

      //得到可用的ActivityRecord
      ActivityRecord reusedActivity = getReusableIntentActivity();

      int preferredWindowingMode = WINDOWING_MODE_UNDEFINED;
      int preferredLaunchDisplayId = DEFAULT_DISPLAY;
      if (mOptions != null) {
          preferredWindowingMode = mOptions.getLaunchWindowingMode();
          preferredLaunchDisplayId = mOptions.getLaunchDisplayId();
      }

      // windowing mode and preferred launch display values from {@link LaunchParams} take
      // priority over those specified in {@link ActivityOptions}.
      if (!mLaunchParams.isEmpty()) {
          if (mLaunchParams.hasPreferredDisplay()) {
              preferredLaunchDisplayId = mLaunchParams.mPreferredDisplayId;
          }

          if (mLaunchParams.hasWindowingMode()) {
              preferredWindowingMode = mLaunchParams.mWindowingMode;
          }
      }

      if (reusedActivity != null) {
          //LockTask mode 且设置了NEW_TASK and CLEAR_TASK则返回
          // When the flags NEW_TASK and CLEAR_TASK are set, then the task gets reused but
          // still needs to be a lock task mode violation since the task gets cleared out and
          // the device would otherwise leave the locked task.
          if (mService.getLockTaskController().isLockTaskModeViolation(reusedActivity.getTask(),
                  (mLaunchFlags & (FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_CLEAR_TASK))
                          == (FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_CLEAR_TASK))) {
              Slog.e(TAG, "startActivityUnchecked: Attempt to violate Lock Task Mode");
              return START_RETURN_LOCK_TASK_MODE_VIOLATION;
          }

          // True if we are clearing top and resetting of a standard (default) launch mode
          // ({@code LAUNCH_MULTIPLE}) activity. The existing activity will be finished.
          final boolean clearTopAndResetStandardLaunchMode =
                  (mLaunchFlags & (FLAG_ACTIVITY_CLEAR_TOP | FLAG_ACTIVITY_RESET_TASK_IF_NEEDED))
                          == (FLAG_ACTIVITY_CLEAR_TOP | FLAG_ACTIVITY_RESET_TASK_IF_NEEDED)
                  && mLaunchMode == LAUNCH_MULTIPLE;

          //如果启动的activity没有管理task，则用存在activity的task
          // If mStartActivity does not have a task associated with it, associate it with the
          // reused activity's task. Do not do so if we're clearing top and resetting for a
          // standard launchMode activity.
          if (mStartActivity.getTask() == null && !clearTopAndResetStandardLaunchMode) {
              mStartActivity.setTask(reusedActivity.getTask());
          }

          if (reusedActivity.getTask().intent == null) {
              //设置mStartActivity
              // This task was started because of movement of the activity based on affinity...
              // Now that we are actually launching it, we can assign the base intent.
              reusedActivity.getTask().setIntent(mStartActivity);
          }

          // This code path leads to delivering a new intent, we want to make sure we schedule it
          // as the first operation, in case the activity will be resumed as a result of later
          // operations.
          if ((mLaunchFlags & FLAG_ACTIVITY_CLEAR_TOP) != 0
                  || isDocumentLaunchesIntoExisting(mLaunchFlags)
                  || isLaunchModeOneOf(LAUNCH_SINGLE_INSTANCE, LAUNCH_SINGLE_TASK)) {
              final TaskRecord task = reusedActivity.getTask();
              //LAUNCH_SINGLE_INSTANCE,LAUNCH_SINGLE_TASK模式下，栈移除所有的activity
              // In this situation we want to remove all activities from the task up to the one
              // being started. In most cases this means we are resetting the task to its initial
              // state.
              final ActivityRecord top = task.performClearTaskForReuseLocked(mStartActivity,
                      mLaunchFlags);

              // The above code can remove {@code reusedActivity} from the task, leading to the
              // the {@code ActivityRecord} removing its reference to the {@code TaskRecord}. The
              // task reference is needed in the call below to
              // {@link setTargetStackAndMoveToFrontIfNeeded}.
              if (reusedActivity.getTask() == null) {
                  reusedActivity.setTask(task);
              }

              if (top != null) {
                  //在前台
                  if (top.frontOfTask) {
                      // Activity aliases may mean we use different intents for the top activity,
                      // so make sure the task now has the identity of the new intent.
                      top.getTask().setIntent(mStartActivity);
                  }
                  deliverNewIntent(top);
              }
          }

          mSupervisor.sendPowerHintForLaunchStartIfNeeded(false /* forceSend */, reusedActivity);

          reusedActivity = setTargetStackAndMoveToFrontIfNeeded(reusedActivity);

          final ActivityRecord outResult =
                  outActivity != null && outActivity.length > 0 ? outActivity[0] : null;

          // When there is a reused activity and the current result is a trampoline activity,
          // set the reused activity as the result.
          if (outResult != null && (outResult.finishing || outResult.noDisplay)) {
              outActivity[0] = reusedActivity;
          }

          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!  And for paranoia, make sure we have
              // correctly resumed the top activity.
              resumeTargetStackIfNeeded();
              return START_RETURN_INTENT_TO_CALLER;
          }

          if (reusedActivity != null) {
              setTaskFromIntentActivity(reusedActivity);

              if (!mAddingToTask && mReuseTask == null) {
                  // We didn't do anything...  but it was needed (a.k.a., client don't use that
                  // intent!)  And for paranoia, make sure we have correctly resumed the top activity.

                  resumeTargetStackIfNeeded();
                  if (outActivity != null && outActivity.length > 0) {
                      outActivity[0] = reusedActivity;
                  }

                  return mMovedToFront ? START_TASK_TO_FRONT : START_DELIVERED_TO_TOP;
              }
          }
      }
      
      //启动的activity没有包名，直接返回
      if (mStartActivity.packageName == null) {
          final ActivityStack sourceStack = mStartActivity.resultTo != null
                  ? mStartActivity.resultTo.getStack() : null;
          if (sourceStack != null) {
              sourceStack.sendActivityResultLocked(-1 /* callingUid */, mStartActivity.resultTo,
                      mStartActivity.resultWho, mStartActivity.requestCode, RESULT_CANCELED,
                      null /* data */);
          }
          ActivityOptions.abort(mOptions);
          return START_CLASS_NOT_FOUND;
      }

      // If the activity being launched is the same as the one currently at the top, then
      // we need to check if it should only be launched once.
      final ActivityStack topStack = mSupervisor.mFocusedStack;
      final ActivityRecord topFocused = topStack.getTopActivity();
      final ActivityRecord top = topStack.topRunningNonDelayedActivityLocked(mNotTop);
      final boolean dontStart = top != null && mStartActivity.resultTo == null
              && top.realActivity.equals(mStartActivity.realActivity)
              && top.userId == mStartActivity.userId
              && top.app != null && top.app.thread != null
              && ((mLaunchFlags & FLAG_ACTIVITY_SINGLE_TOP) != 0
              || isLaunchModeOneOf(LAUNCH_SINGLE_TOP, LAUNCH_SINGLE_TASK));        
      if (dontStart) {
          // 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;
          }
          //触发onNewIntent
          deliverNewIntent(top);

          // 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(), preferredWindowingMode,
                  preferredLaunchDisplayId, topStack);

          return START_DELIVERED_TO_TOP;
      }

      boolean newTask = false;
      final TaskRecord taskToAffiliate = (mLaunchTaskBehind && mSourceRecord != null)
              ? mSourceRecord.getTask() : null;

      // Should this be considered a new task?
      int result = START_SUCCESS;
      if (mStartActivity.resultTo == null && mInTask == null && !mAddingToTask
              && (mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) != 0) {
          newTask = true;
          result = setTaskFromReuseOrCreateNewTask(taskToAffiliate, 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;
      }

      mService.grantUriPermissionFromIntentLocked(mCallingUid, mStartActivity.packageName,
              mIntent, mStartActivity.getUriPermissionsLocked(), mStartActivity.userId);
      mService.grantEphemeralAccessLocked(mStartActivity.userId, mIntent,
              mStartActivity.appInfo.uid, UserHandle.getAppId(mCallingUid));
      if (newTask) {
          EventLog.writeEvent(EventLogTags.AM_CREATE_TASK, mStartActivity.userId,
                  mStartActivity.getTask().taskId);
      }
      ActivityStack.logStartActivity(
              EventLogTags.AM_CREATE_ACTIVITY, mStartActivity, mStartActivity.getTask());
      mTargetStack.mLastPausedActivity = null;

      mSupervisor.sendPowerHintForLaunchStartIfNeeded(false /* forceSend */, mStartActivity);
      //见2.10节
      mTargetStack.startActivityLocked(mStartActivity, topFocused, newTask, mKeepCurTransition,
              mOptions);
      if (mDoResume) {
          final ActivityRecord topTaskActivity =
                  mStartActivity.getTask().topRunningActivityLocked();
          if (!mTargetStack.isFocusable()
                  || (topTaskActivity != null && topTaskActivity.mTaskOverlay
                  && mStartActivity != topTaskActivity)) {
              // 没有获取焦点，不能resume   
              // If the activity is not focusable, we can't resume it, but still would like to
              // make sure it becomes visible as it starts (this will also trigger entry
              // animation). An example of this are PIP activities.
              // Also, we don't want to resume activities in a task that currently has an overlay
              // as the starting activity just needs to be in the visible paused state until the
              // over is removed.
              mTargetStack.ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
              // Go ahead and tell window manager to execute app transition for this activity
              // since the app transition will not be triggered through the resume channel.
              mService.mWindowManager.executeAppTransition();
          } else {
              // If the target stack was not previously focusable (previous top running activity
              // on that stack was not visible) then any prior calls to move the stack to the
              // will not update the focused stack.  If starting the new activity now allows the
              // task stack to be focusable, then ensure that we now update the focused stack
              // accordingly.
              if (mTargetStack.isFocusable() && !mSupervisor.isFocusedStack(mTargetStack)) {
                  mTargetStack.moveToFront("startActivityUnchecked");
              }
              //见2.11节
              mSupervisor.resumeFocusedStackTopActivityLocked(mTargetStack, mStartActivity,
                      mOptions);
          }
      } else if (mStartActivity != null) {
          mSupervisor.mRecentTasks.add(mStartActivity.getTask());
      }
      mSupervisor.updateUserStackLocked(mStartActivity.userId, mTargetStack);

      mSupervisor.handleNonResizableTaskIfNeeded(mStartActivity.getTask(), preferredWindowingMode,
              preferredLaunchDisplayId, mTargetStack);

      return START_SUCCESS;
  }

找到或者创建新的Activity所属的Task对象，之后调用AS.startActivityLocked

2.9.1 AS.setInitialState

[->ActivityStarter.java]

private void setInitialState(ActivityRecord r, ActivityOptions options, TaskRecord inTask,
            boolean doResume, int startFlags, ActivityRecord sourceRecord,
            IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor) {
        reset(false /* clearRequest */);

        mStartActivity = r;
        mIntent = r.intent;
        mOptions = options;
        mCallingUid = r.launchedFromUid;
        mSourceRecord = sourceRecord;
        mVoiceSession = voiceSession;
        mVoiceInteractor = voiceInteractor;

        mPreferredDisplayId = getPreferedDisplayId(mSourceRecord, mStartActivity, options);

        mLaunchParams.reset();

        mSupervisor.getLaunchParamsController().calculate(inTask, null /*layout*/, r, sourceRecord,
                options, mLaunchParams);

        mLaunchMode = r.launchMode;
        //当intent和Activity manifest存在冲突，则manifest优先
        mLaunchFlags = adjustLaunchFlagsToDocumentMode(
                r, LAUNCH_SINGLE_INSTANCE == mLaunchMode,
                LAUNCH_SINGLE_TASK == mLaunchMode, mIntent.getFlags());
        mLaunchTaskBehind = r.mLaunchTaskBehind
                && !isLaunchModeOneOf(LAUNCH_SINGLE_TASK, LAUNCH_SINGLE_INSTANCE)
                && (mLaunchFlags & FLAG_ACTIVITY_NEW_DOCUMENT) != 0;

        sendNewTaskResultRequestIfNeeded();
   
        if ((mLaunchFlags & FLAG_ACTIVITY_NEW_DOCUMENT) != 0 && r.resultTo == null) {
            mLaunchFlags |= FLAG_ACTIVITY_NEW_TASK;
        }

        // If we are actually going to launch in to a new task, there are some cases where
        // we further want to do multiple task.
        if ((mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) != 0) {
            if (mLaunchTaskBehind
                    || r.info.documentLaunchMode == DOCUMENT_LAUNCH_ALWAYS) {
                mLaunchFlags |= FLAG_ACTIVITY_MULTIPLE_TASK;
            }
        }

        // We'll invoke onUserLeaving before onPause only if the launching
        // activity did not explicitly state that this is an automated launch.
        mSupervisor.mUserLeaving = (mLaunchFlags & FLAG_ACTIVITY_NO_USER_ACTION) == 0;
        if (DEBUG_USER_LEAVING) Slog.v(TAG_USER_LEAVING,
                "startActivity() => mUserLeaving=" + mSupervisor.mUserLeaving);
        //当本次不需要resume时，则设置为延迟resume的状态
        // If the caller has asked not to resume at this point, we make note
        // of this in the record so that we can skip it when trying to find
        // the top running activity.
        mDoResume = doResume;
        if (!doResume || !r.okToShowLocked()) {
            r.delayedResume = true;
            mDoResume = false;
        }

        if (mOptions != null) {
            if (mOptions.getLaunchTaskId() != -1 && mOptions.getTaskOverlay()) {
                r.mTaskOverlay = true;
                if (!mOptions.canTaskOverlayResume()) {
                    final TaskRecord task = mSupervisor.anyTaskForIdLocked(
                            mOptions.getLaunchTaskId());
                    final ActivityRecord top = task != null ? task.getTopActivity() : null;
                    if (top != null && !top.isState(RESUMED)) {

                        // The caller specifies that we'd like to be avoided to be moved to the
                        // front, so be it!
                        mDoResume = false;
                        mAvoidMoveToFront = true;
                    }
                }
            } else if (mOptions.getAvoidMoveToFront()) {
                mDoResume = false;
                mAvoidMoveToFront = true;
            }
        }

        mNotTop = (mLaunchFlags & FLAG_ACTIVITY_PREVIOUS_IS_TOP) != 0 ? r : null;

        mInTask = inTask;
        // In some flows in to this function, we retrieve the task record and hold on to it
        // without a lock before calling back in to here...  so the task at this point may
        // not actually be in recents.  Check for that, and if it isn't in recents just
        // consider it invalid.
        if (inTask != null && !inTask.inRecents) {
            Slog.w(TAG, "Starting activity in task not in recents: " + inTask);
            mInTask = null;
        }

        mStartFlags = startFlags;
        // If the onlyIfNeeded flag is set, then we can do this if the activity being launched
        // is the same as the one making the call...  or, as a special case, if we do not know
        // the caller then we count the current top activity as the caller.
        if ((startFlags & START_FLAG_ONLY_IF_NEEDED) != 0) {
            ActivityRecord checkedCaller = sourceRecord;
            if (checkedCaller == null) {
                checkedCaller = mSupervisor.mFocusedStack.topRunningNonDelayedActivityLocked(
                        mNotTop);
            }
            if (!checkedCaller.realActivity.equals(r.realActivity)) {
                //调用者与将要启动的activity不相同时今日该分支
                // Caller is not the same as launcher, so always needed.
                mStartFlags &= ~START_FLAG_ONLY_IF_NEEDED;
            }
        }

        mNoAnimation = (mLaunchFlags & FLAG_ACTIVITY_NO_ANIMATION) != 0;
    }

2.9.2 AS.computeLaunchingTaskFlags

[->ActivityStarter.java]

private void computeLaunchingTaskFlags() {
        //当调用者不是来自于activity，而是指定明确task的情况
        // If the caller is not coming from another activity, but has given us an explicit task into
        // which they would like us to launch the new activity, then let's see about doing that.
        if (mSourceRecord == null && mInTask != null && mInTask.getStack() != null) {
            final Intent baseIntent = mInTask.getBaseIntent();
            final ActivityRecord root = mInTask.getRootActivity();
            if (baseIntent == null) {
                ActivityOptions.abort(mOptions);
                throw new IllegalArgumentException("Launching into task without base intent: "
                        + mInTask);
            }

            // If this task is empty, then we are adding the first activity -- it
            // determines the root, and must be launching as a NEW_TASK.
            if (isLaunchModeOneOf(LAUNCH_SINGLE_INSTANCE, LAUNCH_SINGLE_TASK)) {
                if (!baseIntent.getComponent().equals(mStartActivity.intent.getComponent())) {
                    ActivityOptions.abort(mOptions);
                    throw new IllegalArgumentException("Trying to launch singleInstance/Task "
                            + mStartActivity + " into different task " + mInTask);
                }
                if (root != null) {
                    ActivityOptions.abort(mOptions);
                    throw new IllegalArgumentException("Caller with mInTask " + mInTask
                            + " has root " + root + " but target is singleInstance/Task");
                }
            }

            // If task is empty, then adopt the interesting intent launch flags in to the
            // activity being started.
            if (root == null) {
                final int flagsOfInterest = FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_MULTIPLE_TASK
                        | FLAG_ACTIVITY_NEW_DOCUMENT | FLAG_ACTIVITY_RETAIN_IN_RECENTS;
                mLaunchFlags = (mLaunchFlags & ~flagsOfInterest)
                        | (baseIntent.getFlags() & flagsOfInterest);
                mIntent.setFlags(mLaunchFlags);
                mInTask.setIntent(mStartActivity);
                mAddingToTask = true;

                // If the task is not empty and the caller is asking to start it as the root of
                // a new task, then we don't actually want to start this on the task. We will
                // bring the task to the front, and possibly give it a new intent.
            } else if ((mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) != 0) {
                mAddingToTask = false;

            } else {
                mAddingToTask = true;
            }

            mReuseTask = mInTask;
        } else {
            mInTask = null;
            // Launch ResolverActivity in the source task, so that it stays in the task bounds
            // when in freeform workspace.
            // Also put noDisplay activities in the source task. These by itself can be placed
            // in any task/stack, however it could launch other activities like ResolverActivity,
            // and we want those to stay in the original task.
            if ((mStartActivity.isResolverActivity() || mStartActivity.noDisplay) && mSourceRecord != null
                    && mSourceRecord.inFreeformWindowingMode())  {
                mAddingToTask = true;
            }
        }

        if (mInTask == null) {
            if (mSourceRecord == null) {
                //调用者不是Activity context,则强制创建新task
                // This activity is not being started from another...  in this
                // case we -always- start a new task.
                if ((mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) == 0 && mInTask == null) {
                    Slog.w(TAG, "startActivity called from non-Activity context; forcing " +
                            "Intent.FLAG_ACTIVITY_NEW_TASK for: " + mIntent);
                    mLaunchFlags |= FLAG_ACTIVITY_NEW_TASK;
                }
            } else if (mSourceRecord.launchMode == LAUNCH_SINGLE_INSTANCE) {
                 //调用者启动模式是single instance，则创建新task
                // The original activity who is starting us is running as a single
                // instance...  this new activity it is starting must go on its
                // own task.
                mLaunchFlags |= FLAG_ACTIVITY_NEW_TASK;
            } else if (isLaunchModeOneOf(LAUNCH_SINGLE_INSTANCE, LAUNCH_SINGLE_TASK)) {
                //目标activity带有single instance或者single task则创建新的task
                // The activity being started is a single instance...  it always
                // gets launched into its own task.
                mLaunchFlags |= FLAG_ACTIVITY_NEW_TASK;
            }
        }
    }

2.9.3 AS.computeSourceStack

[->ActivityStarter.java]

private void computeSourceStack() {
       if (mSourceRecord == null) {
           mSourceStack = null;
           return;
       }
       if (!mSourceRecord.finishing) {
          //当调用者activity不为空，且不在finishing状态，则其所在的栈赋于sourceStack
           mSourceStack = mSourceRecord.getStack();
           return;
       }
       //当调用者处于finishing状态，则创建新的task
       // If the source is finishing, we can't further count it as our source. This is because the
       // task it is associated with may now be empty and on its way out, so we don't want to
       // blindly throw it in to that task.  Instead we will take the NEW_TASK flow and try to find
       // a task for it. But save the task information so it can be used when creating the new task.
       if ((mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) == 0) {
           Slog.w(TAG, "startActivity called from finishing " + mSourceRecord
                   + "; forcing " + "Intent.FLAG_ACTIVITY_NEW_TASK for: " + mIntent);
           mLaunchFlags |= FLAG_ACTIVITY_NEW_TASK;
           mNewTaskInfo = mSourceRecord.info;

           // It is not guaranteed that the source record will have a task associated with it. For,
           // example, if this method is being called for processing a pending activity launch, it
           // is possible that the activity has been removed from the task after the launch was
           // enqueued.
           final TaskRecord sourceTask = mSourceRecord.getTask();
           mNewTaskIntent = sourceTask != null ? sourceTask.intent : null;
       }
       mSourceRecord = null;
       mSourceStack = null;
   }

2.9.4 AS.getReusableIntentActivity

[->ActivityStarter.java]

/**
     * Decide whether the new activity should be inserted into an existing task. Returns null
     * if not or an ActivityRecord with the task into which the new activity should be added.
     */
    private ActivityRecord getReusableIntentActivity() {
        // We may want to try to place the new activity in to an existing task.  We always
        // do this if the target activity is singleTask or singleInstance; we will also do
        // this if NEW_TASK has been requested, and there is not an additional qualifier telling
        // us to still place it in a new task: multi task, always doc mode, or being asked to
        // launch this as a new task behind the current one.
        boolean putIntoExistingTask = ((mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) != 0 &&
                (mLaunchFlags & FLAG_ACTIVITY_MULTIPLE_TASK) == 0)
                || isLaunchModeOneOf(LAUNCH_SINGLE_INSTANCE, LAUNCH_SINGLE_TASK);
        // If bring to front is requested, and no result is requested and we have not been given
        // an explicit task to launch in to, and we can find a task that was started with this
        // same component, then instead of launching bring that one to the front.
        putIntoExistingTask &= mInTask == null && mStartActivity.resultTo == null;
        ActivityRecord intentActivity = null;
        if (mOptions != null && mOptions.getLaunchTaskId() != -1) {
            final TaskRecord task = mSupervisor.anyTaskForIdLocked(mOptions.getLaunchTaskId());
            intentActivity = task != null ? task.getTopActivity() : null;
        } else if (putIntoExistingTask) {
            if (LAUNCH_SINGLE_INSTANCE == mLaunchMode) {
                // There can be one and only one instance of single instance activity in the
                // history, and it is always in its own unique task, so we do a special search.
               intentActivity = mSupervisor.findActivityLocked(mIntent, mStartActivity.info,
                       mStartActivity.isActivityTypeHome());
            } else if ((mLaunchFlags & FLAG_ACTIVITY_LAUNCH_ADJACENT) != 0) {
                // For the launch adjacent case we only want to put the activity in an existing
                // task if the activity already exists in the history.
                intentActivity = mSupervisor.findActivityLocked(mIntent, mStartActivity.info,
                        !(LAUNCH_SINGLE_TASK == mLaunchMode));
            } else {
                // Otherwise find the best task to put the activity in.
                intentActivity = mSupervisor.findTaskLocked(mStartActivity, mPreferredDisplayId);
            }
        }
        return intentActivity;
    }

上面是根据不同的启动模式，来获取ActivityRecord信息，来决定将要启动的activity所在的栈。

2.9.5 Launch Mode

AcitivityInfo.java定义了四类Launch Mode:

/**
 * Constant corresponding to <code>standard</code> in
 * the {@link android.R.attr#launchMode} attribute.
 */
//每次启动新Activity，都会创建新的Activity，这是最常见标准情形
public static final int LAUNCH_MULTIPLE = 0;
/**
 * Constant corresponding to <code>singleTop</code> in
 * the {@link android.R.attr#launchMode} attribute.
 */
//当启动新Activity，如果栈顶存在相同Activity，则不会创建新的Activity  
public static final int LAUNCH_SINGLE_TOP = 1;
/**
 * Constant corresponding to <code>singleTask</code> in
 * the {@link android.R.attr#launchMode} attribute.
 */
//当启动Activity，在栈中存在相同Activity，则不会创建新的Activity
//而是移除该Activity之上的所有Activity
public static final int LAUNCH_SINGLE_TASK = 2;
/**
 * Constant corresponding to <code>singleInstance</code> in
 * the {@link android.R.attr#launchMode} attribute.
 */
 //每个Task栈只有一个Activity
public static final int LAUNCH_SINGLE_INSTANCE = 3;

常见的flag含义

FLAG_ACTIVITY_NEW_TASK

将新Activity放入新启动的task。

FLAG_ACTIVITY_CLEAR_TASK

启动Activity时，将目标Activity关联的task清除，再启动新task,将该Activity放入该Task。这个flag一般配置FLAG_ACTIVITY_NEW_TASK使用。

FLAG_ACTIVITY_CLEAR_TOP

启动非栈顶Activity时，先清除该Activity之上的Activity. 例如Task已有A,B,C,D，启动A,则需要先清除B,C,D，类似SingleTop。

2.10 AS.startActivityLocked

[->ActivityStack.java]

void startActivityLocked(ActivityRecord r, ActivityRecord focusedTopActivity,
           boolean newTask, boolean keepCurTransition, ActivityOptions options) {
       TaskRecord rTask = r.getTask();
       final int taskId = rTask.taskId;
       // mLaunchTaskBehind tasks get placed at the back of the task stack.
       if (!r.mLaunchTaskBehind && (taskForIdLocked(taskId) == null || newTask)) {
           // Last activity in task had been removed or ActivityManagerService is reusing task.
           // Insert or replace.
           // Might not even be in.
           //task中上一个activity被移除，或者ams重用task,则将该task移到顶部
           insertTaskAtTop(rTask, r);
       }
       TaskRecord task = null;
       if (!newTask) {
           // If starting in an existing task, find where that is...
           boolean startIt = true;
           for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
               task = mTaskHistory.get(taskNdx);
               if (task.getTopActivity() == null) {
                   // All activities in task are finishing.
                   //该task所有activity都finishing
                   continue;
               }
               if (task == rTask) {
                   // Here it is!  Now, if this is not yet visible to the
                   // user, then just add it without starting; it will
                   // get started when the user navigates back to it.
                   if (!startIt) {
                       if (DEBUG_ADD_REMOVE) Slog.i(TAG, "Adding activity " + r + " to task "
                               + task, new RuntimeException("here").fillInStackTrace());
                       r.createWindowContainer();
                       ActivityOptions.abort(options);
                       return;
                   }
                   break;
               } else if (task.numFullscreen > 0) {
                   startIt = false;
               }
           }
       }

       // Place a new activity at top of stack, so it is next to interact with the user.

       // If we are not placing the new activity frontmost, we do not want to deliver the
       // onUserLeaving callback to the actual frontmost activity
       final TaskRecord activityTask = r.getTask();
       if (task == activityTask && mTaskHistory.indexOf(task) != (mTaskHistory.size() - 1)) {
           mStackSupervisor.mUserLeaving = false;
           if (DEBUG_USER_LEAVING) Slog.v(TAG_USER_LEAVING,
                   "startActivity() behind front, mUserLeaving=false");
       }

       task = activityTask;

       // Slot the activity into the history stack and proceed
       if (DEBUG_ADD_REMOVE) Slog.i(TAG, "Adding activity " + r + " to stack to task " + task,
               new RuntimeException("here").fillInStackTrace());
       // TODO: Need to investigate if it is okay for the controller to already be created by the
       // time we get to this point. I think it is, but need to double check.
       // Use test in b/34179495 to trace the call path.
       if (r.getWindowContainerController() == null) {
           r.createWindowContainer();
       }
       task.setFrontOfTask();
      //当切换到新的task或者下一个activity进程目前没有运行
       if (!isHomeOrRecentsStack() || numActivities() > 0) {
           if (DEBUG_TRANSITION) Slog.v(TAG_TRANSITION,
                   "Prepare open transition: starting " + r);
           if ((r.intent.getFlags() & Intent.FLAG_ACTIVITY_NO_ANIMATION) != 0) {
               mWindowManager.prepareAppTransition(TRANSIT_NONE, keepCurTransition);
               mStackSupervisor.mNoAnimActivities.add(r);
           } else {
               int transit = TRANSIT_ACTIVITY_OPEN;
               if (newTask) {
                   if (r.mLaunchTaskBehind) {
                       transit = TRANSIT_TASK_OPEN_BEHIND;
                   } else {
                       // If a new task is being launched, then mark the existing top activity as
                       // supporting picture-in-picture while pausing only if the starting activity
                       // would not be considered an overlay on top of the current activity
                       // (eg. not fullscreen, or the assistant)
                       if (canEnterPipOnTaskSwitch(focusedTopActivity,
                               null /* toFrontTask */, r, options)) {
                           focusedTopActivity.supportsEnterPipOnTaskSwitch = true;
                       }
                       transit = TRANSIT_TASK_OPEN;
                   }
               }
               mWindowManager.prepareAppTransition(transit, keepCurTransition);
               mStackSupervisor.mNoAnimActivities.remove(r);
           }
           boolean doShow = true;
           if (newTask) {
               // Even though this activity is starting fresh, we still need
               // to reset it to make sure we apply affinities to move any
               // existing activities from other tasks in to it.
               // If the caller has requested that the target task be
               // reset, then do so.
               if ((r.intent.getFlags() & Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED) != 0) {
                   resetTaskIfNeededLocked(r, r);
                   doShow = topRunningNonDelayedActivityLocked(null) == r;
               }
           } else if (options != null && options.getAnimationType()
                   == ActivityOptions.ANIM_SCENE_TRANSITION) {
               doShow = false;
           }
           if (r.mLaunchTaskBehind) {
               // Don't do a starting window for mLaunchTaskBehind. More importantly make sure we
               // tell WindowManager that r is visible even though it is at the back of the stack.
               r.setVisibility(true);
               ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
           } else if (SHOW_APP_STARTING_PREVIEW && doShow) {
               // Figure out if we are transitioning from another activity that is
               // "has the same starting icon" as the next one.  This allows the
               // window manager to keep the previous window it had previously
               // created, if it still had one.
               TaskRecord prevTask = r.getTask();
               ActivityRecord prev = prevTask.topRunningActivityWithStartingWindowLocked();
               if (prev != null) {
                  //当前activity属于不同的task
                   // We don't want to reuse the previous starting preview if:
                   // (1) The current activity is in a different task.
                   if (prev.getTask() != prevTask) {
                       prev = null;
                   }
                   //当前activity已经display
                   // (2) The current activity is already displayed.
                   else if (prev.nowVisible) {
                       prev = null;
                   }
               }
               r.showStartingWindow(prev, newTask, isTaskSwitch(r, focusedTopActivity));
           }
       } else {
           // If this is the first activity, don't do any fancy animations,
           // because there is nothing for it to animate on top of.
           ActivityOptions.abort(options);
       }
   }

2.11 ASS.resumeFocusedStackTopActivityLocked

[->ActivityStackSupervisor.java]

boolean resumeFocusedStackTopActivityLocked(
           ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {

       if (!readyToResume()) {
           return false;
       }

       if (targetStack != null && isFocusedStack(targetStack)) {
           return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
       }

       final ActivityRecord r = mFocusedStack.topRunningActivityLocked();
       if (r == null || !r.isState(RESUMED)) {
           mFocusedStack.resumeTopActivityUncheckedLocked(null, null);
       } else if (r.isState(RESUMED)) {
           // Kick off any lingering app transitions form the MoveTaskToFront operation.
           mFocusedStack.executeAppTransition(targetOptions);
       }

       return false;
   }

2.12 AS.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;
          //见2.13节
          result = resumeTopActivityInnerLocked(prev, options);

          // When resuming the top activity, it may be necessary to pause the top activity (for
          // example, returning to the lock screen. We suppress the normal pause logic in
          // {@link #resumeTopActivityUncheckedLocked}, since the top activity is resumed at the
          // end. We call the {@link ActivityStackSupervisor#checkReadyForSleepLocked} again here
          // to ensure any necessary pause logic occurs. In the case where the Activity will be
          // shown regardless of the lock screen, the call to
          // {@link ActivityStackSupervisor#checkReadyForSleepLocked} is skipped.
          final ActivityRecord next = topRunningActivityLocked(true /* focusableOnly */);
          if (next == null || !next.canTurnScreenOn()) {
              checkReadyForSleep();
          }
      } finally {
          mStackSupervisor.inResumeTopActivity = false;
      }

      return result;
  }

2.13 AS.resumeTopActivityInnerLocked

[->ActivityStack.java]

@GuardedBy("mService")
   private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
       //系统没有进入booting或者booted状态被，则不允许启动Activity
       if (!mService.mBooting && !mService.mBooted) {
           // Not ready yet!
           return false;
       }

       //找到top-most activity没有finishing的栈顶activity
       // Find the next top-most activity to resume in this stack that is not finishing and is
       // focusable. If it is not focusable, we will fall into the case below to resume the
       // top activity in the next focusable task.
       final ActivityRecord next = topRunningActivityLocked(true /* focusableOnly */);

       final boolean hasRunningActivity = next != null;

       // TODO: Maybe this entire condition can get removed?
       if (hasRunningActivity && !isAttached()) {
           return false;
       }
       //top running之后的任意处于初始化状态且有显示startingWindow,则移除startingWindow
       mStackSupervisor.cancelInitializingActivities();

       // Remember how we'll process this pause/resume situation, and ensure
       // that the state is reset however we wind up proceeding.
       boolean userLeaving = mStackSupervisor.mUserLeaving;
       mStackSupervisor.mUserLeaving = false;

       if (!hasRunningActivity) {
           //见2.13.1节
           // There are no activities left in the stack, let's look somewhere else.
           return resumeTopActivityInNextFocusableStack(prev, options, "noMoreActivities");
       }

       next.delayedResume = false;
       //已经resume的情况
       // If the top activity is the resumed one, nothing to do.
       if (mResumedActivity == next && next.isState(RESUMED)
               && mStackSupervisor.allResumedActivitiesComplete()) {
           // Make sure we have executed any pending transitions, since there
           // should be nothing left to do at this point.
           executeAppTransition(options);
           if (DEBUG_STATES) Slog.d(TAG_STATES,
                   "resumeTopActivityLocked: Top activity resumed " + next);
           if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
           return false;
       }
       //处于睡眠或者关机状态，top activity已经暂停的情况
       // If we are sleeping, and there is no resumed activity, and the top
       // activity is paused, well that is the state we want.
       if (shouldSleepOrShutDownActivities()
               && mLastPausedActivity == next
               && mStackSupervisor.allPausedActivitiesComplete()) {
           // Make sure we have executed any pending transitions, since there
           // should be nothing left to do at this point.
           executeAppTransition(options);
           if (DEBUG_STATES) Slog.d(TAG_STATES,
                   "resumeTopActivityLocked: Going to sleep and all paused");
           if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
           return false;
       }
       //拥有该activity的用户没有启动则直接返回
       // Make sure that the user who owns this activity is started.  If not,
       // we will just leave it as is because someone should be bringing
       // another user's activities to the top of the stack.
       if (!mService.mUserController.hasStartedUserState(next.userId)) {
           Slog.w(TAG, "Skipping resume of top activity " + next
                   + ": user " + next.userId + " is stopped");
           if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
           return false;
       }
       
       // The activity may be waiting for stop, but that is no longer
       // appropriate for it.
       mStackSupervisor.mStoppingActivities.remove(next);
       mStackSupervisor.mGoingToSleepActivities.remove(next);
       next.sleeping = false;
       mStackSupervisor.mActivitiesWaitingForVisibleActivity.remove(next);

       if (DEBUG_SWITCH) Slog.v(TAG_SWITCH, "Resuming " + next);
       //当处于暂停activity，则直接返回
       // If we are currently pausing an activity, then don't do anything until that is done.
       if (!mStackSupervisor.allPausedActivitiesComplete()) {
           if (DEBUG_SWITCH || DEBUG_PAUSE || DEBUG_STATES) Slog.v(TAG_PAUSE,
                   "resumeTopActivityLocked: Skip resume: some activity pausing.");
           if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
           return false;
       }

       mStackSupervisor.setLaunchSource(next.info.applicationInfo.uid);

       boolean lastResumedCanPip = false;
       ActivityRecord lastResumed = null;
       final ActivityStack lastFocusedStack = mStackSupervisor.getLastStack();
       if (lastFocusedStack != null && lastFocusedStack != this) {
           // So, why aren't we using prev here??? See the param comment on the method. prev doesn't
           // represent the last resumed activity. However, the last focus stack does if it isn't null.
           lastResumed = lastFocusedStack.mResumedActivity;
           //多窗口模式判断
           if (userLeaving && inMultiWindowMode() && lastFocusedStack.shouldBeVisible(next)) {
               // The user isn't leaving if this stack is the multi-window mode and the last
               // focused stack should still be visible.
               if(DEBUG_USER_LEAVING) Slog.i(TAG_USER_LEAVING, "Overriding userLeaving to false"
                       + " next=" + next + " lastResumed=" + lastResumed);
               userLeaving = false;
           }
           lastResumedCanPip = lastResumed != null && lastResumed.checkEnterPictureInPictureState(
                   "resumeTopActivity", userLeaving /* beforeStopping */);
       }
       //要等待暂停当前activity完成，再resume top activity
       // If the flag RESUME_WHILE_PAUSING is set, then continue to schedule the previous activity
       // to be paused, while at the same time resuming the new resume activity only if the
       // previous activity can't go into Pip since we want to give Pip activities a chance to
       // enter Pip before resuming the next activity.
       final boolean resumeWhilePausing = (next.info.flags & FLAG_RESUME_WHILE_PAUSING) != 0
               && !lastResumedCanPip;
       
       //暂停其他Activity，见13.2节
       boolean pausing = mStackSupervisor.pauseBackStacks(userLeaving, next, false);
       if (mResumedActivity != null) {
           if (DEBUG_STATES) Slog.d(TAG_STATES,
                   "resumeTopActivityLocked: Pausing " + mResumedActivity);
           //当resume状态activity不为空，则需要暂停该Activity
           pausing |= startPausingLocked(userLeaving, false, next, false);
       }
       if (pausing && !resumeWhilePausing) {
           if (DEBUG_SWITCH || DEBUG_STATES) Slog.v(TAG_STATES,
                   "resumeTopActivityLocked: Skip resume: need to start pausing");
           // At this point we want to put the upcoming activity's process
           // at the top of the LRU list, since we know we will be needing it
           // very soon and it would be a waste to let it get killed if it
           // happens to be sitting towards the end.
           if (next.app != null && next.app.thread != null) {
               mService.updateLruProcessLocked(next.app, true, null);
           }
           if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
           if (lastResumed != null) {
               lastResumed.setWillCloseOrEnterPip(true);
           }
           return true;
       } else if (mResumedActivity == next && next.isState(RESUMED)
               && mStackSupervisor.allResumedActivitiesComplete()) {
           // It is possible for the activity to be resumed when we paused back stacks above if the
           // next activity doesn't have to wait for pause to complete.
           // So, nothing else to-do except:
           // Make sure we have executed any pending transitions, since there
           // should be nothing left to do at this point.
           executeAppTransition(options);
           if (DEBUG_STATES) Slog.d(TAG_STATES,
                   "resumeTopActivityLocked: Top activity resumed (dontWaitForPause) " + next);
           if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
           return true;
       }

       // If the most recent activity was noHistory but was only stopped rather
       // than stopped+finished because the device went to sleep, we need to make
       // sure to finish it as we're making a new activity topmost.
       if (shouldSleepActivities() && mLastNoHistoryActivity != null &&
               !mLastNoHistoryActivity.finishing) {
           if (DEBUG_STATES) Slog.d(TAG_STATES,
                   "no-history finish of " + mLastNoHistoryActivity + " on new resume");
           requestFinishActivityLocked(mLastNoHistoryActivity.appToken, Activity.RESULT_CANCELED,
                   null, "resume-no-history", false);
           mLastNoHistoryActivity = null;
       }

       if (prev != null && prev != next) {
           if (!mStackSupervisor.mActivitiesWaitingForVisibleActivity.contains(prev)
                   && next != null && !next.nowVisible
                   && checkKeyguardVisibility(next, true /* shouldBeVisible */,
                           next.isTopRunningActivity())) {
               mStackSupervisor.mActivitiesWaitingForVisibleActivity.add(prev);
               if (DEBUG_SWITCH) Slog.v(TAG_SWITCH,
                       "Resuming top, waiting visible to hide: " + prev);
           } else {
               // The next activity is already visible, so hide the previous
               // activity's windows right now so we can show the new one ASAP.
               // We only do this if the previous is finishing, which should mean
               // it is on top of the one being resumed so hiding it quickly
               // is good.  Otherwise, we want to do the normal route of allowing
               // the resumed activity to be shown so we can decide if the
               // previous should actually be hidden depending on whether the
               // new one is found to be full-screen or not.
               if (prev.finishing) {
                   prev.setVisibility(false);
                   if (DEBUG_SWITCH) Slog.v(TAG_SWITCH,
                           "Not waiting for visible to hide: " + prev + ", waitingVisible="
                           + mStackSupervisor.mActivitiesWaitingForVisibleActivity.contains(prev)
                           + ", nowVisible=" + next.nowVisible);
               } else {
                   if (DEBUG_SWITCH) Slog.v(TAG_SWITCH,
                           "Previous already visible but still waiting to hide: " + prev
                           + ", waitingVisible="
                           + mStackSupervisor.mActivitiesWaitingForVisibleActivity.contains(prev)
                           + ", nowVisible=" + next.nowVisible);
               }
           }
       }

       // Launching this app's activity, make sure the app is no longer
       // considered stopped.
       try {
           AppGlobals.getPackageManager().setPackageStoppedState(
                   next.packageName, false, next.userId); /* TODO: Verify if correct userid */
       } catch (RemoteException e1) {
       } catch (IllegalArgumentException e) {
           Slog.w(TAG, "Failed trying to unstop package "
                   + next.packageName + ": " + e);
       }

       // We are starting up the next activity, so tell the window manager
       // that the previous one will be hidden soon.  This way it can know
       // to ignore it when computing the desired screen orientation.
       boolean anim = true;
       if (prev != null) {
           if (prev.finishing) {
               if (DEBUG_TRANSITION) Slog.v(TAG_TRANSITION,
                       "Prepare close transition: prev=" + prev);
               if (mStackSupervisor.mNoAnimActivities.contains(prev)) {
                   anim = false;
                   mWindowManager.prepareAppTransition(TRANSIT_NONE, false);
               } else {
                   mWindowManager.prepareAppTransition(prev.getTask() == next.getTask()
                           ? TRANSIT_ACTIVITY_CLOSE
                           : TRANSIT_TASK_CLOSE, false);
               }
               prev.setVisibility(false);
           } else {
               if (DEBUG_TRANSITION) Slog.v(TAG_TRANSITION,
                       "Prepare open transition: prev=" + prev);
               if (mStackSupervisor.mNoAnimActivities.contains(next)) {
                   anim = false;
                   mWindowManager.prepareAppTransition(TRANSIT_NONE, false);
               } else {
                   mWindowManager.prepareAppTransition(prev.getTask() == next.getTask()
                           ? TRANSIT_ACTIVITY_OPEN
                           : next.mLaunchTaskBehind
                                   ? TRANSIT_TASK_OPEN_BEHIND
                                   : TRANSIT_TASK_OPEN, false);
               }
           }
       } else {
           if (DEBUG_TRANSITION) Slog.v(TAG_TRANSITION, "Prepare open transition: no previous");
           if (mStackSupervisor.mNoAnimActivities.contains(next)) {
               anim = false;
               mWindowManager.prepareAppTransition(TRANSIT_NONE, false);
           } else {
               mWindowManager.prepareAppTransition(TRANSIT_ACTIVITY_OPEN, false);
           }
       }

       if (anim) {
           next.applyOptionsLocked();
       } else {
           next.clearOptionsLocked();
       }

       mStackSupervisor.mNoAnimActivities.clear();
       ActivityStack lastStack = mStackSupervisor.getLastStack();
       //进程存在的情况
       if (next.app != null && next.app.thread != null) {
           if (DEBUG_SWITCH) Slog.v(TAG_SWITCH, "Resume running: " + next
                   + " stopped=" + next.stopped + " visible=" + next.visible);

           // If the previous activity is translucent, force a visibility update of
           // the next activity, so that it's added to WM's opening app list, and
           // transition animation can be set up properly.
           // For example, pressing Home button with a translucent activity in focus.
           // Launcher is already visible in this case. If we don't add it to opening
           // apps, maybeUpdateTransitToWallpaper() will fail to identify this as a
           // TRANSIT_WALLPAPER_OPEN animation, and run some funny animation.
           final boolean lastActivityTranslucent = lastStack != null
                   && (lastStack.inMultiWindowMode()
                   || (lastStack.mLastPausedActivity != null
                   && !lastStack.mLastPausedActivity.fullscreen));

           // The contained logic must be synchronized, since we are both changing the visibility
           // and updating the {@link Configuration}. {@link ActivityRecord#setVisibility} will
           // ultimately cause the client code to schedule a layout. Since layouts retrieve the
           // current {@link Configuration}, we must ensure that the below code updates it before
           // the layout can occur.
           synchronized(mWindowManager.getWindowManagerLock()) {
               //设置activity可见
               // This activity is now becoming visible.
               if (!next.visible || next.stopped || lastActivityTranslucent) {
                   next.setVisibility(true);
               }

               // schedule launch ticks to collect information about slow apps.
               next.startLaunchTickingLocked();

               ActivityRecord lastResumedActivity =
                       lastStack == null ? null :lastStack.mResumedActivity;
               final ActivityState lastState = next.getState();

               mService.updateCpuStats();

               if (DEBUG_STATES) Slog.v(TAG_STATES, "Moving to RESUMED: " + next
                       + " (in existing)");
              //设置activity resume
               next.setState(RESUMED, "resumeTopActivityInnerLocked");

               mService.updateLruProcessLocked(next.app, true, null);
               updateLRUListLocked(next);
               mService.updateOomAdjLocked();

               // Have the window manager re-evaluate the orientation of
               // the screen based on the new activity order.
               boolean notUpdated = true;

               if (mStackSupervisor.isFocusedStack(this)) {
                   // We have special rotation behavior when here is some active activity that
                   // requests specific orientation or Keyguard is locked. Make sure all activity
                   // visibilities are set correctly as well as the transition is updated if needed
                   // to get the correct rotation behavior. Otherwise the following call to update
                   // the orientation may cause incorrect configurations delivered to client as a
                   // result of invisible window resize.
                   // TODO: Remove this once visibilities are set correctly immediately when
                   // starting an activity.
                   notUpdated = !mStackSupervisor.ensureVisibilityAndConfig(next, mDisplayId,
                           true /* markFrozenIfConfigChanged */, false /* deferResume */);
               }

               if (notUpdated) {
                   // The configuration update wasn't able to keep the existing
                   // instance of the activity, and instead started a new one.
                   // We should be all done, but let's just make sure our activity
                   // is still at the top and schedule another run if something
                   // weird happened.
                   ActivityRecord nextNext = topRunningActivityLocked();
                   if (DEBUG_SWITCH || DEBUG_STATES) Slog.i(TAG_STATES,
                           "Activity config changed during resume: " + next
                                   + ", new next: " + nextNext);
                   if (nextNext != next) {
                       // Do over!
                       mStackSupervisor.scheduleResumeTopActivities();
                   }
                   if (!next.visible || next.stopped) {
                       next.setVisibility(true);
                   }
                   next.completeResumeLocked();
                   if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
                   return true;
               }

               try {
                   //分发所有pending结果
                   final ClientTransaction transaction = ClientTransaction.obtain(next.app.thread,
                           next.appToken);
                   // Deliver all pending results.
                   ArrayList<ResultInfo> a = next.results;
                   if (a != null) {
                       final int N = a.size();
                       if (!next.finishing && N > 0) {
                           if (DEBUG_RESULTS) Slog.v(TAG_RESULTS,
                                   "Delivering results to " + next + ": " + a);
                           transaction.addCallback(ActivityResultItem.obtain(a));
                       }
                   }

                   if (next.newIntents != null) {
                       transaction.addCallback(NewIntentItem.obtain(next.newIntents,
                               false /* andPause */));
                   }

                   // Well the app will no longer be stopped.
                   // Clear app token stopped state in window manager if needed.
                   next.notifyAppResumed(next.stopped);

                   EventLog.writeEvent(EventLogTags.AM_RESUME_ACTIVITY, next.userId,
                           System.identityHashCode(next), next.getTask().taskId,
                           next.shortComponentName);

                   next.sleeping = false;
                   mService.getAppWarningsLocked().onResumeActivity(next);
                   mService.showAskCompatModeDialogLocked(next);
                   next.app.pendingUiClean = true;
                   next.app.forceProcessStateUpTo(mService.mTopProcessState);
                   next.clearOptionsLocked();
                   //处罚onResume
                   transaction.setLifecycleStateRequest(
                           ResumeActivityItem.obtain(next.app.repProcState,
                                   mService.isNextTransitionForward()));
                   mService.getLifecycleManager().scheduleTransaction(transaction);

                   if (DEBUG_STATES) Slog.d(TAG_STATES, "resumeTopActivityLocked: Resumed "
                           + next);
               } catch (Exception e) {
                   // Whoops, need to restart this activity!
                   if (DEBUG_STATES) Slog.v(TAG_STATES, "Resume failed; resetting state to "
                           + lastState + ": " + next);
                   next.setState(lastState, "resumeTopActivityInnerLocked");

                   // lastResumedActivity being non-null implies there is a lastStack present.
                   if (lastResumedActivity != null) {
                       lastResumedActivity.setState(RESUMED, "resumeTopActivityInnerLocked");
                   }

                   Slog.i(TAG, "Restarting because process died: " + next);
                   if (!next.hasBeenLaunched) {
                       next.hasBeenLaunched = true;
                   } else  if (SHOW_APP_STARTING_PREVIEW && lastStack != null
                           && lastStack.isTopStackOnDisplay()) {
                       next.showStartingWindow(null /* prev */, false /* newTask */,
                               false /* taskSwitch */);
                   }
                   mStackSupervisor.startSpecificActivityLocked(next, true, false);
                   if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
                   return true;
               }
           }

           // From this point on, if something goes wrong there is no way
           // to recover the activity.
           try {
               next.completeResumeLocked();
           } catch (Exception e) {
               // If any exception gets thrown, toss away this
               // activity and try the next one.
               Slog.w(TAG, "Exception thrown during resume of " + next, e);
               requestFinishActivityLocked(next.appToken, Activity.RESULT_CANCELED, null,
                       "resume-exception", true);
               if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
               return true;
           }
       } else {
           //需要重新启动Activity
           // Whoops, need to restart this activity!
           if (!next.hasBeenLaunched) {
               next.hasBeenLaunched = true;
           } else {
               if (SHOW_APP_STARTING_PREVIEW) {
                   next.showStartingWindow(null /* prev */, false /* newTask */,
                           false /* taskSwich */);
               }
               if (DEBUG_SWITCH) Slog.v(TAG_SWITCH, "Restarting: " + next);
           }
           if (DEBUG_STATES) Slog.d(TAG_STATES, "resumeTopActivityLocked: Restarting " + next);
           //见2.14节
           mStackSupervisor.startSpecificActivityLocked(next, true, true);
       }

       if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
       return true;
   }

主要工作如下：

• 当找不到resume的activity时，则直接回到桌面
• 当resume状态activity不为空,则执行startPausingLocked,暂停该Activity
• 当Activity之前启动过，则直接resume，否则执行startSpecificActivityLocked，2.14节将继续讨论。

2.13.1 AS.resumeTopActivityInNextFocusableStack

[->ActivityStack.java]

private boolean resumeTopActivityInNextFocusableStack(ActivityRecord prev,
           ActivityOptions options, String reason) {
       if (adjustFocusToNextFocusableStack(reason)) {
           //如果该栈没有全屏，则尝试下一个可见的stack
           // Try to move focus to the next visible stack with a running activity if this
           // stack is not covering the entire screen or is on a secondary display (with no home
           // stack).
           return mStackSupervisor.resumeFocusedStackTopActivityLocked(
                   mStackSupervisor.getFocusedStack(), prev, null);
       }

       // Let's just start up the Launcher...
       ActivityOptions.abort(options);
       if (DEBUG_STATES) Slog.d(TAG_STATES,
               "resumeTopActivityInNextFocusableStack: " + reason + ", go home");
       if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
       // Only resume home if on home display
       //启动桌面activity
       return isOnHomeDisplay() &&
               mStackSupervisor.resumeHomeStackTask(prev, reason);
   }

当找不到需要的resume的Activity时，直接回到桌面

2.13.2 AS.pauseBackStacks

[->ActivityStack.java]

/**
    * Pause all activities in either all of the stacks or just the back stacks.
    * @param userLeaving Passed to pauseActivity() to indicate whether to call onUserLeaving().
    * @param resuming The resuming activity.
    * @param dontWait The resuming activity isn't going to wait for all activities to be paused
    *                 before resuming.
    * @return true if any activity was paused as a result of this call.
    */
   boolean pauseBackStacks(boolean userLeaving, ActivityRecord resuming, boolean dontWait) {
       boolean someActivityPaused = false;
       for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
           final ActivityDisplay display = mActivityDisplays.valueAt(displayNdx);
           for (int stackNdx = display.getChildCount() - 1; stackNdx >= 0; --stackNdx) {
               final ActivityStack stack = display.getChildAt(stackNdx);
               if (!isFocusedStack(stack) && stack.getResumedActivity() != null) {
                   if (DEBUG_STATES) Slog.d(TAG_STATES, "pauseBackStacks: stack=" + stack +
                           " mResumedActivity=" + stack.getResumedActivity());
                   //见2.13.2节
                   someActivityPaused |= stack.startPausingLocked(userLeaving, false, resuming,
                           dontWait);
               }
           }
       }
       return someActivityPaused;
   }

暂停所有处于后台栈的所有Activity

2.13.3 AS.startPausingLocked

[->ActivityStack.java]

final boolean startPausingLocked(boolean userLeaving, boolean uiSleeping,
            ActivityRecord resuming, boolean pauseImmediately) {
        if (mPausingActivity != null) {
            Slog.wtf(TAG, "Going to pause when pause is already pending for " + mPausingActivity
                    + " state=" + mPausingActivity.getState());
            if (!shouldSleepActivities()) {
                // Avoid recursion among check for sleep and complete pause during sleeping.
                // Because activity will be paused immediately after resume, just let pause
                // be completed by the order of activity paused from clients.
                completePauseLocked(false, resuming);
            }
        }
        ActivityRecord prev = mResumedActivity;

        if (prev == null) {
            if (resuming == null) {
                Slog.wtf(TAG, "Trying to pause when nothing is resumed");
                mStackSupervisor.resumeFocusedStackTopActivityLocked();
            }
            return false;
        }

        if (prev == resuming) {
            Slog.wtf(TAG, "Trying to pause activity that is in process of being resumed");
            return false;
        }

        if (DEBUG_STATES) Slog.v(TAG_STATES, "Moving to PAUSING: " + prev);
        else if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Start pausing: " + prev);
        mPausingActivity = prev;
        mLastPausedActivity = prev;
        mLastNoHistoryActivity = (prev.intent.getFlags() & Intent.FLAG_ACTIVITY_NO_HISTORY) != 0
                || (prev.info.flags & ActivityInfo.FLAG_NO_HISTORY) != 0 ? prev : null;
        prev.setState(PAUSING, "startPausingLocked");
        prev.getTask().touchActiveTime();
        clearLaunchTime(prev);

        mStackSupervisor.getActivityMetricsLogger().stopFullyDrawnTraceIfNeeded();

        mService.updateCpuStats();

        if (prev.app != null && prev.app.thread != null) {
            if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Enqueueing pending pause: " + prev);
            try {
                EventLogTags.writeAmPauseActivity(prev.userId, System.identityHashCode(prev),
                        prev.shortComponentName, "userLeaving=" + userLeaving);
                mService.updateUsageStats(prev, false);
                //暂停目标Activity
                mService.getLifecycleManager().scheduleTransaction(prev.app.thread, prev.appToken,
                        PauseActivityItem.obtain(prev.finishing, userLeaving,
                                prev.configChangeFlags, pauseImmediately));
            } catch (Exception e) {
                // Ignore exception, if process died other code will cleanup.
                Slog.w(TAG, "Exception thrown during pause", e);
                mPausingActivity = null;
                mLastPausedActivity = null;
                mLastNoHistoryActivity = null;
            }
        } else {
            mPausingActivity = null;
            mLastPausedActivity = null;
            mLastNoHistoryActivity = null;
        }

        // If we are not going to sleep, we want to ensure the device is
        // awake until the next activity is started.
        if (!uiSleeping && !mService.isSleepingOrShuttingDownLocked()) {
            mStackSupervisor.acquireLaunchWakelock();
        }

        if (mPausingActivity != null) {
            // Have the window manager pause its key dispatching until the new
            // activity has started.  If we're pausing the activity just because
            // the screen is being turned off and the UI is sleeping, don't interrupt
            // key dispatch; the same activity will pick it up again on wakeup.
            if (!uiSleeping) {
                prev.pauseKeyDispatchingLocked();
            } else if (DEBUG_PAUSE) {
                 Slog.v(TAG_PAUSE, "Key dispatch not paused for screen off");
            }

            if (pauseImmediately) {
                // If the caller said they don't want to wait for the pause, then complete
                // the pause now.
                completePauseLocked(false, resuming);
                return false;

            } else {
                //500ms,执行暂停超时的消息
                schedulePauseTimeout(prev);
                return true;
            }

        } else {
            // This activity failed to schedule the
            // pause, so just treat it as being paused now.
            if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Activity not running, resuming next.");
            if (resuming == null) {  //调度失败，则认为暂停结束开始执行resume操作
                mStackSupervisor.resumeFocusedStackTopActivityLocked();
            }
            return false;
        }
    }

通过LifecycleManager的方式来暂停Activity操作。对于pauseImmediately= true则执行completePauseLocked操作，否则等待app通知500ms超时再执行该方法。

2.13.4 AS.completePauseLocked

[->ActivityStack.java]

private void completePauseLocked(boolean resumeNext, ActivityRecord resuming) {
       ActivityRecord prev = mPausingActivity;
       if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Complete pause: " + prev);

       if (prev != null) {
           prev.setWillCloseOrEnterPip(false);
           final boolean wasStopping = prev.isState(STOPPING);
           prev.setState(PAUSED, "completePausedLocked");
           if (prev.finishing) {
               if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Executing finish of activity: " + prev);
               prev = finishCurrentActivityLocked(prev, FINISH_AFTER_VISIBLE, false,
                       "completedPausedLocked");
           } else if (prev.app != null) {
               if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Enqueue pending stop if needed: " + prev
                       + " wasStopping=" + wasStopping + " visible=" + prev.visible);
               if (mStackSupervisor.mActivitiesWaitingForVisibleActivity.remove(prev)) {
                   if (DEBUG_SWITCH || DEBUG_PAUSE) Slog.v(TAG_PAUSE,
                           "Complete pause, no longer waiting: " + prev);
               }
               if (prev.deferRelaunchUntilPaused) {
                   // Complete the deferred relaunch that was waiting for pause to complete.
                   if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Re-launching after pause: " + prev);
                   prev.relaunchActivityLocked(false /* andResume */,
                           prev.preserveWindowOnDeferredRelaunch);
               } else if (wasStopping) {
                   // We are also stopping, the stop request must have gone soon after the pause.
                   // We can't clobber it, because the stop confirmation will not be handled.
                   // We don't need to schedule another stop, we only need to let it happen.
                   prev.setState(STOPPING, "completePausedLocked");
               } else if (!prev.visible || shouldSleepOrShutDownActivities()) {
                   // Clear out any deferred client hide we might currently have.
                   prev.setDeferHidingClient(false);
                   // If we were visible then resumeTopActivities will release resources before
                   // stopping.
                   addToStopping(prev, true /* scheduleIdle */, false /* idleDelayed */);
               }
           } else {
               if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "App died during pause, not stopping: " + prev);
               prev = null;
           }
           // It is possible the activity was freezing the screen before it was paused.
           // In that case go ahead and remove the freeze this activity has on the screen
           // since it is no longer visible.
           if (prev != null) {
               prev.stopFreezingScreenLocked(true /*force*/);
           }
           mPausingActivity = null;
       }

       if (resumeNext) {
           final ActivityStack topStack = mStackSupervisor.getFocusedStack();
           if (!topStack.shouldSleepOrShutDownActivities()) {
               mStackSupervisor.resumeFocusedStackTopActivityLocked(topStack, prev, null);
           } else {
               checkReadyForSleep();
               ActivityRecord top = topStack.topRunningActivityLocked();
               if (top == null || (prev != null && top != prev)) {
                   // If there are no more activities available to run, do resume anyway to start
                   // something. Also if the top activity on the stack is not the just paused
                   // activity, we need to go ahead and resume it to ensure we complete an
                   // in-flight app switch.
                   mStackSupervisor.resumeFocusedStackTopActivityLocked();
               }
           }
       }

       if (prev != null) {
           prev.resumeKeyDispatchingLocked();

           if (prev.app != null && prev.cpuTimeAtResume > 0
                   && mService.mBatteryStatsService.isOnBattery()) {
               long diff = mService.mProcessCpuTracker.getCpuTimeForPid(prev.app.pid)
                       - prev.cpuTimeAtResume;
               if (diff > 0) {
                   BatteryStatsImpl bsi = mService.mBatteryStatsService.getActiveStatistics();
                   synchronized (bsi) {
                       BatteryStatsImpl.Uid.Proc ps =
                               bsi.getProcessStatsLocked(prev.info.applicationInfo.uid,
                                       prev.info.packageName);
                       if (ps != null) {
                           ps.addForegroundTimeLocked(diff);
                       }
                   }
               }
           }
           prev.cpuTimeAtResume = 0; // reset it
       }

       // Notify when the task stack has changed, but only if visibilities changed (not just
       // focus). Also if there is an active pinned stack - we always want to notify it about
       // task stack changes, because its positioning may depend on it.
       if (mStackSupervisor.mAppVisibilitiesChangedSinceLastPause
               || getDisplay().hasPinnedStack()) {
           mService.mTaskChangeNotificationController.notifyTaskStackChanged();
           mStackSupervisor.mAppVisibilitiesChangedSinceLastPause = false;
       }

       mStackSupervisor.ensureActivitiesVisibleLocked(resuming, 0, !PRESERVE_WINDOWS);
   }

暂停Activity完成后，修改暂停activity状态

2.14 ASS.startSpecificActivityLocked

[->ActivityStackSupervisor.java]

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);

       if (app != null && app.thread != null) {
           try {
               if ((r.info.flags&ActivityInfo.FLAG_MULTIPROCESS) == 0
                       || !"android".equals(r.info.packageName)) {
                   // Don't add this if it is a platform component that is marked
                   // to run in multiple processes, because this is actually
                   // part of the framework so doesn't make sense to track as a
                   // separate apk in the process.
                   app.addPackage(r.info.packageName, r.info.applicationInfo.longVersionCode,
                           mService.mProcessStats);
               }
               //真正启动Activity，见2.18节
               realStartActivityLocked(r, app, andResume, checkConfig);
               return;
           } catch (RemoteException e) {
               Slog.w(TAG, "Exception when starting activity "
                       + r.intent.getComponent().flattenToShortString(), e);
           }

           // If a dead object exception was thrown -- fall through to
           // restart the application.
       }
       //当进程不存在，则创建进程
       mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,
               "activity", r.intent.getComponent(), false, false, true);
   }

2.15 AMS.startProcessLocked

这个过程为启动Android进程的过程，在文章Android进程启动过程解析，详细描述了startProcessLocked整个过程，创建完成新进程之后，在新进程中通过binder ipc方式后调用到AMS.attachApplicationLocked。

[->ActivityManagerService.java]

private final boolean attachApplicationLocked(IApplicationThread thread,
         int pid, int callingUid, long startSeq) {
        ...
         if (app.isolatedEntryPoint != null) {
             // This is an isolated process which should just call an entry point instead of
             // being bound to an application.
             thread.runIsolatedEntryPoint(app.isolatedEntryPoint, app.isolatedEntryPointArgs);
         } else if (app.instr != null) {
             thread.bindApplication(processName, appInfo, providers,
                     app.instr.mClass,
                     profilerInfo, app.instr.mArguments,
                     app.instr.mWatcher,
                     app.instr.mUiAutomationConnection, testMode,
                     mBinderTransactionTrackingEnabled, enableTrackAllocation,
                     isRestrictedBackupMode || !normalMode, app.persistent,
                     new Configuration(getGlobalConfiguration()), app.compat,
                     getCommonServicesLocked(app.isolated),
                     mCoreSettingsObserver.getCoreSettingsLocked(),
                     buildSerial, isAutofillCompatEnabled);
         } else {
             thread.bindApplication(processName, appInfo, providers, null, profilerInfo,
                     null, null, null, testMode,
                     mBinderTransactionTrackingEnabled, enableTrackAllocation,
                     isRestrictedBackupMode || !normalMode, app.persistent,
                     new Configuration(getGlobalConfiguration()), app.compat,
                     getCommonServicesLocked(app.isolated),
                     mCoreSettingsObserver.getCoreSettingsLocked(),
                     buildSerial, isAutofillCompatEnabled);
         }
         ...
     // See if the top visible activity is waiting to run in this process...
     if (normalMode) {
         try {
             if (mStackSupervisor.attachApplicationLocked(app)) {
                 didSomething = true;
             }
         } catch (Exception e) {
             Slog.wtf(TAG, "Exception thrown launching activities in " + app, e);
             badApp = true;
         }
     }
}

在bindApplication后，调用了ASS.attachApplicationLocked。

2.16 ASS.attachApplicationLocked

[->ActivityStackSupervisor.java]

boolean attachApplicationLocked(ProcessRecord app) throws RemoteException {
       final String processName = app.processName;
       boolean didSomething = false;
       for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
           final ActivityDisplay display = mActivityDisplays.valueAt(displayNdx);
           for (int stackNdx = display.getChildCount() - 1; stackNdx >= 0; --stackNdx) {
               final ActivityStack stack = display.getChildAt(stackNdx);
               if (!isFocusedStack(stack)) {
                   continue;
               }
               stack.getAllRunningVisibleActivitiesLocked(mTmpActivityList);
               //获取前台栈顶第一个非finishing的Activity
               final ActivityRecord top = stack.topRunningActivityLocked();
               final int size = mTmpActivityList.size();
               for (int i = 0; i < size; i++) {
                   final ActivityRecord activity = mTmpActivityList.get(i);
                   if (activity.app == null && app.uid == activity.info.applicationInfo.uid
                           && processName.equals(activity.processName)) {
                       try {
                           //真正启动Activity，见2.15节
                           if (realStartActivityLocked(activity, app,
                                   top == activity /* andResume */, true /* checkConfig */)) {
                               didSomething = true;
                           }
                       } catch (RemoteException e) {
                           Slog.w(TAG, "Exception in new application when starting activity "
                                   + top.intent.getComponent().flattenToShortString(), e);
                           throw e;
                       }
                   }
               }
           }
       }
       if (!didSomething) {
           //启动Activity不成功，确保有可见的Activity
           ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
       }
       return didSomething;
   }

2.17 ASS.realStartActivityLocked

[->ActivityStackSupervisor.java]

final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
          boolean andResume, boolean checkConfig) throws RemoteException {

      if (!allPausedActivitiesComplete()) {
          //如果Activity没有pausing完成则返回
          // While there are activities pausing we skipping starting any new activities until
          // pauses are complete. NOTE: that we also do this for activities that are starting in
          // the paused state because they will first be resumed then paused on the client side.
          if (DEBUG_SWITCH || DEBUG_PAUSE || DEBUG_STATES) Slog.v(TAG_PAUSE,
                  "realStartActivityLocked: Skipping start of r=" + r
                  + " some activities pausing...");
          return false;
      }

      final TaskRecord task = r.getTask();
      final ActivityStack stack = task.getStack();

      beginDeferResume();

      try {
          r.startFreezingScreenLocked(app, 0);
          //启动tick，收集应用启动慢的信息
          // schedule launch ticks to collect information about slow apps.
          r.startLaunchTickingLocked();

          r.setProcess(app);

          if (getKeyguardController().isKeyguardLocked()) {
              r.notifyUnknownVisibilityLaunched();
          }
         
          // Have the window manager re-evaluate the orientation of the screen based on the new
          // activity order.  Note that as a result of this, it can call back into the activity
          // manager with a new orientation.  We don't care about that, because the activity is
          // not currently running so we are just restarting it anyway.
          if (checkConfig) {
              // Deferring resume here because we're going to launch new activity shortly.
              // We don't want to perform a redundant launch of the same record while ensuring
              // configurations and trying to resume top activity of focused stack.
              ensureVisibilityAndConfig(r, r.getDisplayId(),
                      false /* markFrozenIfConfigChanged */, true /* deferResume */);
          }

          if (r.getStack().checkKeyguardVisibility(r, true /* shouldBeVisible */,
                  true /* isTop */)) {
              // We only set the visibility to true if the activity is allowed to be visible
              // based on
              // keyguard state. This avoids setting this into motion in window manager that is
              // later cancelled due to later calls to ensure visible activities that set
              // visibility back to false.
              r.setVisibility(true);
          }

          final int applicationInfoUid =
                  (r.info.applicationInfo != null) ? r.info.applicationInfo.uid : -1;
          if ((r.userId != app.userId) || (r.appInfo.uid != applicationInfoUid)) {
              Slog.wtf(TAG,
                      "User ID for activity changing for " + r
                              + " appInfo.uid=" + r.appInfo.uid
                              + " info.ai.uid=" + applicationInfoUid
                              + " old=" + r.app + " new=" + app);
          }

          app.waitingToKill = null;
          r.launchCount++;
          r.lastLaunchTime = SystemClock.uptimeMillis();

          if (DEBUG_ALL) Slog.v(TAG, "Launching: " + r);

          int idx = app.activities.indexOf(r);
          if (idx < 0) {
              app.activities.add(r);
          }
          
          mService.updateLruProcessLocked(app, true, null);
          mService.updateOomAdjLocked();

          final LockTaskController lockTaskController = mService.getLockTaskController();
          if (task.mLockTaskAuth == LOCK_TASK_AUTH_LAUNCHABLE
                  || task.mLockTaskAuth == LOCK_TASK_AUTH_LAUNCHABLE_PRIV
                  || (task.mLockTaskAuth == LOCK_TASK_AUTH_WHITELISTED
                          && lockTaskController.getLockTaskModeState()
                                  == LOCK_TASK_MODE_LOCKED)) {
              lockTaskController.startLockTaskMode(task, false, 0 /* blank UID */);
          }

          try {
              if (app.thread == null) {
                  throw new RemoteException();
              }
              List<ResultInfo> results = null;
              List<ReferrerIntent> newIntents = null;
              if (andResume) {
                  // We don't need to deliver new intents and/or set results if activity is going
                  // to pause immediately after launch.
                  results = r.results;
                  newIntents = r.newIntents;
              }
              if (DEBUG_SWITCH) Slog.v(TAG_SWITCH,
                      "Launching: " + r + " icicle=" + r.icicle + " with results=" + results
                              + " newIntents=" + newIntents + " andResume=" + andResume);
              EventLog.writeEvent(EventLogTags.AM_RESTART_ACTIVITY, r.userId,
                      System.identityHashCode(r), task.taskId, r.shortComponentName);
              if (r.isActivityTypeHome()) {
                  //home进程是该栈的根进程
                  // Home process is the root process of the task.
                  mService.mHomeProcess = task.mActivities.get(0).app;
              }
              mService.notifyPackageUse(r.intent.getComponent().getPackageName(),
                      PackageManager.NOTIFY_PACKAGE_USE_ACTIVITY);
              r.sleeping = false;
              r.forceNewConfig = false;
              mService.getAppWarningsLocked().onStartActivity(r);
              mService.showAskCompatModeDialogLocked(r);
              r.compat = mService.compatibilityInfoForPackageLocked(r.info.applicationInfo);
              ProfilerInfo profilerInfo = null;
              if (mService.mProfileApp != null && mService.mProfileApp.equals(app.processName)) {
                  if (mService.mProfileProc == null || mService.mProfileProc == app) {
                      mService.mProfileProc = app;
                      ProfilerInfo profilerInfoSvc = mService.mProfilerInfo;
                      if (profilerInfoSvc != null && profilerInfoSvc.profileFile != null) {
                          if (profilerInfoSvc.profileFd != null) {
                              try {
                                  profilerInfoSvc.profileFd = profilerInfoSvc.profileFd.dup();
                              } catch (IOException e) {
                                  profilerInfoSvc.closeFd();
                              }
                          }

                          profilerInfo = new ProfilerInfo(profilerInfoSvc);
                      }
                  }
              }

              app.hasShownUi = true;
              app.pendingUiClean = true;
              //将该进程设置为前台进程PROCESS_STATE_TOP
              app.forceProcessStateUpTo(mService.mTopProcessState);
              // Because we could be starting an Activity in the system process this may not go
              // across a Binder interface which would create a new Configuration. Consequently
              // we have to always create a new Configuration here.

              final MergedConfiguration mergedConfiguration = new MergedConfiguration(
                      mService.getGlobalConfiguration(), r.getMergedOverrideConfiguration());
              r.setLastReportedConfiguration(mergedConfiguration);

              logIfTransactionTooLarge(r.intent, r.icicle);

              //创建Activity启动事务
              // Create activity launch transaction.
              final ClientTransaction clientTransaction = ClientTransaction.obtain(app.thread,
                      r.appToken);
              clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),
                      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, mService.isNextTransitionForward(),
                      profilerInfo));

              //设置目标事务的状态为onResume
              // Set desired final state.
              final ActivityLifecycleItem lifecycleItem;
              if (andResume) {
                  lifecycleItem = ResumeActivityItem.obtain(mService.isNextTransitionForward());
              } else {
                  lifecycleItem = PauseActivityItem.obtain();
              }
              clientTransaction.setLifecycleStateRequest(lifecycleItem);

              //通过transaciton方式开始activity生命周期，onCreate,onStart,onResume
              // Schedule transaction.
              mService.getLifecycleManager().scheduleTransaction(clientTransaction);


              if ((app.info.privateFlags & ApplicationInfo.PRIVATE_FLAG_CANT_SAVE_STATE) != 0
                      && mService.mHasHeavyWeightFeature) {
                  //处理heavy-weight进程
                  // This may be a heavy-weight process!  Note that the package
                  // manager will ensure that only activity can run in the main
                  // process of the .apk, which is the only thing that will be
                  // considered heavy-weight.
                  if (app.processName.equals(app.info.packageName)) {
                      if (mService.mHeavyWeightProcess != null
                              && mService.mHeavyWeightProcess != app) {
                          Slog.w(TAG, "Starting new heavy weight process " + app
                                  + " when already running "
                                  + mService.mHeavyWeightProcess);
                      }
                      mService.mHeavyWeightProcess = app;
                      Message msg = mService.mHandler.obtainMessage(
                              ActivityManagerService.POST_HEAVY_NOTIFICATION_MSG);
                      msg.obj = r;
                      mService.mHandler.sendMessage(msg);
                  }
              }

          } catch (RemoteException e) {
              if (r.launchFailed) {
                  //第二次启动失败，则结束该Activity
                  // This is the second time we failed -- finish activity
                  // and give up.
                  Slog.e(TAG, "Second failure launching "
                          + r.intent.getComponent().flattenToShortString()
                          + ", giving up", e);
                  mService.appDiedLocked(app);
                  stack.requestFinishActivityLocked(r.appToken, Activity.RESULT_CANCELED, null,
                          "2nd-crash", false);
                  return false;
              }
              //第一次启动失败，则重启进程
              // This is the first time we failed -- restart process and
              // retry.
              r.launchFailed = true;
              app.activities.remove(r);
              throw e;
          }
      } finally {
          endDeferResume();
      }

      r.launchFailed = false;
       //将该进程加入到mLruActivity队列顶部
      if (stack.updateLRUListLocked(r)) {
          Slog.w(TAG, "Activity " + r + " being launched, but already in LRU list");
      }

      // TODO(lifecycler): Resume or pause requests are done as part of launch transaction,
      // so updating the state should be done accordingly.
      if (andResume && readyToResume()) {
          // As part of the process of launching, ActivityThread also performs
          // a resume.
          stack.minimalResumeActivityLocked(r);
      } else {
          // This activity is not starting in the resumed state... which should look like we asked
          // it to pause+stop (but remain visible), and it has done so and reported back the
          // current icicle and other state.
          if (DEBUG_STATES) Slog.v(TAG_STATES,
                  "Moving to PAUSED: " + r + " (starting in paused state)");
          r.setState(PAUSED, "realStartActivityLocked");
      }

      // Launch the new version setup screen if needed.  We do this -after-
      // launching the initial activity (that is, home), so that it can have
      // a chance to initialize itself while in the background, making the
      // switch back to it faster and look better.
      if (isFocusedStack(stack)) {
          //当系统发生更新时，只会执行一次的用户向导
          mService.getActivityStartController().startSetupActivity();
      }

      // Update any services we are bound to that might care about whether
      // their client may have activities.
      if (r.app != null) {
          //更新所有与该Activity具有绑定关系的Service连接
          mService.mServices.updateServiceConnectionActivitiesLocked(r.app);
      }

      return true;
  }

Android9.0之后，引入了ClientLifecycleManager和ClientTransactionHandler来辅助管理Activity的生命周期。

一个生命周期都抽象出了一个对象。

onCreate (LaunchActivityItem),onResume(ResumeActivityItem),

onPause(PauseActivityItem)，onStop(StopActivityItem),onDestrory(DestroyActivityItem)

2.18 CLM.scheduleTransaction

[->ClientLifecycleManager.java]

将2.17节启动Activity生命周期的代码单独分析一下启动的过程

 //创建Activity启动事务
final ClientTransaction clientTransaction = ClientTransaction.obtain(app.thread,
        r.appToken);
//设置事务callback，状态为onCreate --->1        
clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),
        System.identityHashCode(r), r.info,
        mergedConfiguration.getGlobalConfiguration(),
        mergedConfiguration.getOverrideConfiguration(), r.compat,
        r.launchedFromPackage, task.voiceInteractor, app.repProcState, r.icicle,
        r.persistentState, results, newIntents, mService.isNextTransitionForward(),
        profilerInfo));

//设置目标事务的状态为onResume   ---->2
final ActivityLifecycleItem lifecycleItem;
lifecycleItem = ResumeActivityItem.obtain(mService.isNextTransitionForward());
clientTransaction.setLifecycleStateRequest(lifecycleItem);

//通过事务方式开始activity生命周期，onCreate,onStart,onResume   ---->3
mService.getLifecycleManager().scheduleTransaction(clientTransaction);

2.18.1 AMS.getLifecycleManager

[->ActivityManagerService.java]

ClientLifecycleManager getLifecycleManager() {
       return mLifecycleManager;
   }

2.18.2 CLM.scheduleTransaction

[->ClientLifecycleManager.java]

void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
      final IApplicationThread client = transaction.getClient();
      transaction.schedule();
      if (!(client instanceof Binder)) {
          // If client is not an instance of Binder - it's a remote call and at this point it is
          // safe to recycle the object. All objects used for local calls will be recycled after
          // the transaction is executed on client in ActivityThread.
          transaction.recycle();
      }
  }

2.18.3 CT.schedule

[->ClientTransaction.java]

public IApplicationThread getClient() {
       return mClient;
}
public void schedule() throws RemoteException {
       mClient.scheduleTransaction(this);
}

2.18.4 AT.scheduleTransaction

[->ActivityThread.java]

@Override
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
      ActivityThread.this.scheduleTransaction(transaction);
}

ActivityThread继承ClientTransactionHandler

[->ClientTransactionHandler.java]

/** Prepare and schedule transaction for execution. */
void scheduleTransaction(ClientTransaction transaction) {
     transaction.preExecute(this);
     sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}

2.18.5 AT.handleMessage

[->ActivityThread.java]

public void handleMessage(Message msg) {
         ...
         case EXECUTE_TRANSACTION:
                    final ClientTransaction transaction = (ClientTransaction) msg.obj;
                    mTransactionExecutor.execute(transaction);
                    if (isSystem()) {
                        // Client transactions inside system process are recycled on the client side
                        // instead of ClientLifecycleManager to avoid being cleared before this
                        // message is handled.
                        transaction.recycle();
                    }
                    // TODO(lifecycler): Recycle locally scheduled transactions.
                    break;
           ....
     }

2.18.6 TE.execute

[->TransactionExecutor.java]

/**
    * Resolve transaction.
    * First all callbacks will be executed in the order they appear in the list. If a callback
    * requires a certain pre- or post-execution state, the client will be transitioned accordingly.
    * Then the client will cycle to the final lifecycle state if provided. Otherwise, it will
    * either remain in the initial state, or last state needed by a callback.
    */
   public void execute(ClientTransaction transaction) {
       final IBinder token = transaction.getActivityToken();
       log("Start resolving transaction for client: " + mTransactionHandler + ", token: " + token);
       //2.18节开始方法的第一步，状态为onCreate
       executeCallbacks(transaction);
       //2.18节开始方法的第二步，最后的状态为onResume
       executeLifecycleState(transaction);
       mPendingActions.clear();
       log("End resolving transaction");
   }

[->TransactionExecutor.java]

public void executeCallbacks(ClientTransaction transaction) {
       final List<ClientTransactionItem> callbacks = transaction.getCallbacks();
       if (callbacks == null) {
           // No callbacks to execute, return early.
           return;
       }
       log("Resolving callbacks");

       final IBinder token = transaction.getActivityToken();
       ActivityClientRecord r = mTransactionHandler.getActivityClient(token);

       // In case when post-execution state of the last callback matches the final state requested
       // for the activity in this transaction, we won't do the last transition here and do it when
       // moving to final state instead (because it may contain additional parameters from server).
       final ActivityLifecycleItem finalStateRequest = transaction.getLifecycleStateRequest();
       final int finalState = finalStateRequest != null ? finalStateRequest.getTargetState()
               : UNDEFINED;
       // Index of the last callback that requests some post-execution state.
       final int lastCallbackRequestingState = lastCallbackRequestingState(transaction);

       final int size = callbacks.size();
       for (int i = 0; i < size; ++i) {
           final ClientTransactionItem item = callbacks.get(i);
           log("Resolving callback: " + item);
           final int postExecutionState = item.getPostExecutionState();
           final int closestPreExecutionState = mHelper.getClosestPreExecutionState(r,
                   item.getPostExecutionState());
           if (closestPreExecutionState != UNDEFINED) {
               cycleToPath(r, closestPreExecutionState);
           }
           //将会执行execute方法
           item.execute(mTransactionHandler, token, mPendingActions);
           item.postExecute(mTransactionHandler, token, mPendingActions);
           if (r == null) {
               // Launch activity request will create an activity record.
               r = mTransactionHandler.getActivityClient(token);
           }

           if (postExecutionState != UNDEFINED && r != null) {
               // Skip the very last transition and perform it by explicit state request instead.
               final boolean shouldExcludeLastTransition =
                       i == lastCallbackRequestingState && finalState == postExecutionState;
               cycleToPath(r, postExecutionState, shouldExcludeLastTransition);
           }
       }
   }

[->LaunchActivityItem.java]

@Override
   public void execute(ClientTransactionHandler client, IBinder token,
           PendingTransactionActions pendingActions) {
       Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
       ActivityClientRecord r = new ActivityClientRecord(token, mIntent, mIdent, mInfo,
               mOverrideConfig, mCompatInfo, mReferrer, mVoiceInteractor, mState, mPersistentState,
               mPendingResults, mPendingNewIntents, mIsForward,
               mProfilerInfo, client);
        //见2.19节，ActivityThread继承ClientTransactionHandler
       client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
       Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
   }

2.18.7 TE.cycleToPath

[->TransactionExecutor.java]

/**
    * Transition the client between states with an option not to perform the last hop in the
    * sequence. This is used when resolving lifecycle state request, when the last transition must
    * be performed with some specific parameters.
    */
   private void cycleToPath(ActivityClientRecord r, int finish,
           boolean excludeLastState) {
       final int start = r.getLifecycleState();
       log("Cycle from: " + start + " to: " + finish + " excludeLastState:" + excludeLastState);
       final IntArray path = mHelper.getLifecyclePath(start, finish, excludeLastState);
       performLifecycleSequence(r, path);
   }

   /** Transition the client through previously initialized state sequence. */
   private void performLifecycleSequence(ActivityClientRecord r, IntArray path) {
       final int size = path.size();
       for (int i = 0, state; i < size; i++) {
           state = path.get(i);
           log("Transitioning to state: " + state);
           switch (state) {
               case ON_CREATE:
                   mTransactionHandler.handleLaunchActivity(r, mPendingActions,
                           null /* customIntent */);
                   break;
               case ON_START:
                   mTransactionHandler.handleStartActivity(r, mPendingActions);
                   break;
               case ON_RESUME:
                   mTransactionHandler.handleResumeActivity(r.token, false /* finalStateRequest */,
                           r.isForward, "LIFECYCLER_RESUME_ACTIVITY");
                   break;
               case ON_PAUSE:
                   mTransactionHandler.handlePauseActivity(r.token, false /* finished */,
                           false /* userLeaving */, 0 /* configChanges */, mPendingActions,
                           "LIFECYCLER_PAUSE_ACTIVITY");
                   break;
               case ON_STOP:
                   mTransactionHandler.handleStopActivity(r.token, false /* show */,
                           0 /* configChanges */, mPendingActions, false /* finalStateRequest */,
                           "LIFECYCLER_STOP_ACTIVITY");
                   break;
               case ON_DESTROY:
                   mTransactionHandler.handleDestroyActivity(r.token, false /* finishing */,
                           0 /* configChanges */, false /* getNonConfigInstance */,
                           "performLifecycleSequence. cycling to:" + path.get(size - 1));
                   break;
               case ON_RESTART:
                   mTransactionHandler.performRestartActivity(r.token, false /* start */);
                   break;
               default:
                   throw new IllegalArgumentException("Unexpected lifecycle state: " + state);
           }
       }
   }

cycleToPath将会执行从start,finish之间的周期方法。

2.19 AT.handleLaunchActivity

[->ActivityThread.java]

/**
 * Extended implementation of activity launch. Used when server requests a launch or relaunch.
 */
@Override
public Activity handleLaunchActivity(ActivityClientRecord r,
        PendingTransactionActions pendingActions, Intent customIntent) {
    // If we are getting ready to gc after going to the background, well
    // we are back active so skip it.
    unscheduleGcIdler();
    mSomeActivitiesChanged = true;

    if (r.profilerInfo != null) {
        mProfiler.setProfiler(r.profilerInfo);
        mProfiler.startProfiling();
    }
    //回调目标Activity的onConfigurationChanged
    // Make sure we are running with the most recent config.
    handleConfigurationChanged(null, null);

    if (localLOGV) Slog.v(
        TAG, "Handling launch of " + r);
 
    // Initialize before creating the activity
    if (!ThreadedRenderer.sRendererDisabled) {
        GraphicsEnvironment.earlyInitEGL();
    }
    WindowManagerGlobal.initialize();
     //回调目标Activity的onCreate，正式开始Activity的生命周期
    final Activity a = performLaunchActivity(r, customIntent);

    if (a != null) {
        r.createdConfig = new Configuration(mConfiguration);
        reportSizeConfigurations(r);
        if (!r.activity.mFinished && pendingActions != null) {
            pendingActions.setOldState(r.state);
            pendingActions.setRestoreInstanceState(true);
            pendingActions.setCallOnPostCreate(true);
        }
    } else {
        //存在error,则停止该Activity
        // If there was an error, for any reason, tell the activity manager to stop us.
        try {
            ActivityManager.getService()
                    .finishActivity(r.token, Activity.RESULT_CANCELED, null,
                            Activity.DONT_FINISH_TASK_WITH_ACTIVITY);
        } catch (RemoteException ex) {
            throw ex.rethrowFromSystemServer();
        }
    }

    return a;
}

2.20 AT.performLaunchActivity

[->ActivityThread.java]

private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
      ActivityInfo aInfo = r.activityInfo;
      if (r.packageInfo == null) {
          r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo,
                  Context.CONTEXT_INCLUDE_CODE);
      }

      ComponentName component = r.intent.getComponent();
      if (component == null) {
          component = r.intent.resolveActivity(
              mInitialApplication.getPackageManager());
          r.intent.setComponent(component);
      }

      if (r.activityInfo.targetActivity != null) {
          component = new ComponentName(r.activityInfo.packageName,
                  r.activityInfo.targetActivity);
      }

      ContextImpl appContext = createBaseContextForActivity(r);
      Activity activity = null;
      try {
          java.lang.ClassLoader cl = appContext.getClassLoader();
          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) {
          if (!mInstrumentation.onException(activity, e)) {
              throw new RuntimeException(
                  "Unable to instantiate activity " + component
                  + ": " + e.toString(), e);
          }
      }

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

          if (localLOGV) Slog.v(TAG, "Performing launch of " + r);
          if (localLOGV) Slog.v(
                  TAG, r + ": app=" + app
                  + ", appName=" + app.getPackageName()
                  + ", pkg=" + r.packageInfo.getPackageName()
                  + ", comp=" + r.intent.getComponent().toShortString()
                  + ", dir=" + r.packageInfo.getAppDir());

          if (activity != null) {
              CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
              Configuration config = new Configuration(mCompatConfiguration);
              if (r.overrideConfig != null) {
                  config.updateFrom(r.overrideConfig);
              }
              if (DEBUG_CONFIGURATION) Slog.v(TAG, "Launching activity "
                      + r.activityInfo.name + " with config " + config);
              Window window = null;
              if (r.mPendingRemoveWindow != null && r.mPreserveWindow) {
                  window = r.mPendingRemoveWindow;
                  r.mPendingRemoveWindow = null;
                  r.mPendingRemoveWindowManager = null;
              }
              appContext.setOuterContext(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, r.configCallback);

              if (customIntent != null) {
                  activity.mIntent = customIntent;
              }
              r.lastNonConfigurationInstances = null;
              checkAndBlockForNetworkAccess();
              activity.mStartedActivity = false;
              int theme = r.activityInfo.getThemeResource();
              if (theme != 0) {
                  activity.setTheme(theme);
              }

              activity.mCalled = false;
              //进入生命周期的onCreate
              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.setState(ON_CREATE);

          mActivities.put(r.token, r);

      } catch (SuperNotCalledException e) {
          throw e;

      } catch (Exception e) {
          if (!mInstrumentation.onException(activity, e)) {
              throw new RuntimeException(
                  "Unable to start activity " + component
                  + ": " + e.toString(), e);
          }
      }

      return activity;
  }

2.21 callActivityOnCreate

[->Instrumentation.java]

public void callActivityOnCreate(Activity activity, Bundle icicle) {
     prePerformCreate(activity);
     activity.performCreate(icicle);
     postPerformCreate(activity);
 }

2.22 performCreate

[->Activity.java]

@UnsupportedAppUsage
   final void performCreate(Bundle icicle, PersistableBundle persistentState) {
       mCanEnterPictureInPicture = true;
       restoreHasCurrentPermissionRequest(icicle);
       if (persistentState != null) {
           onCreate(icicle, persistentState);
       } else {
           onCreate(icicle);
       }
       writeEventLog(LOG_AM_ON_CREATE_CALLED, "performCreate");
       mActivityTransitionState.readState(icicle);

       mVisibleFromClient = !mWindow.getWindowStyle().getBoolean(
               com.android.internal.R.styleable.Window_windowNoDisplay, false);
       mFragments.dispatchActivityCreated();
       mActivityTransitionState.setEnterActivityOptions(this, getActivityOptions());
   }

到此，介绍了完成了Activity从onCreate,onStart,onResume的生命周期详细过程。

三、总结

本文从startActivity开始，详细分析了Activity的启动过程。

1. 流程[2.1~2.3]:运行在调用者的进程当中，比如桌面启动Activity，则调用者所在的进程为launcher，launcher进程通过IActivityManager.aidl生成的代理类，进入到了systemserver进程（AMS相应的Server端）。
2. 流程[2.3~2.17]:允许在systemserver系统进程中，这个过程为比较复杂且核心的过程，主要如下：
   • 流程[2.7]:调用resolveActivity，通过PackageManager查询系统中所有符合要求的Activity，当存在多个满足多个条件的Activity则会让用户来选择 。
   • 流程[2.8]:创建ActivityRecord对象，检查intent相关信息和权限，是否允许app切换，然后处理mPendingActivityLaunches中的Activity
   • 流程[2.9]:为Activity找到或创建新的Task对象，设置flags信息
   • 流程[2.13]:当没有处于任务栈中没有Activity时，直接回到桌面了;否则当mResumeActivity不为空是，先执行startPausingLocked方法暂停该Activity，然后进入startSpecificActivityLocked
   • 流程[2.14]:当目标进程已经存在则直接进入2.17，当目标进程不存在时则创建进程，经过调用最后到2.17
   • 流程[2.17]:systemserver进程通过IApplicationThread binder接口，进入到了目标进程。
3. 流程[2.18~2.20]:允许在目标进程，通过Handler消息机制，该进程中的binder线程向主线程发送EXECUTE_TRANSACTION消息，进入事务处理阶段调用到handleLaunchActivity，最后通过发射创建的目标Activity，然后进入到onCreate生命周期。

从进程的角度分析

1. 点击桌面图标，Launcher进程采用Binder IPC向systemserver进程发送startActivity请求
2. systemserver进程接收到请求后，向zygote进程发送创建进程的请求
3. zygote进程fork出新的子进程即app进程
4. App进程，通过Binder IPC向systemserver进程发起attachApplication请求
5. systemserver进程收到请求后，进行一系列准备工作后，在通过binderIPC进程发送scheduleTransaction请求
6. APP进程的binder进程（ApplicationThread）在收到请求后，通过handler向主线程发送EXECUTE_TRANSACTION消息。
7. 主线程收到Message消息后，通过反射机制创建目标Activity，并回调Activity的onCreate方法。

到此应用正式启动，开始进入应用的生命周期，执行完onCreate，onStart，onResume方法，makeVisible，UI渲染结束后就可以看到App的主界面了。

附录

源码路径

frameworks/base/core/java/android/content/ContextWrapper.java
frameworks/base/core/java/android/app/ContextImpl.java
frameworks/base/core/java/android/app/Instrumentation.java
frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
frameworks/base/services/core/java/com/android/server/am/ActivityStartController.java
frameworks/base/services/core/java/com/android/server/am/ActivityStarter.java
frameworks/base/services/core/java/com/android/server/am/ActivityStack.java
frameworks/base/services/core/java/com/android/server/am/ActivityStackSupervisor.java
frameworks/base/core/java/android/app/servertransaction/TransactionExecutor.java