自学内容网 自学内容网

ActivityManagerService Activity的启动流程(2)

ActivityManagerService Activity的启动流程

简述

提到ActivityManagerService,最重要的流程之一就是启动Activity了。
这个流程比较复杂:

  • 启动activity的调用链很长。
  • 业务逻辑很多,activity启动有很多flag,例如FLAG_ACTIVITY_NEW_TASK,FLAG_ACTIVITY_CLEAR_TOP等等。
  • 需要在app进程和systemserver之间来回binder调用。
    同时activity启动还有两种不同的情况,一种是要启动的Activity进程已经存在了,只是新启动一个Activity,例如在app内部页面跳转。而另一种是要启动的Activity进程不存在,需要新启动一个进程,比如从桌面启动一个进程。

app启动Activity

在这里插入图片描述

1.1 Activity.startActivityForResult
Activity.startActivity最终也会走到Activity.startActivityForResult,只不过requestCode会传-1,我们就从这里开始.
这里的mParent是历史版本的遗留产物,应该是被Fragment替代了,这里可以不用管。
调用了Instrumentation.execStartActivity

  public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
        @Nullable Bundle options) {
    if (mParent == null) { 
        options = transferSpringboardActivityOptions(options);
        // 调用Instrumentation.execStartActivity,详见1.2
        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) {
            mStartedActivity = true;
        }

        cancelInputsAndStartExitTransition(options);
    } else {
        // ...
    }
}

1.2 Instrumentation.execStartActivity
mActivityMonitors一般用于CTS测试,除了mActivityMonitors插桩的逻辑,主要逻辑是调用ATMS服务,启动Activity

public ActivityResult execStartActivity(
        Context who, IBinder contextThread, IBinder token, Activity target,
        Intent intent, int requestCode, Bundle options) {
    IApplicationThread whoThread = (IApplicationThread) contextThread;
    Uri referrer = target != null ? target.onProvideReferrer() : null;
    if (referrer != null) {
        intent.putExtra(Intent.EXTRA_REFERRER, referrer);
    }
    // ...mActivityMonitors,一般用于CTS测试
    try {
        intent.migrateExtraStreamToClipData(who);
        intent.prepareToLeaveProcess(who);
        // 调用ATMS启动activity,详见1.3
        int result = ActivityTaskManager.getService().startActivity(whoThread,
                who.getOpPackageName(), who.getAttributionTag(), intent,
                intent.resolveTypeIfNeeded(who.getContentResolver()), token,
                target != null ? target.mEmbeddedID : null, requestCode, 0, null, options);
        // 通知mActivityMonitors返回结果
        notifyStartActivityResult(result, options);
        // 处理返回值,如果没有启动成功抛出对应异常
        checkStartActivityResult(result, intent);
    } catch (RemoteException e) {
        throw new RuntimeException("Failure from system", e);
    }
    return null;
}

1.3 ActivityTaskManagerService.startActivity
直接调用了startActivityAsUser

public final int startActivity(IApplicationThread caller, String callingPackage,
        String callingFeatureId, Intent intent, String resolvedType, IBinder resultTo,
        String resultWho, int requestCode, int startFlags, ProfilerInfo profilerInfo,
        Bundle bOptions) {
    // 详见1.4
    return startActivityAsUser(caller, callingPackage, callingFeatureId, intent, resolvedType,
            resultTo, resultWho, requestCode, startFlags, profilerInfo, bOptions,
            UserHandle.getCallingUserId());
}

1.4 ActivityTaskManagerService.startActivityAsUser
调用了重载函数startActivityAsUser

public int startActivityAsUser(IApplicationThread caller, String callingPackage,
        String callingFeatureId, Intent intent, String resolvedType, IBinder resultTo,
        String resultWho, int requestCode, int startFlags, ProfilerInfo profilerInfo,
        Bundle bOptions, int userId) {
    return startActivityAsUser(caller, callingPackage, callingFeatureId, intent, resolvedType,
            resultTo, resultWho, requestCode, startFlags, profilerInfo, bOptions, userId,
            true /*validateIncomingUser*/);
}

1.5 ActivityTaskManagerService.startActivityAsUser
使用所有参数构造一个ActivityStarter,然后调用ActivityStarter.execute

private int startActivityAsUser(IApplicationThread caller, String callingPackage,
        @Nullable String callingFeatureId, Intent intent, String resolvedType,
        IBinder resultTo, String resultWho, int requestCode, int startFlags,
        ProfilerInfo profilerInfo, Bundle bOptions, int userId, boolean validateIncomingUser) {

    final SafeActivityOptions opts = SafeActivityOptions.fromBundle(bOptions);

    assertPackageMatchesCallingUid(callingPackage);
    enforceNotIsolatedCaller("startActivityAsUser");

    // ...

    userId = getActivityStartController().checkTargetUser(userId, validateIncomingUser,
            Binder.getCallingPid(), Binder.getCallingUid(), "startActivityAsUser");
    // 详见1.6
    return getActivityStartController().obtainStarter(intent, "startActivityAsUser")
            .setCaller(caller) // 调用者对应的binder token
            .setCallingPackage(callingPackage) // 调用者包名
            .setCallingFeatureId(callingFeatureId)
            .setResolvedType(resolvedType) // MIME类型
            .setResultTo(resultTo) // startActivityForResult里接受返回结果的Activity
            .setResultWho(resultWho)
            .setRequestCode(requestCode) // startActivityForResult里面的requestCode
            .setStartFlags(startFlags) // 启动的flag
            .setProfilerInfo(profilerInfo) 
            .setActivityOptions(opts) // 启动Activity的option
            .setUserId(userId) // 设置userId
            .execute(); // 详见1.6

}

1.6 ActivityStarter.execute
主要是判断activityInfo是否为空来判断之前Intent是否解析,如果没有解析则需要在这里解析出需要启动的Activity信息,然后调用executeRequest进行实际的启动。
除此之外还记录了一些信息以便重启后可以恢复一些数据。判断是否改变了Configuration,如果需要则通知Configuraion改变,进行Configuraion计算以及通知。

int execute() {
    try {
        // ...
        

        // 如果activityInfo为空,则说明之前没有解析Intent,就在这里解析,将action等解析为需要启动的Activity信息。
        if (mRequest.activityInfo == null) {
            mRequest.resolveActivity(mSupervisor);
        }

        if (mRequest.intent != null) {
            String intentAction = mRequest.intent.getAction();
            String callingPackage = mRequest.callingPackage;
            if (intentAction != null && callingPackage != null
                    && (Intent.ACTION_REQUEST_SHUTDOWN.equals(intentAction)
                            || Intent.ACTION_SHUTDOWN.equals(intentAction)
                            || Intent.ACTION_REBOOT.equals(intentAction))) {
                // 记录关机检测点,以便重启后可以恢复一些状态。
                ShutdownCheckPoints.recordCheckPoint(intentAction, callingPackage, null);
            }
        }

        int res;
        synchronized (mService.mGlobalLock) {
            // 检测Configuration是否需要变化
            final boolean globalConfigWillChange = mRequest.globalConfig != null
                    && mService.getGlobalConfiguration().diff(mRequest.globalConfig) != 0;
            final Task rootTask = mRootWindowContainer.getTopDisplayFocusedRootTask();
            if (rootTask != null) {
                rootTask.mConfigWillChange = globalConfigWillChange;
            }
            // ...

            try {
                // 具体启动的逻辑,详见1.7
                res = executeRequest(mRequest);
            } finally {
                mRequest.logMessage.append(" result code=").append(res);
                Slog.i(TAG, mRequest.logMessage.toString());
                mRequest.logMessage.setLength(0);
            }

            Binder.restoreCallingIdentity(origId);

            if (globalConfigWillChange) {
                // ...
                // 通知Configuration变化
                mService.updateConfigurationLocked(mRequest.globalConfig, null, false);
            }
            // ... 记录启动消耗时间等信息
            // 等待启动结果
            if (mRequest.waitResult != null) {
                mRequest.waitResult.result = res;
                res = waitResultIfNeeded(mRequest.waitResult, mLastStartActivityRecord,
                        launchingState);
            }
            return getExternalResult(res);
        }
    } finally {
        onExecutionComplete();
    }
}  

1.7 executeRequest
这里主要是一些预处理,resultRecord的判定,然后是对Intent中的信息进行解析,解析结果主要是ResolveInfo,里面有一个ActivityInfo。
ResolveInfo里面有用于Intent筛选的信息,如IntentFilter.还有一些图标,labels等信息。
ResolveInfo持有一个ActivityInfo,里面是Activity的一些信息,如launchMode,taskAffinity(acitivity启动的Task),启动activity所需的permission等。
这些信息几乎都是来源于AndroidManifest.xml,所以这里解析其实是通过PackageManagerService,我们这里就不细看了。
此外还有一些特殊场景的处理,如语音会话的启动,启动需要先启动用户确认授权Activity等。
然后就是构建ActivityRecord,这个在WMS章节提过,Activity在system_server侧就是一个ActivityRecord,会在WMS等窗口树上,就是这里创建的。
最后调用了startActivityUnchecked,进一步做启动Activity的操作。

private int executeRequest(Request request) {
    // ... 一些局部变量声明
    // ...

    ActivityRecord sourceRecord = null;
    ActivityRecord resultRecord = null;
    // 如果requestCode大于0,且SourceRecord没有finish,则说明这次启动activity结束后是需要给resultRecord返回结果的。
    if (resultTo != null) {
        sourceRecord = ActivityRecord.isInAnyTask(resultTo);
        if (sourceRecord != null) {
            if (requestCode >= 0 && !sourceRecord.finishing) {
                resultRecord = sourceRecord;
            }
        }
    }

    final int launchFlags = intent.getFlags();
    // FLAG_ACTIVITY_FORWARD_RESULT作用:假如A启动B,B使用FLAG_ACTIVITY_FORWARD_RESULT启动C,则C返回的结果给A。
    if ((launchFlags & Intent.FLAG_ACTIVITY_FORWARD_RESULT) != 0 && sourceRecord != null) {
        if (requestCode >= 0) {
            SafeActivityOptions.abort(options);
            return ActivityManager.START_FORWARD_AND_REQUEST_CONFLICT;
        }
        resultRecord = sourceRecord.resultTo;
        if (resultRecord != null && !resultRecord.isInRootTaskLocked()) {
            resultRecord = null;
        }
        resultWho = sourceRecord.resultWho;
        requestCode = sourceRecord.requestCode;
        sourceRecord.resultTo = null;
        if (resultRecord != null) {
            resultRecord.removeResultsLocked(sourceRecord, resultWho, requestCode);
        }
        if (sourceRecord.launchedFromUid == callingUid) {
            callingPackage = sourceRecord.launchedFromPackage;
            callingFeatureId = sourceRecord.launchedFromFeatureId;
        }
    }

    // 找不到处理Intent的类
    if (err == ActivityManager.START_SUCCESS && intent.getComponent() == null) {
        err = ActivityManager.START_INTENT_NOT_RESOLVED;
    }

    // 找不到Intent对应的Activity类
    if (err == ActivityManager.START_SUCCESS && aInfo == null) {
        err = ActivityManager.START_CLASS_NOT_FOUND;
    }
    // ... 语音会话启动,需要鉴权,处理兼容性问题
    // ... Intent权限检查

    if (request.allowPendingRemoteAnimationRegistryLookup) {
        checkedOptions = mService.getActivityStartController()
                .getPendingRemoteAnimationRegistry()
                .overrideOptionsIfNeeded(callingPackage, checkedOptions);
    }
    if (mService.mController != null) {
        try {
            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,
            callingFeatureId);
    // ...
    // 这个ACTION_REVIEW_PERMISSIONS是给用户确认是否授于XXX权限
    if (aInfo != null) {
        if (mService.getPackageManagerInternalLocked().isPermissionsReviewRequired(
                aInfo.packageName, userId)) {
            final IIntentSender target = mService.getIntentSenderLocked(
                    ActivityManager.INTENT_SENDER_ACTIVITY, callingPackage, callingFeatureId,
                    callingUid, userId, null, null, 0, new Intent[]{intent},
                    new String[]{resolvedType}, PendingIntent.FLAG_CANCEL_CURRENT
                            | PendingIntent.FLAG_ONE_SHOT, null);

            Intent newIntent = new Intent(Intent.ACTION_REVIEW_PERMISSIONS);

            // ...
        }
    }

    // 处理临时应用程序,安装成功或者安装失败提示。
    if (rInfo != null && rInfo.auxiliaryInfo != null) {
        intent = createLaunchIntent(rInfo.auxiliaryInfo, request.ephemeralIntent,
                callingPackage, callingFeatureId, verificationBundle, resolvedType, userId);
        resolvedType = null;
        callingUid = realCallingUid;
        callingPid = realCallingPid;

        // The ephemeral installer shouldn't get any permission grants
        // intended for the original destination
        intentGrants = null;

        aInfo = mSupervisor.resolveActivity(intent, rInfo, startFlags, null /*profilerInfo*/);
    }
    
    if (callerApp == null && realCallingPid > 0) {
        final WindowProcessController wpc = mService.mProcessMap.getProcess(realCallingPid);
        if (wpc != null) {
            callerApp = wpc;
        }
    }
    // 构建ActivityRecord
    final ActivityRecord r = new ActivityRecord.Builder(mService)
            .setCaller(callerApp)
            .setLaunchedFromPid(callingPid)
            .setLaunchedFromUid(callingUid)
            .setLaunchedFromPackage(callingPackage)
            .setLaunchedFromFeature(callingFeatureId)
            .setIntent(intent)
            .setResolvedType(resolvedType)
            .setActivityInfo(aInfo)
            .setConfiguration(mService.getGlobalConfiguration())
            .setResultTo(resultRecord)
            .setResultWho(resultWho)
            .setRequestCode(requestCode)
            .setComponentSpecified(request.componentSpecified)
            .setRootVoiceInteraction(voiceSession != null)
            .setActivityOptions(checkedOptions)
            .setSourceRecord(sourceRecord)
            .build();

    mLastStartActivityRecord = r;

    WindowProcessController homeProcess = mService.mHomeProcess;
    boolean isHomeProcess = homeProcess != null
            && aInfo.applicationInfo.uid == homeProcess.mUid;
    if (balCode != BAL_BLOCK && !isHomeProcess) {
        mService.resumeAppSwitches();
    }
    // 调用startActivityUnchecked,详见1.8
    mLastStartActivityResult = startActivityUnchecked(r, sourceRecord, voiceSession,
            request.voiceInteractor, startFlags, checkedOptions,
            inTask, inTaskFragment, balCode, intentGrants, realCallingUid);

    if (request.outActivity != null) {
        request.outActivity[0] = mLastStartActivityRecord;
    }

    return mLastStartActivityResult;
}

1.8 startActivityUnchecked
处理启动动画相关的逻辑。调用startActivityInner

private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
        IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
        int startFlags, ActivityOptions options, Task inTask,
        TaskFragment inTaskFragment, @BalCode int balCode,
        NeededUriGrants intentGrants, int realCallingUid) {
    int result = START_CANCELED;
    final Task startedActivityRootTask;

    // 创建Activity启动动画的Transaction
    final TransitionController transitionController = r.mTransitionController;
    Transition newTransition = transitionController.isShellTransitionsEnabled()
            ? transitionController.createAndStartCollecting(TRANSIT_OPEN) : null;
    RemoteTransition remoteTransition = r.takeRemoteTransition();
    try {
        mService.deferWindowLayout();
        transitionController.collect(r);
        try {
            Trace.traceBegin(Trace.TRACE_TAG_WINDOW_MANAGER, "startActivityInner");
            // 详见1.9
            result = startActivityInner(r, sourceRecord, voiceSession, voiceInteractor,
                    startFlags, options, inTask, inTaskFragment, balCode,
                    intentGrants, realCallingUid);
        } finally {
            Trace.traceEnd(Trace.TRACE_TAG_WINDOW_MANAGER);
            // 处理result,同时会触发启动动画。
            startedActivityRootTask = handleStartResult(r, options, result, newTransition,
                    remoteTransition);
        }
    } finally {
        mService.continueWindowLayout();
    }
    postStartActivityProcessing(r, result, startedActivityRootTask);

    return result;
}

1.9 startActivityInner
这里会处理Activity启动的flag等参数,处理新启动的Activity和WMS相关的逻辑(即调整WMS树),具体有以下的操作:

  • 选择启动的Activity的DisplayContent

  • 判断是否有可以复用的Task,如果没有则新增Task

  • 调整Task位置,比如移动到最上层。

  • 如果需要,则将ActivityRecord添加到对应的Task上
    最后调用resumeFocusedTasksTopActivities,尝试唤醒Focus的Activity。(后面就是Activity声明周期相关的逻辑了)

    int startActivityInner(final ActivityRecord r, ActivityRecord sourceRecord,
    IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
    int startFlags, ActivityOptions options, Task inTask,
    TaskFragment inTaskFragment, @BalCode int balCode,
    NeededUriGrants intentGrants, int realCallingUid) {
    // 设置初始化状态。主要是计算activity需要启动在哪个屏幕上,如果启动的时候没有指定display,就是这里计算的结果一般是sourceActivity所在的屏幕或者主屏
    // 这里计算的diplay不一定是最终的display,如果后续发现有复用Task之类的情况,可能会更新这个display
    // 除此之外还有一些option里面的参数处理(如指定了taskId),以及根据Activity launch mode更新launch flag等等。
    setInitialState(r, options, inTask, inTaskFragment, startFlags, sourceRecord,
    voiceSession, voiceInteractor, balCode, realCallingUid);
    // 计算launch flag,会影响到后面是否需要new task或者敷用task等等。
    computeLaunchingTaskFlags();
    mIntent.setFlags(mLaunchFlags);

      // ...
      // 根据Activity的LaunchMode以及mLaunchFlags等信息,计算是否有可以复用的Task
      final Task reusedTask = getReusableTask();
      // ...
    
      // computeTargetTask根据mLaunchFlags和sourceRecord等信息,计算是否已经有存在的Task用来启动目标的Activity
      // (比如mLaunchFlags有FLAG_ACTIVITY_NEW_TASK,表示要新增Task,computeTargetTask一般就会返回null)
      final Task targetTask = reusedTask != null ? reusedTask : computeTargetTask();
      final boolean newTask = targetTask == null;
      mTargetTask = targetTask;
      // 会根据计算出来的targetTask重新计算需要将Activity启动到哪个屏幕
      computeLaunchParams(r, sourceRecord, targetTask);
    
      // 合法性检查
      int startResult = isAllowedToStart(r, newTask, targetTask);
      if (startResult != START_SUCCESS) {
          // ...
          return startResult;
      }
    
      if (targetTask != null) {
          // 数量检查,由于每个Activity都有Surface,是系统资源,所以要约束app,每个Task有数量限制
          if (targetTask.getTreeWeight() > MAX_TASK_WEIGHT_FOR_ADDING_ACTIVITY) {
              // ...
              targetTask.removeImmediately("bulky-task");
              return START_ABORTED;
          }
          // ...
      }
    
      final ActivityRecord targetTaskTop = newTask
              ? null : targetTask.getTopNonFinishingActivity();
      if (targetTaskTop != null) {
          // 如果Activity的LaunchMode是SingleInstance,检查一下其他的Task有没有这个activity,有就需要销毁
          if (LAUNCH_SINGLE_INSTANCE == mLaunchMode && mSourceRecord != null
                  && targetTask == mSourceRecord.getTask()) {
              final ActivityRecord activity = mRootWindowContainer.findActivity(mIntent,
                      mStartActivity.info, false);
              if (activity != null && activity.getTask() != targetTask) {
                  activity.destroyIfPossible("Removes redundant singleInstance");
              }
          }
          // 判断是否需要加入ActivityRecord(可能是复用原来存在的),还会把targetTask放到目标屏幕最上面。
          startResult = recycleTask(targetTask, targetTaskTop, reusedTask, intentGrants);
          if (startResult != START_SUCCESS) {
              return startResult;
          }
      } else {
          mAddingToTask = true;
      }
    
      if (mTargetRootTask == null) {
          mTargetRootTask = getOrCreateRootTask(mStartActivity, mLaunchFlags, targetTask,
                  mOptions);
      }
    
      // 如果需要newTask,根据Affiliate新建一个Task
      if (newTask) {
          final Task taskToAffiliate = (mLaunchTaskBehind && mSourceRecord != null)
                  ? mSourceRecord.getTask() : null;
          setNewTask(taskToAffiliate);
      } else if (mAddingToTask) {
          // 否则直接将启动activity添加
          addOrReparentStartingActivity(targetTask, "adding to task");
      }
    
      // ...
    
      final Task startedTask = mStartActivity.getTask();
      // ...
    
      mRootWindowContainer.startPowerModeLaunchIfNeeded(
              false /* forceSend */, mStartActivity);
    
      final boolean isTaskSwitch = startedTask != prevTopTask;
      mTargetRootTask.startActivityLocked(mStartActivity, topRootTask, newTask, isTaskSwitch,
              mOptions, sourceRecord);
      if (mDoResume) {
          final ActivityRecord topTaskActivity = startedTask.topRunningActivityLocked();
          if (!mTargetRootTask.isTopActivityFocusable()
                  || (topTaskActivity != null && topTaskActivity.isTaskOverlay()
                  && mStartActivity != topTaskActivity)) {
              // 如果activity不是focusable,不能设置为focus,但是仍然要设置可见性。
              mTargetRootTask.ensureActivitiesVisible(null /* starting */,
                      0 /* configChanges */, !PRESERVE_WINDOWS);
              mTargetRootTask.mDisplayContent.executeAppTransition();
          } else {
              // 需要将Task移动到最上面
              if (!mAvoidMoveToFront && mTargetRootTask.isTopActivityFocusable()
                      && !mRootWindowContainer.isTopDisplayFocusedRootTask(mTargetRootTask)) {
                  mTargetRootTask.moveToFront("startActivityInner");
              }
              // 这里resume,详见1.10
              mRootWindowContainer.resumeFocusedTasksTopActivities(
                      mTargetRootTask, mStartActivity, mOptions, mTransientLaunch);
          }
      }
      mRootWindowContainer.updateUserRootTask(mStartActivity.mUserId, mTargetRootTask);
    
      // Update the recent tasks list immediately when the activity starts
      mSupervisor.mRecentTasks.add(startedTask);
      mSupervisor.handleNonResizableTaskIfNeeded(startedTask,
              mPreferredWindowingMode, mPreferredTaskDisplayArea, mTargetRootTask);
    
      // ...画中画相关逻辑
      return START_SUCCESS;
    

    }

1.10 RootWindowContainer.resumeFocusedTasksTopActivities
这里需要resume Activity。最终都会调用需要resume的Activity所在的rootTask的resumeTopActivityUncheckedLocked。

boolean resumeFocusedTasksTopActivities(
        Task targetRootTask, ActivityRecord target, ActivityOptions targetOptions,
        boolean deferPause) {
    // 如果有其他activity还在resume,直接return
    if (!mTaskSupervisor.readyToResume()) {
        return false;
    }

    boolean result = false;
    // 如果focus的task就是targetRootTask,就调用resumeTopActivityUncheckedLocked
    if (targetRootTask != null && (targetRootTask.isTopRootTaskInDisplayArea()
            || getTopDisplayFocusedRootTask() == targetRootTask)) {
        // 详见1.11
        result = targetRootTask.resumeTopActivityUncheckedLocked(target, targetOptions,
                deferPause);
    }
    // 遍历每个DisplayContent
    for (int displayNdx = getChildCount() - 1; displayNdx >= 0; --displayNdx) {
        final DisplayContent display = getChildAt(displayNdx);
        final boolean curResult = result;
        boolean[] resumedOnDisplay = new boolean[1];
        // 遍历所有Task
        display.forAllRootTasks(rootTask -> {
            final ActivityRecord topRunningActivity = rootTask.topRunningActivity();
            if (!rootTask.isFocusableAndVisible() || topRunningActivity == null) {
                return;
            }
            if (rootTask == targetRootTask) {
                // 如果是targetRootTask
                resumedOnDisplay[0] |= curResult;
                return;
            }
            if (topRunningActivity.isState(RESUMED)
                    && topRunningActivity == rootTask.getDisplayArea().topRunningActivity()) {
                rootTask.executeAppTransition(targetOptions);
            } else {
                // 这里会对每个Activity进行判断,如果是target则代表需要resume,会调用Activity对应Task的resumeTopActivityUncheckedLocked,详见1.11
                // 如果activity需要pause,调用scheduleTransaction通知端侧
                resumedOnDisplay[0] |= topRunningActivity.makeActiveIfNeeded(target);
            }
        });
        result |= resumedOnDisplay[0];
        // 前面都没有resume成功
        if (!resumedOnDisplay[0]) {
            final Task focusedRoot = display.getFocusedRootTask();
            // 调用focus task的resumeTopActivityUncheckedLocked
            if (focusedRoot != null) {
                // 详见1.11
                result |= focusedRoot.resumeTopActivityUncheckedLocked(target, targetOptions);
            } else if (targetRootTask == null) {
                // 如果没有focus task,就resume home activity
                result |= resumeHomeActivity(null /* prev */, "no-focusable-task",
                        display.getDefaultTaskDisplayArea());
            }
        }
    }

    return result;
}

1.11 Task.resumeTopActivityUncheckedLocked
如果是leafTask,直接调用resumeTopActivityInnerLocked,否则递归调用resumeTopActivityUncheckedLocked,遍历子节点,最终会调用可以focus并且有RunningActivity的leafTask的resumeTopActivityInnerLocked。

boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options,
        boolean deferPause) {
    // 防止重入
    if (mInResumeTopActivity) {
        return false;
    }

    boolean someActivityResumed = false;
    try {
        mInResumeTopActivity = true;
        // 如果是leafTask,直接调用Task的resumeTopActivityInnerLocked
        if (isLeafTask()) {
            if (isFocusableAndVisible()) {
                // 详见1.12
                someActivityResumed = resumeTopActivityInnerLocked(prev, options, deferPause);
            }
        } else {
            // 否则递归调用resumeTopActivityUncheckedLocked
            int idx = mChildren.size() - 1;
            while (idx >= 0) {
                final Task child = (Task) getChildAt(idx--);
                if (!child.isTopActivityFocusable()) {
                    continue;
                }
                if (child.getVisibility(null /* starting */)
                        != TASK_FRAGMENT_VISIBILITY_VISIBLE) {
                    if (child.topRunningActivity() == null) {
                        continue;
                    }
                    break;
                }

                someActivityResumed |= child.resumeTopActivityUncheckedLocked(prev, options,
                        deferPause);
                if (idx >= mChildren.size()) {
                    idx = mChildren.size() - 1;
                }
            }
        }

        final ActivityRecord next = topRunningActivity(true /* focusableOnly */);
        if (next == null || !next.canTurnScreenOn()) {
            checkReadyForSleep();
        }
    } finally {
        mInResumeTopActivity = false;
    }

    return someActivityResumed;
}

1.12 Task.resumeTopActivityInnerLocked
遍历当前Task的所有的TaskFragment,调用Top且可resume的TaskFragment的resumeTopActivity

private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options,
        boolean deferPause) {
    if (!mAtmService.isBooting() && !mAtmService.isBooted()) {
        return false;
    }

    final ActivityRecord topActivity = topRunningActivity(true /* focusableOnly */);
    if (topActivity == null) {
        return resumeNextFocusableActivityWhenRootTaskIsEmpty(prev, options);
    }

    final boolean[] resumed = new boolean[1];
    final TaskFragment topFragment = topActivity.getTaskFragment();
    // 调用TaskFragment的resumeTopActivity,详见1.13
    resumed[0] = topFragment.resumeTopActivity(prev, options, deferPause);
    forAllLeafTaskFragments(f -> {
        if (topFragment == f) {
            return;
        }
        if (!f.canBeResumed(null /* starting */)) {
            return;
        }
        resumed[0] |= f.resumeTopActivity(prev, options, deferPause);
    }, true);
    return resumed[0];
}

1.13 TaskFragment.resumeTopActivity
首先会检查是否有activity正在pause,如果有就直接返回,等待pause完成再继续操作。
然后需要检查是否需要pause activity,我们知道如果activity A跳转activity B,会先执行A的pause,再resume B,所以这里如果发现之前的activity没有pause,就先执行pause操作。(如果发生了pause操作,就会顺带检查一下ativity B所在的进程是否启动,如果没有启动就会在这里触发启动,并行进行节约时间,关于启动进程的逻辑我们下一个章节再介绍)
如果发现顶部的activity已经pause了(往往是第二次进这个方法,app pause完成后通知systemserver,systemserver重新执行resumeTopActivity),这个时候就可以进行resume操作。
如果要启动的Activity是复用之前已经创建过的,next.attachedToProcess()为true,这时候主要做的事是修改ActivityRecord的状态到RESUMED,更新Activity可见效以及config,然后通知app侧执行对应的声明周期。
而如果没有复用的Activity,这里是刚刚新建的Activity,则会调用startSpecificActivity来启动Activity。
关于通知App更新生命周期LifecycleManager的逻辑我们会单独有一篇文章来介绍。

final boolean resumeTopActivity(ActivityRecord prev, ActivityOptions options,
        boolean deferPause) {
    ActivityRecord next = topRunningActivity(true /* focusableOnly */);
    if (next == null || !next.canResumeByCompat()) {
        return false;
    }

    next.delayedResume = false;

    // ...如果没有正在pause的activty,继续流程

    final TaskDisplayArea taskDisplayArea = getDisplayArea();
    // 如果top activity已经resume,不做什么操作
    if (mResumedActivity == next && next.isState(RESUMED)
            && taskDisplayArea.allResumedActivitiesComplete()) {
        // 确保topactivity visible
        taskDisplayArea.ensureActivitiesVisible(null /* starting */, 0 /* configChanges */,
                false /* preserveWindows */, true /* notifyClients */);
        // 确保切换已经执行
        executeAppTransition(options);

        // ...

        return false;
    }

    // 如果topactivity是paused,并且在sleep,那什么都不用做
    if (mLastPausedActivity == next && shouldSleepOrShutDownActivities()) {
        executeAppTransition(options);
        return false;
    }

    // ...处理多用户情况
    // 从mStoppingActivities remove现在要换新的ActivityRecord
    mTaskSupervisor.mStoppingActivities.remove(next);

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

    ActivityRecord lastResumed = null;
    final Task lastFocusedRootTask = taskDisplayArea.getLastFocusedRootTask();
    if (lastFocusedRootTask != null && lastFocusedRootTask != getRootTaskFragment().asTask()) {
        lastResumed = lastFocusedRootTask.getTopResumedActivity();
    }

    boolean pausing = !deferPause && taskDisplayArea.pauseBackTasks(next);
    if (mResumedActivity != null) {
       // 如果之前的ResumeActivity还没有resume,现在触发pause,详见1.13.1
        pausing |= startPausing(mTaskSupervisor.mUserLeaving, false /* uiSleeping */,
                next, "resumeTopActivity");
    }
    // 如果已经触发pause,进这个分支直接return了,要等pausing完了activity,app回调回来才会进行resume
    if (pausing) {
        if (next.attachedToProcess()) {
            // 更新进程信息,例如adj,启动组件可能需要更新adj
            next.app.updateProcessInfo(false /* updateServiceConnectionActivities */,
                    true /* activityChange */, false /* updateOomAdj */,
                    false /* addPendingTopUid */);
        } else if (!next.isProcessRunning()) {
            // 如果没有绑定进程。那么就需要新启动进程。
            // 这个流程我们下一章再介绍。
            final boolean isTop = this == taskDisplayArea.getFocusedRootTask();
            mAtmService.startProcessAsync(next, false /* knownToBeDead */, isTop,
                    isTop ? HostingRecord.HOSTING_TYPE_NEXT_TOP_ACTIVITY
                            : HostingRecord.HOSTING_TYPE_NEXT_ACTIVITY);
        }
        if (lastResumed != null) {
            lastResumed.setWillCloseOrEnterPip(true);
        }
        return true;
    } else if (mResumedActivity == next && next.isState(RESUMED)
            && taskDisplayArea.allResumedActivitiesComplete()) {
        // 确保AppTrasnsition。
        executeAppTransition(options);
        return true;
    }

    // ...

    // ... 处理动画

    mTaskSupervisor.mNoAnimActivities.clear();
    // 如果需要启动ActivityRecord的app已经绑定进程,这里需要做resume操作了
    // 如果activity没有复用,是新启动的这里一般是false。
    if (next.attachedToProcess()) {

        // mLastPausedActivity
        final boolean lastActivityTranslucent = inMultiWindowMode()
                || mLastPausedActivity != null && !mLastPausedActivity.occludesParent();

        // 设置Activity可见性
        if (!next.isVisibleRequested() || next.mAppStopped || lastActivityTranslucent) {
            next.app.addToPendingTop();
            next.setVisibility(true);
        }

        // 收集app启动速度
        next.startLaunchTickingLocked();

        ActivityRecord lastResumedActivity =
                lastFocusedRootTask == null ? null
                        : lastFocusedRootTask.getTopResumedActivity();
        final ActivityRecord.State lastState = next.getState();

        mAtmService.updateCpuStats();
        // 设置activity状态resume
        next.setState(RESUMED, "resumeTopActivity");

        boolean notUpdated = true;

        if (shouldBeVisible(next)) {
            // 更新activity visible以及配置
            notUpdated = !mRootWindowContainer.ensureVisibilityAndConfig(next, getDisplayId(),
                    true /* markFrozenIfConfigChanged */, false /* deferResume */);
        }

        if (notUpdated) {
            ActivityRecord nextNext = topRunningActivity();
            if (nextNext != next) {

                mTaskSupervisor.scheduleResumeTopActivities();
            }
            if (!next.isVisibleRequested() || next.mAppStopped) {
                next.setVisibility(true);
            }
            next.completeResumeLocked();
            return true;
        }

        try {
            // 回调app侧,通知app activity需要到resume状态。
            final ClientTransaction transaction =
                    ClientTransaction.obtain(next.app.getThread(), next.token);
            // ...
            transaction.setLifecycleStateRequest(
                    ResumeActivityItem.obtain(next.app.getReportedProcState(),
                            dc.isNextTransitionForward(), next.shouldSendCompatFakeFocus()));
            mAtmService.getLifecycleManager().scheduleTransaction(transaction);
        } catch (Exception e) {
            // Whoops, need to restart this activity!
            ProtoLog.v(WM_DEBUG_STATES, "Resume failed; resetting state to %s: "
                    + "%s", 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 && lastFocusedRootTask != null
                    && lastFocusedRootTask.isTopRootTaskInDisplayArea()) {
                next.showStartingWindow(false /* taskSwitch */);
            }
            mTaskSupervisor.startSpecificActivity(next, true, false);
            return true;
        }

        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);
            next.finishIfPossible("resume-exception", true /* oomAdj */);
            return true;
        }
    } else {
        if (!next.hasBeenLaunched) {
            next.hasBeenLaunched = true;
        } else {
            if (SHOW_APP_STARTING_PREVIEW) {
                next.showStartingWindow(false /* taskSwich */);
            }
        }
        // 正常新启动Activity而不是复用会走这里,详见1.14
        mTaskSupervisor.startSpecificActivity(next, true, true);
    }

    return true;
}

1.13.1 TaskFragment.startPausing
更新需要pause的ActivityRecord状态到PAUSING,通知app侧进行对应的生命周期操作。
如果pause到Activity对应的进程已经不在了,就直接调用resumeFocusedTasksTopActivities继续唤醒topActivity的流程。
否则等待app pause流程完成后,app会回调system_server,最终也会走到completePause,里面会将ActivityRecord状态改为PAUSED,并且重新调用resumeFocusedTasksTopActivities。(关于通知app的生命周期以及app回调流程,我们会单独有一篇文章来介绍)

boolean startPausing(boolean userLeaving, boolean uiSleeping, ActivityRecord resuming,
        String reason) {
    // ...
    // ... 合理性检查,如正在暂停的activity不能是我们正在唤醒的activity resuming

    ProtoLog.v(WM_DEBUG_STATES, "Moving to PAUSING: %s", prev);
    mPausingActivity = prev;
    mLastPausedActivity = prev;
    if (!prev.finishing && prev.isNoHistory()
            && !mTaskSupervisor.mNoHistoryActivities.contains(prev)) {
        mTaskSupervisor.mNoHistoryActivities.add(prev);
    }
    // 修改状态为PAUSING
    prev.setState(PAUSING, "startPausingLocked");
    prev.getTask().touchActiveTime();

    mAtmService.updateCpuStats();

    boolean pauseImmediately = false;
    boolean shouldAutoPip = false;
    if (resuming != null) {
        // ...画中画相关逻辑 
    }

    if (prev.attachedToProcess()) {
        if (shouldAutoPip) {
            prev.mPauseSchedulePendingForPip = true;
            boolean didAutoPip = mAtmService.enterPictureInPictureMode(
                    prev, prev.pictureInPictureArgs, false /* fromClient */);
        } else {
            // 通过getLifecycleManager().scheduleTransaction通知app进行pause到生命周期
            schedulePauseActivity(prev, userLeaving, pauseImmediately,
                    false /* autoEnteringPip */, reason);
        }
    } else {
        mPausingActivity = null;
        mLastPausedActivity = null;
        mTaskSupervisor.mNoHistoryActivities.remove(prev);
    }
    // ...

    // If already entered PIP mode, no need to keep pausing.
    if (mPausingActivity != null) {
        // ... 

        if (pauseImmediately) {
            // 如果需要立刻完成pause,不等待app侧完成pause再进行回调,这里直接执行completePause继续唤醒流程
            // completePause会将ActivityRecord状态改为PAUSED,并且重新调用resumeFocusedTasksTopActivities,
            completePause(false, resuming);
            return false;
        } else {
            prev.schedulePauseTimeout();
            if (!uiSleeping) {
                mTransitionController.setReady(this, false /* ready */);
            }
            return true;
        }

    } else {
        // ... 直接调用resumeFocusedTasksTopActivities继续唤醒流程
        if (resuming == null) {
            mRootWindowContainer.resumeFocusedTasksTopActivities();
        }
        return false;
    }
}

1.14 ActivityTaskSupervisor.startSpecificActivity
如果app进程已经启动,则会调用realStartActivityLocked进行Activity的启动,否则会调用startProcessAsync启动对应进程,启动进程的流程我们下一篇文章再介绍。

void startSpecificActivity(ActivityRecord r, boolean andResume, boolean checkConfig) {
    final WindowProcessController wpc =
            mService.getProcessController(r.processName, r.info.applicationInfo.uid);

    boolean knownToBeDead = false;
    // 如果app进程已经启动,则会调用realStartActivityLocked来启动activity,详见1.15
    if (wpc != null && wpc.hasThread()) {
        // ...
        realStartActivityLocked(r, wpc, andResume, checkConfig);
        return;
        // ...
    }
    // ...

    final boolean isTop = andResume && r.isTopRunningActivity();
    // 否则会触发启动进程的流程。
    mService.startProcessAsync(r, knownToBeDead, isTop,
            isTop ? HostingRecord.HOSTING_TYPE_TOP_ACTIVITY
                    : HostingRecord.HOSTING_TYPE_ACTIVITY);
}

1.15 ActivityTaskSupervisor.realStartActivityLocked
主要通过getLifecycleManager通知app启动activity。最后还会调用rootTask.minimalResumeActivityLocked来设置Activity的可见性。

boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,
        boolean andResume, boolean checkConfig) throws RemoteException {

    // ...检测所有Activity pause完成

    final Task task = r.getTask();
    final Task rootTask = task.getRootTask();


    try {
        r.startFreezingScreenLocked(proc, 0);

        // schedule launch ticks to collect information about slow apps.
        r.startLaunchTickingLocked();
        r.lastLaunchTime = SystemClock.uptimeMillis();
        r.setProcess(proc);

        if (andResume && !r.canResumeByCompat()) {
            andResume = false;
        }

        r.notifyUnknownVisibilityLaunchedForKeyguardTransition();

        // ...
        if (checkConfig) {
            // 更新Activity visible以及configuration
            mRootWindowContainer.ensureVisibilityAndConfig(r, r.getDisplayId(),
                    false /* markFrozenIfConfigChanged */, true /* deferResume */);
        }

        // ...
        try {
            // ...
            // 通知app侧创建启动activity。  
            final ClientTransaction clientTransaction = ClientTransaction.obtain(
                    proc.getThread(), r.token);

            final boolean isTransitionForward = r.isTransitionForward();
            final IBinder fragmentToken = r.getTaskFragment().getFragmentToken();

            final int deviceId = getDeviceIdForDisplayId(r.getDisplayId());
            clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),
                    System.identityHashCode(r), r.info, 
                    mergedConfiguration.getGlobalConfiguration(),
                    mergedConfiguration.getOverrideConfiguration(), deviceId,
                    r.getFilteredReferrer(r.launchedFromPackage), task.voiceInteractor,
                    proc.getReportedProcState(), r.getSavedState(), r.getPersistentSavedState(),
                    results, newIntents, r.takeOptions(), isTransitionForward,
                    proc.createProfilerInfoIfNeeded(), r.assistToken, activityClientController,
                    r.shareableActivityToken, r.getLaunchedFromBubble(), fragmentToken));

            final ActivityLifecycleItem lifecycleItem;
            if (andResume) {
                lifecycleItem = ResumeActivityItem.obtain(isTransitionForward,
                        r.shouldSendCompatFakeFocus());
            } else {
                lifecycleItem = PauseActivityItem.obtain();
            }
            clientTransaction.setLifecycleStateRequest(lifecycleItem);
            
            mService.getLifecycleManager().scheduleTransaction(clientTransaction);
            // ... 
        }
        // ...

    if (andResume && readyToResume()) {
        // 详见1.16
        rootTask.minimalResumeActivityLocked(r);
    }
}

1.16 Task.minimalResumeActivityLocked

void minimalResumeActivityLocked(ActivityRecord r) {
    ProtoLog.v(WM_DEBUG_STATES, "Moving to RESUMED: %s (starting new instance) "
            + "callers=%s", r, Debug.getCallers(5));
    r.setState(RESUMED, "minimalResumeActivityLocked");
    // 详见1.17
    r.completeResumeLocked();
}

1.17 ActivityRecord.completeResumeLocked
这个方法其实只要resume了Activity的路径都会走到。
我们的主要关注更新可见性相关逻辑,其余的逻辑就忽略了。我们知道Activity可见状态是resume的时候,所以在这里会更新可见性。
通过setVisibility设置ActivityRecord可见,然后调用reportResumedActivityLocked。

void completeResumeLocked() {
    final boolean wasVisible = mVisibleRequested;
    setVisibility(true);
    // ...
    // 详见1.18
    mTaskSupervisor.reportResumedActivityLocked(this);

    // ...
}

1.18 ActivityTaskSupervisor.reportResumedActivityLocked

boolean reportResumedActivityLocked(ActivityRecord r) {
    // resumed的Activity不能在StoppingActivities集合里
    mStoppingActivities.remove(r);

    final Task rootTask = r.getRootTask();
    if (rootTask.getDisplayArea().allResumedActivitiesComplete()) {
        // 这个方法用来更新Activity的可见性,详见1.19
        mRootWindowContainer.ensureActivitiesVisible(null, 0, !PRESERVE_WINDOWS);
        mRootWindowContainer.executeAppTransitionForAllDisplay();
        return true;
    }
    return false;
}

1.19 Task.ensureActivitiesVisible
RootWindowContainer.ensureActivitiesVisible会递归遍历DisplayContent,调用DisplayContent.ensureActivitiesVisible
同样DisplayContent会调用RootTask的ensureActivitiesVisible
我们直接看Task.ensureActivitiesVisible
遍历LeafTask,调用updateActivityVisibilities方法。

void ensureActivitiesVisible(@Nullable ActivityRecord starting, int configChanges,
        boolean preserveWindows, boolean notifyClients) {
    mTaskSupervisor.beginActivityVisibilityUpdate();
    try {
        forAllLeafTasks(task -> {
            // 详见1.20
            task.updateActivityVisibilities(starting, configChanges, preserveWindows,
                    notifyClients);
        }, true /* traverseTopToBottom */);

        if (mTranslucentActivityWaiting != null &&
                mUndrawnActivitiesBelowTopTranslucent.isEmpty()) {
            notifyActivityDrawnLocked(null);
        }
    } finally {
        mTaskSupervisor.endActivityVisibilityUpdate();
    }
}

1.20 TaskFragment.updateActivityVisibilities
只是调用了mEnsureActivitiesVisibleHelper.process

final void updateActivityVisibilities(@Nullable ActivityRecord starting, int configChanges,
        boolean preserveWindows, boolean notifyClients) {
    mTaskSupervisor.beginActivityVisibilityUpdate();
    try {
        // 详见1.21
        mEnsureActivitiesVisibleHelper.process(
                starting, configChanges, preserveWindows, notifyClients);
    } finally {
        mTaskSupervisor.endActivityVisibilityUpdate();
    }
}

1.21 EnsureActivitiesVisibleHelper.process
递归遍历所有TaskFragment.updateActivityVisibilities,如果TaskFragment有activity,则更新activity可见性状态。

void process(@Nullable ActivityRecord starting, int configChanges, boolean preserveWindows,
        boolean notifyClients) {
    reset(starting, configChanges, preserveWindows, notifyClients);

    if (mTopRunningActivity != null && mTaskFragment.asTask() != null) {
        // TODO(14709632): Check if this needed to be implemented in TaskFragment.
        mTaskFragment.asTask().checkTranslucentActivityWaiting(mTopRunningActivity);
    }

    // 判断一些不应resumeActivity的情况。  
    // 我们不应该恢复在后面启动的Activity,因为这些活动实际上在其他全屏的Activity后面,但仍然需要可见(例如执行Recents动画)。
    final boolean resumeTopActivity = mTopRunningActivity != null
            && !mTopRunningActivity.mLaunchTaskBehind
            && mTaskFragment.canBeResumed(starting)
            && (starting == null || !starting.isDescendantOf(mTaskFragment));

    ArrayList<TaskFragment> adjacentTaskFragments = null;
    for (int i = mTaskFragment.mChildren.size() - 1; i >= 0; --i) {
        final WindowContainer child = mTaskFragment.mChildren.get(i);
        final TaskFragment childTaskFragment = child.asTaskFragment();
        if (childTaskFragment != null
                && childTaskFragment.getTopNonFinishingActivity() != null) {
            // 递归遍历调用子TaskFragment.updateActivityVisibilities
            childTaskFragment.updateActivityVisibilities(starting, configChanges,
                    preserveWindows, notifyClients);
            // 判断当前Task边界是否和父Task边界相同,如果相同,且不透明,则他完全遮盖了下面的兄弟Task
            mBehindFullyOccludedContainer |=
                    (childTaskFragment.getBounds().equals(mTaskFragment.getBounds())
                            && !childTaskFragment.isTranslucent(starting));
            if (mAboveTop && mTopRunningActivity.getTaskFragment() == childTaskFragment) {
                mAboveTop = false;
            }
            // 如果之前的Task已经全部遮盖了,就直接continue
            if (mBehindFullyOccludedContainer) {
                continue;
            }

            if (adjacentTaskFragments != null && adjacentTaskFragments.contains(
                    childTaskFragment)) {
                if (!childTaskFragment.isTranslucent(starting)
                        && !childTaskFragment.getAdjacentTaskFragment().isTranslucent(
                                starting)) {
                    // Everything behind two adjacent TaskFragments are occluded.
                    mBehindFullyOccludedContainer = true;
                }
                continue;
            }

            final TaskFragment adjacentTaskFrag = childTaskFragment.getAdjacentTaskFragment();
            if (adjacentTaskFrag != null) {
                if (adjacentTaskFragments == null) {
                    adjacentTaskFragments = new ArrayList<>();
                }
                adjacentTaskFragments.add(adjacentTaskFrag);
            }
        } else if (child.asActivityRecord() != null) {
            // 设置activity visible state,详见1.22
            setActivityVisibilityState(child.asActivityRecord(), starting, resumeTopActivity);
        }
    }
}

1.22 EnsureActivitiesVisibleHelper.setActivityVisibilityState
判断activity是否可见,如果是可见的,则需要设置他的可见状态。
针对不同情况有不同的处理,如果可见的activity还没有attachedToProcess,则调用makeVisibleAndRestartIfNeeded,会设置Activity可见,且如果正在starting的Activity不是当前正在设置可见的Activity,还会重新调用startSpecificActivity来启动Activity。
而其他情况则调用makeActiveIfNeeded或者makeVisibleIfNeeded设置Activity可见,makeVisibleIfNeeded最终也会调用到makeActiveIfNeeded,而makeActiveIfNeeded我们前面已经介绍过了。1.10里也调用这个方法。会重新走上面的流程,而在1.13里如果Activity已经创建过,则会走另一个分支,直接设置Activity可见,通知app侧activity resume的生命周期。

private void setActivityVisibilityState(ActivityRecord r, ActivityRecord starting,
        final boolean resumeTopActivity) {
    final boolean isTop = r == mTopRunningActivity;
    if (mAboveTop && !isTop) {
        // 如果不是最上层的activity,设置不可见
        r.makeInvisible();
        return;
    }
    mAboveTop = false;

    r.updateVisibilityIgnoringKeyguard(mBehindFullyOccludedContainer);
    // 计算Activity是否可见
    final boolean reallyVisible = r.shouldBeVisibleUnchecked();

    // Check whether activity should be visible without Keyguard influence
    if (r.visibleIgnoringKeyguard) {
        if (r.occludesParent()) {
            mBehindFullyOccludedContainer = true;
        } else {
            mBehindFullyOccludedContainer = false;
        }
    } else if (r.isState(INITIALIZING)) {
        r.cancelInitializing();
    }

    if (reallyVisible) {
        if (r.finishing) {
            return;
        }

        if (r != mStarting && mNotifyClients) {
            r.ensureActivityConfiguration(0 /* globalChanges */, mPreserveWindows,
                    true /* ignoreVisibility */);
        }
        // 如果ActivityRecord还没有attch到进程上
        if (!r.attachedToProcess()) {
            // 设置activity visible
            // 且如果当前需要设置可见的activity不是正在starting的activity,就会调用startSpecificActivity去启动当前设置可见的activity
            makeVisibleAndRestartIfNeeded(mStarting, mConfigChanges,
                    resumeTopActivity && isTop, r);
        } else if (r.isVisibleRequested()) {
            if (r.mClientVisibilityDeferred && mNotifyClients) {
                // 这个方法之前提过,在1.10的方法中也调用了该方法。
                // 如果需要走会resumeTopActivity的流程,相当于重新走了上面的流程,只是如果activity已经构建,在1.13中,会走另一条分支,直接通知app侧resume activity,同时会通知client。而不是走startSpecificActivity流程了。
                r.makeActiveIfNeeded(r.mClientVisibilityDeferred ? null : starting);
                r.mClientVisibilityDeferred = false;
            }

            r.handleAlreadyVisible();
            if (mNotifyClients) {
                r.makeActiveIfNeeded(mStarting);
            }
        } else {
            // mNotifyClients为true,则也会调用到makeActiveIfNeeded,否则设置mClientVisibilityDeferred为true,推迟操作。
            r.makeVisibleIfNeeded(mStarting, mNotifyClients);
        }
        // Aggregate current change flags.
        mConfigChanges |= r.configChangeFlags;
    } else {
        // 否者设置不可见
        r.makeInvisible();
    }

    if (!mBehindFullyOccludedContainer && mTaskFragment.isActivityTypeHome()
            && r.isRootOfTask()) {
        mBehindFullyOccludedContainer = true;
    }
}

小结

Activity的启动流程非常长,核心思想主要是两个,一个是处理WMS的窗口层次结构,在WMS树上加上新增的ActivityRecord(如需要可能还有Task),或者是找到复用的ActivityRecord;另一个则是需要处理AMS侧activity生命周期以及可见性相关的逻辑。
一个未启动的应用首次创建Activity是会走启动进程流程的,与当前的逻辑略有不同,我们下一篇文章来介绍。
还有app侧对生命周期的控制,我们在下下篇文章中介绍。


原文地址:https://blog.csdn.net/weixin_43833152/article/details/142303208

免责声明:本站文章内容转载自网络资源,如本站内容侵犯了原著者的合法权益,可联系本站删除。更多内容请关注自学内容网(zxcms.com)!