activity的启动模式，startactivity的过程

灰太狼 2022-06-08 14:55 332阅读 0赞

Android:launchMode

用于指定Activity被启动的方式，主要包括两个方面：即Activity是否为单实例，及Activity归属的task。不管是那种方式，被启动的Activity都要位于Activitytask的栈顶。

1)，standard，默认状态，这种模式下Activity是多实例的，系统总是启动一个新的Activity来满足要求，即使之前已经存在这个Activity的实例；并且它归属于调用startactivity将其启动那个task（除非intent明确指明FLAG_ACTIVITY_NEW_TASK，这样就跟singleTask的启动模式是一样的）。

2），singletop，这个跟standard模式非常类似，它也表明Activity是多实例（下面是例外的情况）的，且task的归属也一致。区别是：

对于standard，无论何时它都会生成一个新的Activity实例；而singleTop当遇到目标Activity已经存在与目标task的栈顶时，会将Intent通过onNewIntent传给这个Activity而不是生成一个新的实例。

3），singleTask，它表明这个Activity是单实例的，Intent将通过OnNewIntent传送给已有的实例；而且他总是在一个新的task中启动。这种类型的Activity永远在task的根位置。另外，singleTask允许其他的Activity进驻到它所在的task中，这一点跟singleInstance不同。

4），singleInstance，和singleTask基本一致，不过它不允许其他的Activity进驻到它所属的task中，也就是说，singleInstance永远都是在一个孤立的task中。

  1. Activity的生命周期
  3. 一个activity的启动：
  5. 10-26 22:18:23.365 24691-24691/? D/First-Activity: recycle,,onCreate
  6. 10-26 22:18:23.365 24691-24691/? D/First-Activity: recycle,,onStart
  7. 10-26 22:18:23.367 24691-24691/? D/First-Activity: recycle,,onResume
  9. 按back键，让activity的退出，activity会被出栈（Activitystack）：
  10. com.firstapp.linjw.myapplication_n D/First-Activity: recycle,,onPause
  11. com.firstapp.linjw.myapplication_n D/First-Activity: recycle,,onStop
  12. com.firstapp.linjw.myapplication_n D/First-Activity: recycle,,onDestroy
  14. 按home间，让activity退出，会执行onPause(),onStop(),但是不会执行onDestory(),
  16. 启动另一个activity：
  17. com.firstapp.linjw.myapplication_n D/First-Activity: recycle,,onPause
  18. com.firstapp.linjw.myapplication_n D/Second-Activity: recycle,,onCreate
  19. com.firstapp.linjw.myapplication_n D/Second-Activity: recycle,,onStart
  20. com.firstapp.linjw.myapplication_n D/Second-Activity: recycle,,onResume
  21. com.firstapp.linjw.myapplication_n D/First-Activity: recycle,,onStop
  23. 从第二个activity返回：
  24. com.firstapp.linjw.myapplication_n D/Second-Activity: recycle,,onPause
  25. com.firstapp.linjw.myapplication_n D/First-Activity: recycle,,onRestart
  26. com.firstapp.linjw.myapplication_n D/First-Activity: recycle,,onStart
  27. com.firstapp.linjw.myapplication_n D/First-Activity: recycle,,onResume
  28. com.firstapp.linjw.myapplication_n D/Second-Activity: recycle,,onStop
  29. com.firstapp.linjw.myapplication_n D/Second-Activity: recycle,,onDestroy
  31. 1，ActivityManagerService的功能，ActivityManagerService的功能

1）组件状态的管理，四个组件的开启、关闭等一系列操作

2）组件状态查询**，查询组件当前的运行情况**

3）Task相关的操作**，removeTask，**movetasktofront。

4）其他一些系统运行信息的查询**，getMemeoryInfo等。**

AMS是在systemserver中启动的**。**

  1. SystemServer.java
  2.     private void startBootstrapServices() {
  3. //这里会调用AMS的start方法。
  4.         mActivityManagerService = mSystemServiceManager.startService(
  5.             ActivityManagerService.Lifecycle.class).getService();
  6. //然后，进行初始化，并把一些服务添加到serviceManager中。
  7.         mActivityManagerService.initPowerManagement();
  8.         mActivityManagerService.setSystemProcess();
  9.         mActivityManagerService.installSystemProviders();
  10.         mActivityManagerService.setWindowManager(wm);
  11.         mActivityManagerService.enterSafeMode();
  12. //将一系列与进程管理相关的服务，注册到systemmanager。
  13.         mActivityManagerService.setSystemProcess();
  14. //下面这个调用会先执行AMS中的systemready方法，确保AMS启动ok了，才会执行这个回调，在这个回调中，systemserver接着执行系统服务的启动，在这里启动systemUI。
  15.         mActivityManagerService.systemReady(new Runnable() {
  16.             public void run() {
  17.                 mSystemServiceManager.startBootPhase(
  18.                     SystemService.PHASE_ACTIVITY_MANAGER_READY);
  20.                 mActivityManagerService.startObservingNativeCrashes();
  21.                 startSystemUi(context);
  22.                 mSystemServiceManager.startBootPhase(
  23.                     SystemService.PHASE_THIRD_PARTY_APPS_CAN_START);
  24.             }
  25.         });
  26.     }
  28. ActivityManagerService.java
  29.     public void systemReady(final Runnable goingCallback) {
  30. //在AMS启动完成之前， mSystemReady是false的，
  31.         synchronized(this) {
  32.             if (mSystemReady) {
  33.                 goingCallback.run();
  34.                 return;
  35.             }
  36.             mSystemReady = true;
  37.         }
  38. //下面是AMS的启动操作，包括启动home应用程序。
  39.         retrieveSettings();
  40.         readGrantedUriPermissionsLocked();
  41.         …
  42. //这里去执行systemserver中的回调，继续systemserver中未完成的系统服务的启动。因为systemserver的后续运行要依赖AMS，所以在AMS还没就绪的情况下就冒然返回，可能造成系统宕机。
  43.         if (goingCallback != null) goingCallback.run();
  44.         ...
  45.         startPersistentApps(PackageManager.MATCH_DIRECT_BOOT_AWARE);
  46.         startHomeActivityLocked(currentUserId, "systemReady");
  47.         mStackSupervisor.resumeFocusedStackTopActivityLocked();
  49.     }

启动时，通过Lifecycle这个Systemservice先创建ActivityManagerService实例，然后调用其start方法。

在AMS的构造函数中，会创建一个线程ServiceThread，这是一个自带消息队列的线程。

  1. ActivityManagerService,一个用于管理Activity（其他组件）运行状态的系统进程。
  2. AMS会向servicemanager登记多种Binderserver，如：activity，meminfo，cpuinfo，processinfo，permission等。
  4. public void setSystemProcess() @ActivityManagerService.java{
  5.     ServiceManager.addService(Context.ACTIVITY_SERVICE, this, true);
  6.     ServiceManager.addService(ProcessStats.SERVICE_NAME, mProcessStats);
  7.     ServiceManager.addService("meminfo", new MemBinder(this));
  8.     ServiceManager.addService("cpuinfo", new CpuBinder(this));
  9.     ServiceManager.addService("processinfo", new ProcessInfoService(this));
  10.     ServiceManager.addService("permission", new PermissionController(this));    
  11. }
  13. 2，管理当前系统中的Activity状态。
  14. Activitystack是管理系统中所有Activity状态的一个数据结构。一个Activity所经历的状态有：
  15. enum ActivityState {
  16.     INITIALIZING,//正在初始化
  17.     RESUMED,//恢复
  18.     PAUSING,//正在暂停
  19.     PAUSED,//已经暂停
  20.     STOPPING,//正在停止
  21.     STOPPED,//已经停止
  22.     FINISHING,//正在完成
  23.     DESTROYING,//正在销毁
  24.     DESTROYED//已经销毁
  25. }
  27. Activity的状态迁移图：的状态迁移图：

Center

  1. 2.1 AMS主要的变量
  2. ActivityManagerService.java
  3. AMS通过ActivityStackSupervisor mStackSupervisor管理系统的Activitystack,通过StackSupervisor运行所有的activitystacks。
  4. ActivityRecord mFocusedActivity;//当前拥有焦点的Activity。
  5. RecentTasks mRecentTasks;//用于启动最近任务的intent列表。
  7. ActivityStackSupervisor.java
  8. ActivityStack mHomeStack;//包含launcher app的stack，
  9. ActivityStack mFocusedStack;//当前可以接收输入事件或启动下一个Activity的stack。
  10. //等待即将可见的新的Activity的列表。
  11. ArrayList<ActivityRecord> mWaitingVisibleActivities；
  12. //列表中的Activity可以被stop，但是要等待下一个Activity就绪。
  13. ArrayList<ActivityRecord> mStoppingActivities
  14. //列表中Activity可以被finish的，但是要等上一个Activity就绪。
  15. ArrayList<ActivityRecord> mFinishingActivities 
  17. ActivityStack.java
  18. //所有前面Activity的回退记录，包括可能正在运行的Activity。
  19. ArrayList<TaskRecord> mTaskHistory
  20. //正在运行的Activity的列表，以最近的使用情况排序，第一个是最近最少使用的元素。
  21. ArrayList<ActivityRecord> mLRUActivities
  22. //当前正在被暂停的Activity
  23. ActivityRecord mPausingActivity
  24. //上一个被暂停的Activity
  25. ActivityRecord mLastPausedActivity
  26. //当前被恢复的Activity
  27. ActivityRecord mResumedActivity
  28. //最近一次被启动的Activity
  29. ActivityRecord mLastStartedActivity
  31. TaskRecord.java
  32. //task中的所有的Activity，这个task是在历史记录中按顺序排列的
  33. ArrayList<ActivityRecord> mActivities;
  34. //当前的stack，管理者这个task中的Activity。
  35. ActivityStack stack;
  37. ActivityRecord.java
  38. //表明这个Activity所属的task，
  39. TaskRecord task;
  41. 大致结构：
  42. mStackSupervisor（ActivityStackSupervisor）负责管理所有的Activitystack。
  43. ActivityStack管理着系统中的task，也就是TaskRecord。
  44. TaskRecord中的mActivities中保存了属于当前task的Activitys（ActivityRecord），这些Activity在是以stack的形式存放的，每一个Activity就是一个Activityrecord。
  46. 从获取顶层Activity的函数可以看出以上关系：
  48. final ActivityRecord topRunningActivityLocked()@ActivityStack.java{
  49.     for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
  50.         ActivityRecord r = mTaskHistory.get(taskNdx).topRunningActivityLocked();
  51.     }
  52. }
  53. ActivityRecord topRunningActivityLocked()@TaskRecord.java{
  54.     for (int activityNdx = mActivities.size() - 1; activityNdx >= 0; --activityNdx) {
  55.         ActivityRecord r = mActivities.get(activityNdx);
  56.         if (!r.finishing && stack.okToShowLocked(r)) {
  57.             return r;
  58.         }
  59.     }
  60. }

因为Task是有先后之分的，所以对ActivityRecord的存储使用的是stack栈的方式，具体可以参考addActivityAtBottom()@TaskRecord.java，addActivityToTop()@TaskRecord.java

  1. 3，startActivity的过程
  2. 直接从AMS说起：
  4. public final int startActivity(IApplicationThread caller, String callingPackage,
  5.     Intent intent, String resolvedType, IBinder resultTo, String resultWho, int   
  6.    requestCode,int startFlags, ProfilerInfo profilerInfo, Bundle bOptions) {
  7.     return startActivityAsUser(caller, callingPackage, intent, resolvedType, 
  8.         resultTo, resultWho, requestCode, startFlags, profilerInfo, bOptions,
  9.         UserHandle.getCallingUserId());
  10. }
  12. 通过UserHandle.getCallingUserId()获取调用者的用户ID。
  13. //下面主要权限检查
  15. public final int startActivityAsUser(...){
  16. //调用者是否属于被隔离的对象。
  17.     enforceNotIsolatedCaller("startActivity");
  18. //调用者是否有权限执行这一操作。
  19.     userId = mUserController.handleIncomingUser(Binder.getCallingPid(), 
  20.         Binder.getCallingUid(),userId, false, ALLOW_FULL_ONLY, "startActivity", 
  21.         null);
  22.     return mActivityStarter.startActivityMayWait(…);
  23. }
  25. final int startActivityMayWait(...)@ActivityStarter.java{
  26. //通过解析intent，确定目标Activity。
  27.     ResolveInfo rInfo = mSupervisor.resolveIntent(intent, resolvedType, userId);
  28.     ActivityInfo aInfo = mSupervisor.resolveActivity(intent, rInfo, startFlags, 
  29.         profilerInfo);
  30. //判断目标Activity所属进程，是不是重量级进程，对于重量级进程不参与正常的应用程序的生命周期。所以如果系统中已经存在的重量级进程不是即将要启动的这个，那么要给intent重新赋值，重新解析。
  31.     if (aInfo.applicationInfo.privateFlags& 
  32.         ApplicationInfo.PRIVATE_FLAG_CANT_SAVE_STATE) != 0）
  33.     if (aInfo.processName.equals(aInfo.applicationInfo.packageName)) {
  34.         final ProcessRecord heavy = mService.mHeavyWeightProcess;
  35.         if (heavy != null && (heavy.info.uid != aInfo.applicationInfo.uid
  36.         || !heavy.processName.equals(aInfo.processName))) {
  37.             Intent newIntent = new Intent();
  38.             newIntent.putExtra(HeavyWeightSwitcherActivity.KEY_INTENT,
  39.                 new IntentSender(target));
  40.             newIntent.putExtra(HeavyWeightSwitcherActivity.KEY_NEW_APP,
  41.                 aInfo.packageName);
  42.             newIntent.setClassName("android",
  43.                 HeavyWeightSwitcherActivity.class.getName());
  44.             intent = newIntent;
  45.             rInfo = mSupervisor.resolveIntent(intent, null /*resolvedType*/, 
  46.                 userId);
  47.         }
  48.     }
  49. //调用 startActivityLocked进一步执行启动操作。这个 startActivityLocked函数参数较多，后面还有调用同名的 startActivityLocked函数，它的参数较少。
  50.     int res = startActivityLocked(…);
  51. }
  53. final int startActivityLocked(...)@ActivityStarter.java{
  54. //确保调用者本身的进程是存在的，否则返回 PERMISSION_DENIED，权限被拒绝错误。
  55.     ProcessRecord callerApp = null;
  56.     callerApp = mService.getRecordForAppLocked(caller);
  57.     if (callerApp != null) {
  58.         callingPid = callerApp.pid;
  59.         callingUid = callerApp.info.uid;
  60.     }else{
  61.         err = ActivityManager.START_PERMISSION_DENIED;
  62.     }
  63. //处理标记： FLAG_ACTIVITY_FORWARD_RESULT，即Activity_result的跨越式传递。
  64.     if ((launchFlags & Intent.FLAG_ACTIVITY_FORWARD_RESULT) != 0 
  65.         && sourceRecord != null) {
  66.         resultWho = sourceRecord.resultWho;
  67.     }
  68. //再次对调用者做权限检查，包括是否匹配intent-filter规则。
  69.     boolean abort = !mSupervisor.checkStartAnyActivityPermission(intent, aInfo, 
  70.         resultWho,requestCode, callingPid, callingUid, callingPackage,…);
  71.     abort |= !mService.mIntentFirewall.checkStartActivity(intent, callingUid,
  72.         callingPid, resolvedType, aInfo.applicationInfo);
  73. //生成一个ActivityRecord，记录各项判断结果。
  74.     ActivityRecord r = new ActivityRecord(mService, callerApp, callingUid, 
  75.         callingPackage,…);
  76. //调用 startActivityUnchecked，处理启动模式，及intent标志相关的。
  77.     err = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor,  
  78.         startFlags,true, options, inTask);
  79. }
  81. //对一系列启动标志的处理。对一系列启动标志的处理。
  83. private int startActivityUnchecked(...){
  84. //获取intent中的启动标记。
  85.     final Intent baseIntent = mInTask.getBaseIntent();
  86.     mLaunchFlags = mLaunchFlags |baseIntent.getFlags();
  87. //如果被启动的对象和调用者是同一个，什么都不用做，只要正确恢复顶层的Activity。
  88.     if ((mStartFlags & START_FLAG_ONLY_IF_NEEDED) != 0) {
  89.         resumeTargetStackIfNeeded();
  90.         return START_RETURN_INTENT_TO_CALLER;
  91.     }
  92. //要启动的是newtask，相关的处理。
  93.     if(mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) != 0){
  94.         newTask = true;
  95.         setTaskFromReuseOrCreateNewTask(taskToAffiliate);
  96.     }
  97. //接着调用另一个startActivityLocked。
  98.     mTargetStack.startActivityLocked(mStartActivity, newTask, 
  99.         mKeepCurTransition, mOptions);
  100. //恢复最上层的Activity。
  101.     mSupervisor.resumeFocusedStackTopActivityLocked(mTargetStack, 
  102.         mStartActivity,mOptions);
  103. }
  105. //这是启动Activity的最后一步了。
  107. final void startActivityLocked(){
  108. //如果目标Activity不在新的task中启动，就要找到他属于那个已存在的task，通过遍历整个 mTaskHistory列表，如果整个task对用户还不可见，先把Activity加进去，并把它加到history队列中。addConfigOverride(r, task);这句调用是在WindowManagerservice中做好注册，也就是添加一个AppWindowToken，
  109.     if (!newTask) {
  110.         for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
  111.             task = mTaskHistory.get(taskNdx);
  112.             if (task == r.task) {
  113.                 task.addActivityToTop(r);
  114.                 r.putInHistory();
  115.                 addConfigOverride(r, task);
  116.             }
  117.         }
  118.     }
  119. //是否显示启动窗口。
  120.     if (SHOW_APP_STARTING_PREVIEW && doShow) {
  121.         ActivityRecord prev = 
  122.             r.task.topRunningActivityWithStartingWindowLocked();
  123.         r.showStartingWindow(prev, showStartingIcon);
  124.     }
  125. }
  127. 到这里startActivity的一系列调用就分析完了，接下来就是恢复最顶层的Activity。
  129. boolean resumeFocusedStackTopActivityLocked(
  130.     ActivityStack targetStack, ActivityRecord target, ActivityOptions 
  131.     targetOptions)@ActivityStackSupervisor.java {
  132.     targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
  133.     result = resumeTopActivityInnerLocked(prev, options);
  134. }
  136. private boolean resumeTopActivityInnerLocked(ActivityRecord prev, 
  137.     ActivityOptions options) {
  138. //取出最上面有效的Activity。
  139.     final ActivityRecord next = topRunningActivityLocked();
  140. //next为null，启动launcher界面。
  141.     if (next == null) {
  142.         return isOnHomeDisplay() &&
  143.             mStackSupervisor.resumeHomeStackTask(returnTaskType, prev, reason);
  144.     }
  145. //如果正在运行的Activity就是目标对象，就不用重复启动了。
  146.     if (mResumedActivity == next && next.state == ActivityState.RESUMED）{
  147.         return false;
  148.     }
  149. //如果目标Activity正在等待停止，就是正在stoping，那么就终止这个操作，从一下列表中移除，并置sleeping标志为false。
  150.     mStackSupervisor.mStoppingActivities.remove(next);
  151.     mStackSupervisor.mGoingToSleepActivities.remove(next);
  152.     next.sleeping = false;
  153.     mStackSupervisor.mWaitingVisibleActivities.remove(next);
  154. //mResumedActivity不为null，说明前一个Activity还在运行，先执行pause操作。
  155.     if (mResumedActivity != null) {
  156.         pausing |= startPausingLocked(userLeaving, false, next, 
  157.             dontWaitForPause);
  158.     }
  159. //在启动新的Activity之前，要把前一个窗口隐藏掉。这个操作只在前一个Activity正在finishing时执行，这就意味着它处于正在resumed的Activity的上面，所以要把它尽快隐藏，也就是说是否要隐藏前一个取决于新的Activity是不是全屏显示。
  160.     if (prev != null && prev != next) {
  161.         if (prev.finishing) {
  162.             mWindowManager.setAppVisibility(prev.appToken, false);
  163.         }
  164.     }
  165. //正式启动目标Activity，目标进程已有实例存在，告知目标线程resume指定的Activity，这个函数 scheduleResumeActivity会叫起Activity的onResume方法。
  166.     if (next.app != null && next.app.thread != null) {
  167.         mWindowManager.setAppVisibility(next.appToken, true);
  168.         next.app.thread.scheduleResumeActivity(next.appToken, 
  169.         next.app.repProcState,mService.isNextTransitionForward(), 
  170.         resumeAnimOptions);
  171.     }else{
  172. //目标Activity所属程序还没进程在运行，启动目标进程。
  173.         mStackSupervisor.startSpecificActivityLocked(next, true, true);
  174.     }
  175. }
  177. // startSpecificActivityLocked最后会调用Process.start()启动一个进程，同时加载了 ActivityThread这一主线程。
  178. private final void startProcessLocked(...)@ActivityManagerService.java{
  179.     entryPoint = "android.app.ActivityThread";
  180.     Process.ProcessStartResult startResult = Process.start(entryPoint,
  181.     app.processName, uid, uid, gids, debugFlags, mountExternal,
  182.     app.info.targetSdkVersion, app.info.seinfo, requiredAbi, instructionSet,
  183.     app.info.dataDir, entryPointArgs);
  184. }
  185. //目标进程启动后，会通过 attachApplication回调AMS，
  186. private void attach(boolean system)@ActivityThread.java {
  187.     final IActivityManager mgr = ActivityManagerNative.getDefault();
  188.     mgr.attachApplication(mAppThread);
  189. }
  190. //AMS在接收回调后，会判断当前是否有Activity等待这个进程的启动，如果有，就调用 realStartActivityLocked继续之前的启动
  191. 操作，接下来就是Activity生命周期的开始。
  192. private final boolean attachApplicationLocked()@ActivityManagerService.java{
  193.     mStackSupervisor.attachApplicationLocked(app);
  194. }
  195. boolean attachApplicationLocked(ProcessRecord app)@ActivityStackSupervisor.java{
  196.     realStartActivityLocked(hr, app, true, true);
  197. }
  198. final boolean realStartActivityLocked()@ActivityStackSupervisor.java{
  199.     app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,…);
  200. }

发表评论

表情：
评论列表 （有 0 条评论，332人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Activity启动模式

    今天我们来讲的是Activity有几种启动模式，其实以前我没太在意这方面的知识，但是我在开发过程中发现，其实了解和学习这几种启动模式还是非常重要的，确实能用到。那么接下来我们就

    秒速五厘米秒速五厘米/ 0 赞/ 348 阅读

    相关 Activity的启动模式

    在Android程序中，应用程序通过活动栈来管理Activity，活动栈中有多少个Activity对象，我们在退出程序的时候就要按多少下返回键（即要将活动栈中的所有Activi

    痛定思痛。痛定思痛。/ 0 赞/ 299 阅读