startactivity流程|Gaozhipeng's Blog

startactivity流程

1.activity.startactivity

  public void startActivity(Intent intent) {
      this.startActivity(intent, null);
  }
  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);
      }
  }
  public void startActivityForResult(@RequiresPermission Intent intent, int requestCode) {
      startActivityForResult(intent, requestCode, null);
  }
  public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
          @Nullable Bundle options) {
      if (mParent == null) {
          options = transferSpringboardActivityOptions(options);
          Instrumentation.ActivityResult ar =
              mInstrumentation.execStartActivity(
                  this, mMainThread.getApplicationThread(), mToken, this,
                  intent, requestCode, options);
          if (ar != null) {
              mMainThread.sendActivityResult(
                  mToken, mEmbeddedID, requestCode, ar.getResultCode(),
                  ar.getResultData());
          }
          if (requestCode >= 0) {
              // If this start is requesting a result, we can avoid making
              // the activity visible until the result is received.  Setting
              // this code during onCreate(Bundle savedInstanceState) or onResume() will keep the
              // activity hidden during this time, to avoid flickering.
              // This can only be done when a result is requested because
              // that guarantees we will get information back when the
              // activity is finished, no matter what happens to it.
              mStartedActivity = true;
          }
4604
          cancelInputsAndStartExitTransition(options);
          // TODO Consider clearing/flushing other event sources and events for child windows.
      } else {
          if (options != null) {
              mParent.startActivityFromChild(this, intent, requestCode, options);
          } else {
              // Note we want to go through this method for compatibility with
              // existing applications that may have overridden it.
              mParent.startActivityFromChild(this, intent, requestCode);
          }
      }
  }

####2.instrumentation.java -> execstartactivity

  public ActivityResult execStartActivity(
          Context who, IBinder contextThread, IBinder token, Activity target,
          Intent intent, int requestCode, Bundle options) {
      android.util.SeempLog.record_str(377, intent.toString());
      IApplicationThread whoThread = (IApplicationThread) contextThread;
      Uri referrer = target != null ? target.onProvideReferrer() : null;
      if (referrer != null) {
          intent.putExtra(Intent.EXTRA_REFERRER, referrer);
      }
      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++;
                      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 != null ? target.mEmbeddedID : null,
                      requestCode, 0, null, options);
          checkStartActivityResult(result, intent);
      } catch (RemoteException e) {
          throw new RuntimeException("Failure from system", e);
      }
      return null;
  }

然后这里就和startservice相同，采用了aidl的方式来binder调用到systemserver端

3.ams.startactivity-> am.startactivityasuser->am.startactivityasuser

  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");
5199
      userId = mActivityStartController.checkTargetUser(userId, validateIncomingUser,
              Binder.getCallingPid(), Binder.getCallingUid(), "startActivityAsUser");
5202
      // 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();
5216
  }

p之后采用了工厂模式，首先取出一个starter，然后将配置starter的相关属性，然后再进行start

4.activitystarter -> execute

  int execute() {
      try {
          // TODO(b/64750076): Look into passing request directly to these methods to allow
          // for transactional diffs and preprocessing.
          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);
          } 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);
          }
      } finally {
          onExecutionComplete();
      }
  }

####5.activitystarter.startactivitymaywait

  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) {
    ...
      ResolveInfo rInfo = mSupervisor.resolveIntent(intent, resolvedType, userId,
              0 /* matchFlags */,
                      computeResolveFilterUid(
                              callingUid, realCallingUid, mRequest.filterCallingUid));
    ...
1101
          final ActivityRecord[] outRecord = new ActivityRecord[1];
          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);
    ...
  }

####6.activitystart.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, String reason,
          boolean allowPendingRemoteAnimationRegistryLookup) {
540
      if (TextUtils.isEmpty(reason)) {
          throw new IllegalArgumentException("Need to specify a reason.");
      }
      mLastStartReason = reason;
      mLastStartActivityTimeMs = System.currentTimeMillis();
      mLastStartActivityRecord[0] = null;
//继续调用内部的startactivity方法
      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);
553
      if (outActivity != null) {
          // mLastStartActivityRecord[0] is set in the call to startActivity above.
          outActivity[0] = mLastStartActivityRecord[0];
      }
558
      return getExternalResult(mLastStartActivityResult);
  }

acitvitystart.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) {
      return startActivity(r, sourceRecord, voiceSession, voiceInteractor, startFlags,
              true /* doResume */, checkedOptions, inTask, outActivity);
  }

####activitystarter.startactivityunchecked

需要注意的是，在这个地方会进行launchmode的判断，

  private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
          IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
          int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
          ActivityRecord[] outActivity) {
...//如果有可用的stack，那么就将那个stack放置到前台。
          if (reusedActivity != null) {
              setTaskFromIntentActivity(reusedActivity);
1345
              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.
1349
                  resumeTargetStackIfNeeded();
                  if (outActivity != null && outActivity.length > 0) {
                      outActivity[0] = reusedActivity;
                  }
1354
                  return mMovedToFront ? START_TASK_TO_FRONT : START_DELIVERED_TO_TOP;
              }
          }
      }
...
1447//在stack中启动应用
      mTargetStack.startActivityLocked(mStartActivity, topFocused, newTask, mKeepCurTransition,
              mOptions);
...
      if (mDoResume) {
          final ActivityRecord topTaskActivity =
                  mStartActivity.getTask().topRunningActivityLocked();
          if (!mTargetStack.isFocusable()
                  || (topTaskActivity != null && topTaskActivity.mTaskOverlay
                  && mStartActivity != topTaskActivity)) {
              // 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");
              }//此处需要resumeactivity
              mSupervisor.resumeFocusedStackTopActivityLocked(mTargetStack, mStartActivity,
                      mOptions);
          }
      } else if (mStartActivity != null) {
          mSupervisor.mRecentTasks.add(mStartActivity.getTask());
      }
      mSupervisor.updateUserStackLocked(mStartActivity.userId, mTargetStack);
1482
      mSupervisor.handleNonResizableTaskIfNeeded(mStartActivity.getTask(), preferredWindowingMode,
              preferredLaunchDisplayId, mTargetStack);
1485
      return START_SUCCESS;
  }
}

activitystack.startactivitylocked

  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.
          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.
                  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;
              }
          }
      }
2953
      // Place a new activity at top of stack, so it is next to interact with the user.
2955
      // 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");
      }
2964
      task = activityTask;
2966
      // 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();
2977
      if (mActivityTrigger != null) {
          mActivityTrigger.activityStartTrigger(r.intent, r.info, r.appInfo, r.fullscreen);
      }
      if (mActivityPluginDelegate != null) {
          mActivityPluginDelegate.activityInvokeNotification
              (r.appInfo.packageName, r.fullscreen);
      }
      if (!isActivityTypeHome() || numActivities() > 0) {
          // We want to show the starting preview window if we are
          // switching to a new task, or the next activity's process is
          // not currently running.
          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) {
                  // 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;
                  }
                  // (2) The current activity is already displayed.
                  else if (prev.nowVisible) {
                      prev = null;
                  }
              }
    //注意此处的showstartingwindow，这个地方是我们经常用来性能提升的地方
              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);
      }
  }

接着我们可以看resumeactivity

activitystacksupervisor -> resumefocusedstacktopactivitylocked

  boolean resumeFocusedStackTopActivityLocked(
          ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
2228
      if (!readyToResume()) {
          return false;
      }
2232//将目标stack的栈顶activity进行resume
      if (targetStack != null && isFocusedStack(targetStack)) {
          return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
      }
2236
      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);
      }
2244
      return false;
  }

activitystack.resumetopactivityuncheckedlocked

  boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
      if (mStackSupervisor.inResumeTopActivity) {
          // Don't even start recursing.
          return false;
      }
2307
      boolean result = false;
      try {
          // Protect against recursion.
          mStackSupervisor.inResumeTopActivity = true;
          result = resumeTopActivityInnerLocked(prev, options);//真正resume的地方
2313

          final ActivityRecord next = topRunningActivityLocked(true /* focusableOnly */);
          if (next == null || !next.canTurnScreenOn()) {
              checkReadyForSleep();
          }
      } finally {
          mStackSupervisor.inResumeTopActivity = false;
      }
2328
      return result;
  }

activitystack -> resumetopactivityinnerlocked

  private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
      if (!mService.mBooting && !mService.mBooted) {
          // Not ready yet!
          return false;
      }
2355
      // 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 */);
2360
      final boolean hasRunningActivity = next != null;
2362
      // TODO: Maybe this entire condition can get removed?
      if (hasRunningActivity && !isAttached()) {
          return false;
      }
2367
      mStackSupervisor.cancelInitializingActivities();
2369
      // 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;
2374
      if (!hasRunningActivity) {
          // There are no activities left in the stack, let's look somewhere else.
          return resumeTopActivityInNextFocusableStack(prev, options, "noMoreActivities");
      }
2379
      next.delayedResume = false;
2381
      // 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;
      }
2393
      // 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;
      }
2407
      // 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;
      }
2417
      // 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);
      next.launching = true;
2425
      if (DEBUG_SWITCH) Slog.v(TAG_SWITCH, "Resuming " + next);
2427
      if (mActivityTrigger != null) {
          mActivityTrigger.activityResumeTrigger(next.intent, next.info, next.appInfo,
                  next.fullscreen);
      }
2432
      if (mActivityPluginDelegate != null) {
          mActivityPluginDelegate.activityInvokeNotification
              (next.appInfo.packageName, next.fullscreen);
      }
      // 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;
      }
2445
      mStackSupervisor.setLaunchSource(next.info.applicationInfo.uid);
2447
      // MIUI ADD: START
      // Resume boost.
      if (mPerf == null) {
          mPerf = new BoostFramework();
      } else {
          ProcessRecord app = mService.getProcessRecordLocked(next.processName,
              next.info.applicationInfo.uid, true);
          if (app != null && app.thread != null) {
              mPerf.perfHint(BoostFramework.VENDOR_HINT_SUBSEQ_LAUNCH_BOOST, next.packageName,
                 -1, BoostFramework.Launch.BOOST_V1);
          }
      }
      // END
2461
      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 */);
      }
      // 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;
2485
      boolean pausing = mStackSupervisor.pauseBackStacks(userLeaving, next, false);
      if (mResumedActivity != null) {
          if (DEBUG_STATES) Slog.d(TAG_STATES,
                  "resumeTopActivityLocked: Pausing " + mResumedActivity);
    //注意此处是pause前一个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;
      }
2520
      // 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;
      }
2532
      if (prev != null && prev != next) {
          if (!mStackSupervisor.mActivitiesWaitingForVisibleActivity.contains(prev)
                  && next != null && !next.nowVisible) {
              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);
              }
          }
      }
2563
      // 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);
      }
2574
      // 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 (mPerf == null) {
          mPerf = new BoostFramework();
      }
      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);
                  if(prev.getTask() != next.getTask() && mPerf != null) {
                     mPerf.perfHint(BoostFramework.VENDOR_HINT_ANIM_BOOST,
                             next.packageName, -1, 1);
                  }
              }
              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);
                  if(prev.getTask() != next.getTask() && mPerf != null) {
                     mPerf.perfHint(BoostFramework.VENDOR_HINT_ANIM_BOOST,
                             next.packageName, -1, 1);
                  }
              }
          }
      } 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);
          }
      }
2626
      if (anim) {
          next.applyOptionsLocked();
      } else {
          next.clearOptionsLocked();
      }
2632
      mStackSupervisor.mNoAnimActivities.clear();
2634
      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);
2639
          // 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));
2651
          // 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()) {
              // This activity is now becoming visible.
              if (!next.visible || next.stopped || lastActivityTranslucent) {
                  next.setVisibility(true);
              }
2662
              // schedule launch ticks to collect information about slow apps.
              next.startLaunchTickingLocked();
2665
              ActivityRecord lastResumedActivity =
                      lastStack == null ? null :lastStack.mResumedActivity;
              final ActivityState lastState = next.getState();
2669
              mService.updateCpuStats();
2671
              if (DEBUG_STATES) Slog.v(TAG_STATES, "Moving to RESUMED: " + next
                      + " (in existing)");
2674
              next.setState(RESUMED, "resumeTopActivityInnerLocked");
2676
              mService.updateLruProcessLocked(next.app, true, null);
              updateLRUListLocked(next);
              mService.updateOomAdjLocked();
2680
              // Have the window manager re-evaluate the orientation of
              // the screen based on the new activity order.
              boolean notUpdated = true;
2684
              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 */);
              }
2697
              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;
              }
2719
              try {
                  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));
                      }
                  }
2733
                  if (next.newIntents != null) {
                      transaction.addCallback(NewIntentItem.obtain(next.newIntents,
                              false /* andPause */));
                  }
2738
                  // Well the app will no longer be stopped.
                  // Clear app token stopped state in window manager if needed.
                  next.notifyAppResumed(next.stopped);
2742
                  EventLog.writeEvent(EventLogTags.AM_RESUME_ACTIVITY, next.userId,
                          System.identityHashCode(next), next.getTask().taskId,
                          next.shortComponentName);
2746
                  next.sleeping = false;
                  mService.getAppWarningsLocked().onResumeActivity(next);
                  mService.showAskCompatModeDialogLocked(next);
                  next.app.pendingUiClean = true;
                  next.app.forceProcessStateUpTo(mService.mTopProcessState);
                  next.clearOptionsLocked();
                  transaction.setLifecycleStateRequest(
                          ResumeActivityItem.obtain(next.app.repProcState,
                                  mService.isNextTransitionForward()));
                  mService.getLifecycleManager().scheduleTransaction(transaction);
2757
                  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");
2765
                  // lastResumedActivity being non-null implies there is a lastStack present.
                  if (lastResumedActivity != null) {
                      lastResumedActivity.setState(RESUMED, "resumeTopActivityInnerLocked");
                  }
2770
                  Slog.i(TAG, "Restarting because process died: " + next);
                  if (!next.hasBeenLaunched) {
                      next.hasBeenLaunched = true;
                  } else  if (SHOW_APP_STARTING_PREVIEW && lastStack != null
                          && getDisplay() != null && lastStack.isTopStackOnDisplay()) {
                      next.showStartingWindow(null /* prev */, false /* newTask */,
                              false /* taskSwitch */);
                  }
                  mStackSupervisor.startSpecificActivityLocked(next, true, false);
                  if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
                  return true;
              }
          }
2784
          // 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 {
          // 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);
    //此处是resume对应的activity
          mStackSupervisor.startSpecificActivityLocked(next, true, true);
      }
2812
      if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
      return true;
  }

activitystacksupervisor -> startspecificactivitylocked

  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);
1695
      getLaunchTimeTracker().setLaunchTime(r);
1697
      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);
              }
              realStartActivityLocked(r, app, andResume, checkConfig);
              return;
          } catch (RemoteException e) {
              Slog.w(TAG, "Exception when starting activity "
                      + r.intent.getComponent().flattenToShortString(), e);
          }
1715
          // If a dead object exception was thrown -- fall through to
          // restart the application.
      }
1719
      mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,
              "activity", r.intent.getComponent(), false, false, true);
  }

activitystacksupervisor -> realstartactivitylocked

1381
  final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
          boolean andResume, boolean checkConfig) throws RemoteException {
1384
    ...
              // 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));
1539
              // Set desired final state.
              final ActivityLifecycleItem lifecycleItem;
              if (andResume) {
                  lifecycleItem = ResumeActivityItem.obtain(mService.isNextTransitionForward());
              } else {
                  lifecycleItem = PauseActivityItem.obtain();
              }
              clientTransaction.setLifecycleStateRequest(lifecycleItem);
1548
              // Schedule transaction.
              mService.getLifecycleManager().scheduleTransaction(clientTransaction);
1551
1552
    ...
  }

之后就会回调到activitythread中的handlelaunchactivity中了

  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;
3031
      if (r.profilerInfo != null) {
          mProfiler.setProfiler(r.profilerInfo);
          mProfiler.startProfiling();
      }
3036
      // Make sure we are running with the most recent config.
      handleConfigurationChanged(null, null);
3039
      if (localLOGV) Slog.v(
          TAG, "Handling launch of " + r);
3042
      // Initialize before creating the activity
      if (!ThreadedRenderer.sRendererDisabled) {
          GraphicsEnvironment.earlyInitEGL();
      }
      WindowManagerGlobal.initialize();
3048
      final Activity a = performLaunchActivity(r, customIntent);
3050
      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 {
          // 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();
          }
      }
3069
      return a;
  }

启动流程：

点击桌面App图标，Launcher进程采用Binder IPC向system_server进程发起startActivity请求；
system_server进程接收到请求后，向zygote进程发送创建进程的请求；
Zygote进程fork出新的子进程，即App进程；
App进程，通过Binder IPC向sytem_server进程发起attachApplication请求；
system_server进程在收到请求后，进行一系列准备工作后，再通过binder IPC向App进程发送scheduleLaunchActivity请求；
App进程的binder线程（ApplicationThread）在收到请求后，通过handler向主线程发送LAUNCH_ACTIVITY消息；
主线程在收到Message后，通过发射机制创建目标Activity，并回调Activity.onCreate()等方法。