程序博客网 > 与犯罪的战争 知乎

Android6.0 AMS启动Activity(四) AMS内部成员变量

来源：互联网 发布：与犯罪的战争 知乎 编辑：程序博客网 时间：2024/06/13 00:59

之前在分析AMS和ActivityStackSupervisor和ActivityStack对一些成员变量比较模糊，这篇博客主要讲下这些成员变量


一、AMS成员变量的初始化

我们先来看看AMS在systemServer的构造，初始化，先是调用了在SystemServiceManager中调用了AMS的构造函数。

[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. mActivityManagerService = mSystemServiceManager.startService(  
  2.         ActivityManagerService.Lifecycle.class).getService();  
  3. mActivityManagerService.setSystemServiceManager(mSystemServiceManager);  
  4. mActivityManagerService.setInstaller(installer);  

构造函数主要是初始化了一些成员变量，下面我们来看如下两个成员变量，mRecenTasks代表最近的几个task

[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. mRecentTasks = new RecentTasks(this);  
  2. mStackSupervisor = new ActivityStackSupervisor(this, mRecentTasks);  

在ActivityStackSupervisor的构造函数就是创建了一个handler，然后把service和recentTasks保存在成员变量中。

[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. public ActivityStackSupervisor(ActivityManagerService service, RecentTasks recentTasks) {  
  2.     mService = service;  
  3.     mRecentTasks = recentTasks;  
  4.     mHandler = new ActivityStackSupervisorHandler(mService.mHandler.getLooper());  
  5. }  

随后在SystemServer中会调用如下代码，就是把SystemServer这个进程保存进程信息。

[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. mActivityManagerService.setSystemProcess();  

再后面我们看下如下代码，把WMS对象设置到AMS中去。

[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. mActivityManagerService.setWindowManager(wm);  
看下AMS的setWindowManager函数，保存了WMS，然后调用了ActivityStackSupervisor的setWindowManager函数。
[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. public void setWindowManager(WindowManagerService wm) {  
  2.     mWindowManager = wm;  
  3.     mStackSupervisor.setWindowManager(wm);  
  4. }  
看下ActivityStackSupervisor的setWindowManager函数，在这个函数中先获取所有的显示设备，然后一一对应创建ActivityDisplay对象，接着调用createStackOnDisplay对象创建获取displayId的ActivityContainer，在ActivityContainer中又创建了ActivitStack对象。
[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. void setWindowManager(WindowManagerService wm) {  
  2.     synchronized (mService) {  
  3.         mWindowManager = wm;  
  4.   
  5.         mDisplayManager =  
  6.                 (DisplayManager)mService.mContext.getSystemService(Context.DISPLAY_SERVICE);  
  7.         mDisplayManager.registerDisplayListener(this, null);  
  8.   
  9.         Display[] displays = mDisplayManager.getDisplays();//获取所有的显示设备  
  10.         for (int displayNdx = displays.length - 1; displayNdx >= 0; --displayNdx) {  
  11.             final int displayId = displays[displayNdx].getDisplayId();  
  12.             ActivityDisplay activityDisplay = new ActivityDisplay(displayId);//每一个显示设备创建一个对象的ActivityDisplay  
  13.             if (activityDisplay.mDisplay == null) {  
  14.                 throw new IllegalStateException("Default Display does not exist");  
  15.             }  
  16.             mActivityDisplays.put(displayId, activityDisplay);  
  17.         }  
  18.   
  19.         createStackOnDisplay(HOME_STACK_ID, Display.DEFAULT_DISPLAY);//创建ActivityStack  
  20.         mHomeStack = mFocusedStack = mLastFocusedStack = getStack(HOME_STACK_ID);  
  21.   
  22.         mInputManagerInternal = LocalServices.getService(InputManagerInternal.class);  
  23.   
  24.         // Initialize this here, now that we can get a valid reference to PackageManager.  
  25.         mLeanbackOnlyDevice = isLeanbackOnlyDevice();  
  26.     }  
  27. }  
在createStackOnDisplay函数，会获取传入的displayId获取activityDisplay ，然后创建一个ActivityContainer在这个对象的构造函数中会创建一个ActivityStack对象，最后调用attachToDisplayLocked把这个activityDisplay和activityContainer 联系起来。
[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. ActivityStack createStackOnDisplay(int stackId, int displayId) {  
  2.     ActivityDisplay activityDisplay = mActivityDisplays.get(displayId);  
  3.     if (activityDisplay == null) {  
  4.         return null;  
  5.     }  
  6.   
  7.     ActivityContainer activityContainer = new ActivityContainer(stackId);  
  8.     mActivityContainers.put(stackId, activityContainer);//把activityContainer放入mActivityContainers中  
  9.     activityContainer.attachToDisplayLocked(activityDisplay);  
  10.     return activityContainer.mStack;  
  11. }  

我们再来看下ActivityContainer 的attachToDisplayLocked函数，ActivityStack的mStacks是每一个显示设备上所有的ActivityStack。

[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. void attachToDisplayLocked(ActivityDisplay activityDisplay) {  
  2.     if (DEBUG_STACK) Slog.d(TAG_STACK, "attachToDisplayLocked: " + this  
  3.             + " to display=" + activityDisplay);  
  4.     mActivityDisplay = activityDisplay;  
  5.     mStack.mDisplayId = activityDisplay.mDisplayId;  
  6.     mStack.mStacks = activityDisplay.mStacks;  
  7.   
  8.     activityDisplay.attachActivities(mStack);  
  9.     mWindowManager.attachStack(mStackId, activityDisplay.mDisplayId);  
  10. }  
我们再来看ActivityDisplay的attachActivities函数，把当前的ActivityStack放在ActivityDisplay的mStacks中。
[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. void attachActivities(ActivityStack stack) {  
  2.     if (DEBUG_STACK) Slog.v(TAG_STACK,  
  3.             "attachActivities: attaching " + stack + " to displayId=" + mDisplayId);  
  4.     mStacks.add(stack);  
  5. }  

所以每一个ActivityStack的mStacks变量代表的是这个显示设备上所有的ActivityStack。


然后我们再来看下面这句，调用getStack，传入的stackId就是HOME_STACK_ID，这样刚才创建的ActivityStack就赋给这些成员变量。这里mHomeStack就不会改变了，然后mFocusedStack和mLastFocusedStack会改变的。

[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. mHomeStack = mFocusedStack = mLastFocusedStack = getStack(HOME_STACK_ID);  


二、startActivity流程

之前分析startActivity的时候，最后在ActivityStackSupervisor的startActivityUncheckedLocked函数分为两种情况，一种就是需要新建TaskRecord，另一种不需要新建TaskRecord。

2.1 需要创建新TaskRecord

现在我们再来看startActivity流程，回顾下在ActivityStackSupervisor的startActivityUncheckedLocked函数中，当需要创建一个新的task的时候，到如下代码线调用computeStackFocus函数创建了一个ActivityStack，然后调用ActivityStack的moveToFront函数

[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. if (r.resultTo == null && inTask == null && !addingToTask  
  2.         && (launchFlags & Intent.FLAG_ACTIVITY_NEW_TASK) != 0) {  
  3.     newTask = true;  
  4.     targetStack = computeStackFocus(r, newTask);//创建ActivityStack  
  5.     targetStack.moveToFront("startingNewTask");//将当前的ActivityStack放在最前面  
  6.   
  7.     if (reuseTask == null) {  
  8.         r.setTask(targetStack.createTaskRecord(getNextTaskId(),  
  9.                 newTaskInfo != null ? newTaskInfo : r.info,  
  10.                 newTaskIntent != null ? newTaskIntent : intent,  
  11.                 voiceSession, voiceInteractor, !launchTaskBehind /* toTop */),  
  12.                 taskToAffiliate);  
  13.         if (DEBUG_TASKS) Slog.v(TAG_TASKS,  
  14.                 "Starting new activity " + r + " in new task " + r.task);  
  15.     } else {  
  16.         r.setTask(reuseTask, taskToAffiliate);  
  17.     }  
  18.     if (isLockTaskModeViolation(r.task)) {  
  19.         Slog.e(TAG, "Attempted Lock Task Mode violation r=" + r);  
  20.         return ActivityManager.START_RETURN_LOCK_TASK_MODE_VIOLATION;  
  21.     }  
  22.     if (!movedHome) {  
  23.         if ((launchFlags &  
  24.                 (FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_TASK_ON_HOME))  
  25.                 == (FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_TASK_ON_HOME)) {  
  26.             // Caller wants to appear on home activity, so before starting  
  27.             // their own activity we will bring home to the front.  
  28.             r.task.setTaskToReturnTo(HOME_ACTIVITY_TYPE);  
  29.         }  
  30.     }  
  31. }  

我们先来看computeStackFocus函数，先是获取ActivityRecord的task对象，这个时候我们需要建一个task，所以显然为null。这个函数就是寻找合适的ActivityStack，最后没找到就调用createStackOnDisplay函数创建一个ActivityContainer对象，当然也就创建了ActivityStack对象了。

[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. ActivityStack computeStackFocus(ActivityRecord r, boolean newTask) {  
  2.     final TaskRecord task = r.task;//为null  
  3.   
  4.     // On leanback only devices we should keep all activities in the same stack.  
  5.     if (!mLeanbackOnlyDevice &&  
  6.             (r.isApplicationActivity() || (task != null && task.isApplicationTask()))) {  
  7.   
  8.         ActivityStack stack;  
  9.   
  10.         if (task != null && task.stack != null) {//如果当前TaskRecord中有stack，这里显然没有  
  11.             stack = task.stack;  
  12.             if (stack.isOnHomeDisplay()) {  
  13.                 if (mFocusedStack != stack) {  
  14.                     if (DEBUG_FOCUS || DEBUG_STACK) Slog.d(TAG_FOCUS,  
  15.                             "computeStackFocus: Setting " + "focused stack to r=" + r  
  16.                             + " task=" + task);  
  17.                 } else {  
  18.                     if (DEBUG_FOCUS || DEBUG_STACK) Slog.d(TAG_FOCUS,  
  19.                         "computeStackFocus: Focused stack already=" + mFocusedStack);  
  20.                 }  
  21.             }  
  22.             return stack;  
  23.         }  
  24.   
  25.         final ActivityContainer container = r.mInitialActivityContainer;  
  26.         if (container != null) {  
  27.             // The first time put it on the desired stack, after this put on task stack.  
  28.             r.mInitialActivityContainer = null;  
  29.             return container.mStack;  
  30.         }  
  31.   
  32.         if (mFocusedStack != mHomeStack && (!newTask ||//mFousedStack不是HomeStack，而且不是新建Task  
  33.                 mFocusedStack.mActivityContainer.isEligibleForNewTasks())) {  
  34.             if (DEBUG_FOCUS || DEBUG_STACK) Slog.d(TAG_FOCUS,  
  35.                     "computeStackFocus: Have a focused stack=" + mFocusedStack);  
  36.             return mFocusedStack;  
  37.         }  
  38.   
  39.         final ArrayList<ActivityStack> homeDisplayStacks = mHomeStack.mStacks;//所有设备上的ActivityStack  
  40.         for (int stackNdx = homeDisplayStacks.size() - 1; stackNdx >= 0; --stackNdx) {  
  41.             stack = homeDisplayStacks.get(stackNdx);  
  42.             if (!stack.isHomeStack()) {//如果StackId不是HOME_STACK_ID  
  43.                 if (DEBUG_FOCUS || DEBUG_STACK) Slog.d(TAG_FOCUS,  
  44.                         "computeStackFocus: Setting focused stack=" + stack);  
  45.                 return stack;  
  46.             }  
  47.         }  
  48.   
  49.         // Need to create an app stack for this user.  
  50.         stack = createStackOnDisplay(getNextStackId(), Display.DEFAULT_DISPLAY);//最后还是没找到创建一个ActivityContainer对象  
  51.         if (DEBUG_FOCUS || DEBUG_STACK) Slog.d(TAG_FOCUS, "computeStackFocus: New stack r="  
  52.                 + r + " stackId=" + stack.mStackId);  
  53.         return stack;  
  54.     }  
  55.     return mHomeStack;  
  56. }  

然后我们再来看下ActivityStack的moveToFront函数，先看看当前是否是HOME_STACK_ID的Stack，如果不是将当前的stack放在mStacks的最前面。mStacks之前看过代表这个显示设备上所有的Stack.

[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. final void moveToFront(String reason) {  
  2.     if (isAttached()) {  
  3.         final boolean homeStack = isHomeStack()//看是否是HOME_STACK_ID的Stack  
  4.                 || (mActivityContainer.mParentActivity != null  
  5.                     && mActivityContainer.mParentActivity.isHomeActivity());  
  6.         ActivityStack lastFocusStack = null;  
  7.         if (!homeStack) {  
  8.             // Need to move this stack to the front before calling  
  9.             // {@link ActivityStackSupervisor#moveHomeStack} below.  
  10.             lastFocusStack = mStacks.get(mStacks.size() - 1);//获取最后的Stack  
  11.             mStacks.remove(this);//去除当前stack  
  12.             mStacks.add(this);//再加入，这样当前的stack就在最前面了  
  13.         }  
  14.         // TODO(multi-display): Focus stack currently adjusted in call to move home stack.  
  15.         // Needs to also work if focus is moving to the non-home display.  
  16.         if (isOnHomeDisplay()) {//是否是默认显示设备  
  17.             mStackSupervisor.moveHomeStack(homeStack, reason, lastFocusStack);  
  18.         }  
  19.         final TaskRecord task = topTask();  
  20.         if (task != null) {  
  21.             mWindowManager.moveTaskToTop(task.taskId);//通知wms  
  22.         }  
  23.     }  
  24. }  

我们再来看看ActivityStackSuperVisor的moveHomeStack函数，这里就是主要是赋值mLastFocusedStack 和 mFocusedStack 。mFocusedStack 就是上面函数刚刚放到mStacks中去的那个ActivityStack，mLastFocusedStack 就是上一个mStacks的最前面的ActivityStack。

[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. void moveHomeStack(boolean toFront, String reason, ActivityStack lastFocusedStack) {  
  2.     ArrayList<ActivityStack> stacks = mHomeStack.mStacks;  
  3.     final int topNdx = stacks.size() - 1;  
  4.     if (topNdx <= 0) {  
  5.         return;  
  6.     }  
  7.   
  8.     // The home stack should either be at the top or bottom of the stack list.  
  9.     if ((toFront && (stacks.get(topNdx) != mHomeStack))  
  10.             || (!toFront && (stacks.get(0) != mHomeStack))) {  
  11.         if (DEBUG_STACK) Slog.d(TAG_STACK, "moveHomeTask: topStack old="  
  12.                 + ((lastFocusedStack != null) ? lastFocusedStack : stacks.get(topNdx))  
  13.                 + " new=" + mFocusedStack);  
  14.         stacks.remove(mHomeStack);  
  15.         stacks.add(toFront ? topNdx : 0, mHomeStack);  
  16.     }  
  17.   
  18.     if (lastFocusedStack != null) {  
  19.         mLastFocusedStack = lastFocusedStack;  
  20.     }  
  21.     mFocusedStack = stacks.get(topNdx);  

再来继续看ActivityStackSupervisor的startActivityUncheckedLocked函数，接下来就是来创建TaskRecord。然后调用ActivityRecord的setTask，把这个创建了TaskRecord作为ActivityRecord的task对象。
[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. if (reuseTask == null) {  
  2.     r.setTask(targetStack.createTaskRecord(getNextTaskId(),  
  3.             newTaskInfo != null ? newTaskInfo : r.info,  
  4.             newTaskIntent != null ? newTaskIntent : intent,  
  5.             voiceSession, voiceInteractor, !launchTaskBehind /* toTop */),  
  6.             taskToAffiliate);  
  7.     if (DEBUG_TASKS) Slog.v(TAG_TASKS,  
  8.             "Starting new activity " + r + " in new task " + r.task);  
  9. }  
我们看ActivityStack的createTaskRecord函数，创建一个TaskRecord。然后调用addTask把TaskRecord保存下来。
[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. TaskRecord createTaskRecord(int taskId, ActivityInfo info, Intent intent,  
  2.         IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,  
  3.         boolean toTop) {  
  4.     TaskRecord task = new TaskRecord(mService, taskId, info, intent, voiceSession,  
  5.             voiceInteractor);  
  6.     addTask(task, toTop, false);  
  7.     return task;  
  8. }  
addTask先把当前的ActivityStack放在这TaskRecord的stack成员变量中，然后就是把这个TaskRecord放在mTaskHistory一个合适的位置。
[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. void addTask(final TaskRecord task, final boolean toTop, boolean moving) {  
  2.     task.stack = this;//把当前ActivityStack放在这TaskRecord的stack成员变量中  
  3.     if (toTop) {  
  4.         insertTaskAtTop(task, null);  
  5.     } else {  
  6.         mTaskHistory.add(0, task);  
  7.         updateTaskMovement(task, false);  
  8.     }  
  9.     if (!moving && task.voiceSession != null) {  
  10.         try {  
  11.             task.voiceSession.taskStarted(task.intent, task.taskId);  
  12.         } catch (RemoteException e) {  
  13.         }  
  14.     }  
  15. }  

2.2 不需要新建TaskReocrd

我们还是看下ActivityStackSupervisor的startActivityUncheckedLocked函数，下面是不要创建新的TaskReocrd的流程。先直接从ActivityRecord的task获取TaskRecord对象。

然后从TaskRecord的stack获取ActivityStack对象。和上面流程一样，先调用ActivityStack的moveToFront将当前这个ActivityStack放在最前面，同时改变mFocusedStack和mLastFocusedStack的值。然后又看当前这个TaskRecord是否是当前ActivityStack最前面的。如果不是把它调整到最前面

[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. } else if (sourceRecord != null) {  
  2.     final TaskRecord sourceTask = sourceRecord.task;  
  3.     if (isLockTaskModeViolation(sourceTask)) {  
  4.         Slog.e(TAG, "Attempted Lock Task Mode violation r=" + r);  
  5.         return ActivityManager.START_RETURN_LOCK_TASK_MODE_VIOLATION;  
  6.     }  
  7.     targetStack = sourceTask.stack;  
  8.     targetStack.moveToFront("sourceStackToFront");//把当前ActivityStack放在最前面  
  9.     final TaskRecord topTask = targetStack.topTask();  
  10.     if (topTask != sourceTask) {  
  11.         targetStack.moveTaskToFrontLocked(sourceTask, noAnimation, options,//把当前TaskRecord放在ActivityStack的最前面  
  12.                 r.appTimeTracker, "sourceTaskToFront");  
  13.     }  


三、将Activity放在TaskRecord的最前面

下面我们再来看ActivityStack的startActivityLocked函数有下面代码，会把当前要启动的Activity放在TaskRecord的最前面

[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. task = r.task;  
  2.   
  3. // Slot the activity into the history stack and proceed  
  4. if (DEBUG_ADD_REMOVE) Slog.i(TAG, "Adding activity " + r + " to stack to task " + task,  
  5.         new RuntimeException("here").fillInStackTrace());  
  6. task.addActivityToTop(r);  
  7. task.setFrontOfTask();  


四、保存TaskRecord到mRecentTasks

我们继续分析ActivityStatck的resumeTopActivityInnerLocked函数，先分析要启动的Activity已经有进程了，这里我会先调用mRecentTasks.addLocked把现在的TaskRecord保存在mRecentTasks代表最近启动的Task

[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. if (next.app != null && next.app.thread != null) {  
  2.     if (DEBUG_SWITCH) Slog.v(TAG_SWITCH, "Resume running: " + next);  
  3.   
  4.     // This activity is now becoming visible.  
  5.     mWindowManager.setAppVisibility(next.appToken, true);  
  6.   
  7.     // schedule launch ticks to collect information about slow apps.  
  8.     next.startLaunchTickingLocked();  
  9.   
  10.     ActivityRecord lastResumedActivity =  
  11.             lastStack == null ? null :lastStack.mResumedActivity;  
  12.     ActivityState lastState = next.state;  
  13.   
  14.     mService.updateCpuStats();  
  15.   
  16.     if (DEBUG_STATES) Slog.v(TAG_STATES, "Moving to RESUMED: " + next + " (in existing)");  
  17.     next.state = ActivityState.RESUMED;  
  18.     mResumedActivity = next;  
  19.     next.task.touchActiveTime();  
  20.     mRecentTasks.addLocked(next.task);//保存TaskRecord在mRecentTasks  
  21.     mService.updateLruProcessLocked(next.app, true, null);  
  22.     updateLRUListLocked(next);  
  23.     mService.updateOomAdjLocked();  
  24.     ......  
  25.   
  26.     try {  
  27.         // Deliver all pending results.  
  28.         ArrayList<ResultInfo> a = next.results;  
  29.         if (a != null) {  
  30.             final int N = a.size();  
  31.             if (!next.finishing && N > 0) {  
  32.                 if (DEBUG_RESULTS) Slog.v(TAG_RESULTS,  
  33.                         "Delivering results to " + next + ": " + a);  
  34.                 next.app.thread.scheduleSendResult(next.appToken, a);  
  35.             }  
  36.         }  
  37.         ......  
  38.         next.app.thread.scheduleResumeActivity(next.appToken, next.app.repProcState,//调用ActivityThread的函数  
  39.                 mService.isNextTransitionForward(), resumeAnimOptions);  

那如果启动没有进程的Activity又是在哪保存TaskRecord到mRecentTasks的呢。如果没有进程会调用startSpecificActivityLocked函数，最后又到ActivityThread的main函数，又调用AMS的attachApplicationLocked函数。在AMS的attachApplicationLocked函数中又会调用ActivityStackSupervisor的attachApplicationLocked方法。

[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. void startSpecificActivityLocked(ActivityRecord r,  
  2.         boolean andResume, boolean checkConfig) {  
  3.     // Is this activity's application already running?  
  4.     ProcessRecord app = mService.getProcessRecordLocked(r.processName,  
  5.             r.info.applicationInfo.uid, true);  
  6.   
  7.     r.task.stack.setLaunchTime(r);  
  8.   
  9.     if (app != null && app.thread != null) {  
  10.         try {  
  11.             if ((r.info.flags&ActivityInfo.FLAG_MULTIPROCESS) == 0  
  12.                     || !"android".equals(r.info.packageName)) {  
  13.                 // Don't add this if it is a platform component that is marked  
  14.                 // to run in multiple processes, because this is actually  
  15.                 // part of the framework so doesn't make sense to track as a  
  16.                 // separate apk in the process.  
  17.                 app.addPackage(r.info.packageName, r.info.applicationInfo.versionCode,  
  18.                         mService.mProcessStats);  
  19.             }  
  20.             realStartActivityLocked(r, app, andResume, checkConfig);  
  21.             return;  
  22.         } catch (RemoteException e) {  
  23.             Slog.w(TAG, "Exception when starting activity "  
  24.                     + r.intent.getComponent().flattenToShortString(), e);  
  25.         }  
  26.   
  27.         // If a dead object exception was thrown -- fall through to  
  28.         // restart the application.  
  29.     }  
  30.   
  31.     mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,  
  32.             "activity", r.intent.getComponent(), false, false, true);  
  33. }  

在ActivityStackSupervisor的attachApplicationLocked方法中又调用了realStartActivityLocked方法，在realStartActivityLocked方法中会调用app.thread.scheduleLaunchActivity启动Activity，后面还会调用ActivityStac的minimalResumeActivityLocked方法。

在这个函数中调用了mRecentTasks.addLocked方法保存了TaskRecord，还保存了mResumedActivity。

[cpp] view plain copy 在CODE上查看代码片派生到我的代码片
  1. void minimalResumeActivityLocked(ActivityRecord r) {  
  2.     r.state = ActivityState.RESUMED;  
  3.     if (DEBUG_STATES) Slog.v(TAG_STATES,  
  4.             "Moving to RESUMED: " + r + " (starting new instance)");  
  5.     r.stopped = false;  
  6.     mResumedActivity = r;  
  7.     r.task.touchActiveTime();  
  8.     mRecentTasks.addLocked(r.task);  
  9.     completeResumeLocked(r);  
  10.     mStackSupervisor.checkReadyForSleepLocked();  
  11.     setLaunchTime(r);  
  12.     if (DEBUG_SAVED_STATE) Slog.i(TAG_SAVED_STATE,  
  13.             "Launch completed; removing icicle of " + r.icicle);  
  14. }  

0 0
与犯罪的战争 知乎 与犯罪的战争 知乎
原创粉丝点击
热门IT博客
网络超好听伤感歌曲网络超好听伤感歌曲
皮鞋品牌 知乎皮鞋品牌 知乎
客服系统组成部分知乎
python 结构体
jo软件哪里能买到
js控制数据几个为一行
网络强国建设的论文
php 序列化数组
山东11选5最大遗漏数据
吉他自学软件排行
codekk源码解析
手机性价比 知乎
淘宝鞋子代销
关于所有淘宝软件
nginx配置两个域名
t车数据
数据完整性管理规程
js 过滤特殊字符
欧盟 网络安全法
淘宝神笔怎么样
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 桌游吧 青春有你 演艺吧 综艺节目 艺人经纪人 录播教室 演艺 关于设计 理想型娱乐圈 录播设备 酒吧 酒吧收银系统 娱乐圈有多乱 m2酒吧 蓝色港湾 俱乐部会所 娱乐圈如此美好 西安游乐场有哪些 娱乐圈吧 西安游乐场 捕鱼怎么 pandora 雪舞 西安大型游乐场 上海休闲会所 榴芒 综艺 variety 桌游 附近ktv 清风小道童西游之大娱乐家 日娱家 yy频道下载 yy在线 yy鱼 歪歪鱼 台湾中文化娱网 台湾湾妹娱中文网 娱网棋牌手机版 台湾湾妹中文娱网 娴庄

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里