ActivityRecord(ActivityManagerService _service, ProcessRecord _caller,
      int _launchedFromUid, String _launchedFromPackage, Intent _intent, String _resolvedType,
      ActivityInfo aInfo, Configuration _configuration,
      ActivityRecord _resultTo, String _resultWho, int _reqCode,
      boolean _componentSpecified, ActivityStackSupervisor supervisor,
      ActivityContainer container, Bundle options) {
    service = _service; // AMS对象
    appToken = new Token(this); //appToken可以进行跨进程传递，标识一个AR对象
    info = aInfo; //从AndroidManifest.xml中解析得到的Activity信息
    launchedFromUid = _launchedFromUid; //譬如从浏览器启动当前AR，那么该属性记录的就是浏览器的UID
    launchedFromPackage = _launchedFromPackage;
    userId = UserHandle.getUserId(aInfo.applicationInfo.uid);
    intent = _intent; //启动当前AR的Intent
    shortComponentName = _intent.getComponent().flattenToShortString();
    resolvedType = _resolvedType;
    componentSpecified = _componentSpecified;
    configuration = _configuration;
    resultTo = _resultTo; //记录上一个AR对象
    resultWho = _resultWho; //reslutTo的字符串标识
    requestCode = _reqCode; //上一个AR对象设定的Request Code
    state = ActivityState.INITIALIZING; //AR的状态，Activity调度时发生改变
    frontOfTask = false; //是否处于Task的根部，调整任务栈中AR顺序时，可能发生改变
    launchFailed = false;
    stopped = false; //pause操作完成状态位
    delayedResume = false;
    finishing = false; //stoped到finished之间的过渡状态位
    configDestroy = false;
    keysPaused = false; //如果置为true，则当前AR不再接受用户输入
    inHistory = false; //将AR压入任务栈后，该状态位被置为true
    visible = true;
    waitingVisible = false;
    nowVisible = false;
    idle = false;
    hasBeenLaunched = false;
    mStackSupervisor = supervisor;
    mInitialActivityContainer = container;
    if (options != null) {
        pendingOptions = new ActivityOptions(options);
        mLaunchTaskBehind = pendingOptions.getLaunchTaskBehind();
    }
    haveState = true;
    if (aInfo != null) {
        //根据aInfo给realActivity, taskAffinity, processName等属性赋值
        ...
    } else {
        //没有aInfo的情况下，赋予默认值
        realActivity = null;
        taskAffinity = null;
        stateNotNeeded = false;
        appInfo = null;
        processName = null;
        packageName = null;
        fullscreen = true;
        noDisplay = false;
        mActivityType = APPLICATION_ACTIVITY_TYPE;
        immersive = false;
    }
}

void addActivityToTop(ActivityRecord r) {
    addActivityAtIndex(mActivities.size(), r);
}

void addActivityAtIndex(int index, ActivityRecord r) {
    // 1. 移除已有的ActivityRecord对象
    if (!mActivities.remove(r) && r.fullscreen) {
        numFullscreen++;
    }
    // 2. 根据任务栈是否为空，设置状态
    if (mActivities.isEmpty()) {
        taskType = r.mActivityType;
        isPersistable = r.isPersistable();
        mCallingUid = r.launchedFromUid;
        mCallingPackage = r.launchedFromPackage;
        maxRecents = Math.min(Math.max(r.info.maxRecents, 1),
                ActivityManager.getMaxAppRecentsLimitStatic());
    } else {
        r.mActivityType = taskType;
    }
    // 3. 在指定的位置添加ActivityRecord
    mActivities.add(index, r);
    // 4. 更新任务栈关联的Intent
    updateEffectiveIntent();
    ...
}

ActivityRecord getTopActivity() {
    for (int i = mActivities.size() - 1; i >= 0; --i) {
        final ActivityRecord r = mActivities.get(i);
        if (r.finishing) {
            continue;
        }
        return r;
    }
    return null;
}

ActivityRecord topRunningActivityLocked(ActivityRecord notTop) {
    for (int activityNdx = mActivities.size() - 1; activityNdx >= 0; --activityNdx) {
        ActivityRecord r = mActivities.get(activityNdx);
        // 除了要求ActivityRecord不是finishing状态以外，还要求不是当前给定输入的ActivityRecord
        if (!r.finishing && r != notTop && stack.okToShowLocked(r)) {
            return r;
        }
    }
}

final void moveActivityToFrontLocked(ActivityRecord newTop) {
    mActivities.remove(newTop);
    mActivities.add(newTop);
    updateEffectiveIntent();
    setFrontOfTask();
}

void updateEffectiveIntent() {
    final int effectiveRootIndex = findEffectiveRootIndex();
    final ActivityRecord r = mActivities.get(effectiveRootIndex);
    setIntent(r);
}

void setIntent(ActivityRecord r) {
    setIntent(r.intent, r.info);
    mCallingUid = r.launchedFromUid;
    mCallingPackage = r.launchedFromPackage;
}

final void setFrontOfTask() {
    boolean foundFront = false;
    final int numActivities = mActivities.size();
    for (int activityNdx = 0; activityNdx < numActivities; ++activityNdx) {
        // 从栈底往上遍历
        final ActivityRecord r = mActivities.get(activityNdx);
        if (foundFront || r.finishing) {
            // 其他ActivityRecord的这个属性都置为false
            r.frontOfTask = false;
        } else {
            // 不为finishing状态，表示已经找到了front的ActivityRecord
            r.frontOfTask = true;
            foundFront = true;
        }

    if (!foundFront && numActivities > 0) {
        mActivities.get(0).frontOfTask = true;
    }
}

enum ActivityState {
    INITIALIZING,
    RESUMED,
    PAUSING,
    PAUSED,
    STOPPING,
    STOPPED,
    FINISHING,
    DESTROYING,
    DESTROYED
}

ActivityRecord findTaskLocked(ActivityRecord target) {
    ...
    for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
        final TaskRecord task = mTaskHistory.get(taskNdx);
        ...
        final ActivityRecord r = task.getTopActivity();
        ...
        final Intent taskIntent = task.intent;
        final Intent affinityIntent = task.affinityIntent;
        ...
        if (!isDocument && !taskIsDocument && task.rootAffinity != null) {
            if (task.rootAffinity.equals(target.taskAffinity)) {
                return r;
            }
        } else if (taskIntent != null && taskIntent.getComponent() != null &&
            taskIntent.getComponent().compareTo(cls) == 0 &&
            Objects.equals(documentData, taskDocumentData)) {
            return r;
        } else if if (affinityIntent != null && affinityIntent.getComponent() != null &&
            affinityIntent.getComponent().compareTo(cls) == 0 &&
            Objects.equals(documentData, taskDocumentData)) {
            return r
        }
        ...
    }
    return null;
}

final void moveToFront(String reason) {
    if (isAttached()) {
        if (isOnHomeDisplay()) {
            mStackSupervisor.moveHomeStack(isHomeStack(), reason);
        }
        mStacks.remove(this);
        mStacks.add(this);
        final TaskRecord task = topTask();
        if (task != null) {
            mWindowManager.moveTaskToTop(task.taskId);
        }
    }
}

final void moveTaskToFrontLocked(TaskRecord tr, ActivityRecord source, Bundle options,
            String reason) {
    final int numTasks = mTaskHistory.size();
    final int index = mTaskHistory.indexOf(tr);
    // 判定ActivityStack是否需要挪动任务栈
    if (numTasks == 0 || index < 0)  {
        ...
        return;
    }
    // 调整ActivityStack
    insertTaskAtTop(tr);
    moveToFront(reason);
    ...
    // 将栈顶的Activity置为Resumed状态
    mStackSupervisor.resumeTopActivitiesLocked();
}

final void setFocusedActivityLocked(ActivityRecord r, String reason) {
    if (mFocusedActivity != r) {
        mFocusedActivity = r;
        ...
        mStackSupervisor.setFocusedStack(r, reason + " setFocusedActivity");
        if (r != null) {
            mWindowManager.setFocusedApp(r.appToken, true);
        }
        applyUpdateLockStateLocked(r);
    }
    ...
}

void setFocusedStack(ActivityRecord r, String reason) {
    if (r != null) {
        final TaskRecord task = r.task;
        // 判断输入的ActivityRecord是否为HomeActivity
        boolean isHomeActivity = !r.isApplicationActivity();
        if (!isHomeActivity && task != null) {
            isHomeActivity = !task.isApplicationTask();
        }
        if (!isHomeActivity && task != null) {
            final ActivityRecord parent = task.stack.mActivityContainer.mParentActivity;
            isHomeActivity = parent != null && parent.isHomeActivity();
        }
        moveHomeStack(isHomeActivity, reason);
    }
}

void moveHomeStack(boolean toFront, String reason) {
    // 1. 获取当前的Top Stack
    ArrayList<ActivityStack> stacks = mHomeStack.mStacks;
    final int topNdx = stacks.size() - 1;
    if (topNdx <= 0) {
        return;
    }
    ActivityStack topStack = stacks.get(topNdx);
    // 2. 判定HomeStack是否需要挪动
    final boolean homeInFront = topStack == mHomeStack;
    if (homeInFront != toFront) {
        mLastFocusedStack = topStack;
        stacks.remove(mHomeStack);
        stacks.add(toFront ? topNdx : 0, mHomeStack);
        mFocusedStack = stacks.get(topNdx);
    }
    ...
    // 3. 判定当前AMS是否完成启动
    if (mService.mBooting || !mService.mBooted) {
        final ActivityRecord r = topRunningActivityLocked();
        if (r != null && r.idle) {
            checkFinishBootingLocked();
        }
    }
}

private void startBootstrapServices() {
    ...
    mActivityManagerService = mSystemServiceManager.startService(
        ActivityManagerService.Lifecycle.class).getService();
    ...
}

public ActivityManagerService(Context systemContext) {
    ...
    mStackSupervisor = new ActivityStackSupervisor(this);
    ...
}

public void handleDisplayAddedLocked(int displayId) {
    ...
    newDisplay = mActivityDisplays.get(displayId) == null;
    if (newDisplay) {
        ActivityDisplay activityDisplay = new ActivityDisplay(displayId);
        ...
    }
    ...
}

private int createStackOnDisplay(int stackId, int displayId) {
    ...
    ActivityContainer activityContainer = new ActivityContainer(stackId);
    mActivityContainers.put(stackId, activityContainer);
    activityContainer.attachToDisplayLocked(activityDisplay);
    return stackId;
}

final ProcessRecord newProcessRecordLocked(ApplicationInfo info, String customProcess,
        boolean isolated, int isolatedUid) {
    ...
    return new ProcessRecord(stats, info, proc, uid);
}

final int startActivityLocked(IApplicationThread caller, ...) {
   ...
   ActivityRecord r  = new ActivityRecord(mService, callerApp, callingUid, callingPackage,
           intent, resolvedType, aInfo, mService.mConfiguration, resultRecord, resultWho,
           requestCode, componentSpecified, this, container, options);
   ...
}

TaskRecord createTaskRecord(int taskId, ActivityInfo info, Intent intent,
        IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
        boolean toTop) {
    TaskRecord task = new TaskRecord(mService, taskId, info, intent, voiceSession,
            voiceInteractor);
    addTask(task, toTop, false);
    return task;
}

void setTask(TaskRecord newTask, TaskRecord taskToAffiliateWith) {
    ...
    task = newTask;
    setTaskToAffiliateWith(taskToAffiliateWith);
}

void startSpecificActivityLocked(ActivityRecord r,
        boolean andResume, boolean checkConfig) {
    ProcessRecord app = mService.getProcessRecordLocked(r.processName,
            r.info.applicationInfo.uid, true);
    ...
    app.addPackage(r.info.packageName, r.info.applicationInfo.versionCode,
    ...
}