devbox
2023面试高手
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

安卓startActivity：彻底理解startActivity的启动过程这一篇就够了_android startactivity

作者：2023面试高手 | 2024-06-06 08:10:25

赞

踩

android startactivity

基于Android 6.0的源码剖析， 分析android Activity启动流程，相关源码：

  1. frameworks/base/services/core/java/com/android/server/am/
  2.   - ActivityManagerService.java
  3.   - ActivityStackSupervisor.java
  4.   - ActivityStack.java
  5.   - ActivityRecord.java
  6.   - ProcessRecord.java
  7.  
  8. frameworks/base/core/java/android/app/
  9.   - IActivityManager.java
  10.   - ActivityManagerNative.java (内含AMP)
  11.   - ActivityManager.java
  12.   
  13.   - IApplicationThread.java
  14.   - ApplicationThreadNative.java (内含ATP)
  15.   - ActivityThread.java (内含ApplicationThread)
  16.   
  17.   - ContextImpl.java

一. 概述

startActivity的整体流程与startService启动过程分析非常相近，但比Service启动更为复杂，多了stack/task以及UI的相关内容以及Activity的生命周期更为丰富。

Activity启动发起后，通过Binder最终交由system进程中的AMS来完成，则启动流程如下图：

 

接下来，从源码来说说每个过程。

二. 启动流程

2.1 Activity.startActivity

[-> Activity.java]

  1. public void startActivity(Intent intent) {
  2.     this.startActivity(intent, null);
  3. }
  4.  
  5. public void startActivity(Intent intent, @Nullable Bundle options) {
  6.     if (options != null) {
  7.         startActivityForResult(intent, -1, options);
  8.     } else {
  9.         //[见小节2.2]
  10.         startActivityForResult(intent, -1);
  11.     }
  12. }

2.2 startActivityForResult

[-> Activity.java]

  1. public void startActivityForResult(Intent intent, int requestCode) {
  2.     startActivityForResult(intent, requestCode, null);
  3. }
  4.  
  5. public void startActivityForResult(Intent intent, int requestCode, @Nullable Bundle options) {
  6.     if (mParent == null) {
  7.         //[见小节2.3]
  8.         Instrumentation.ActivityResult ar =
  9.             mInstrumentation.execStartActivity(
  10.                 this, mMainThread.getApplicationThread(), mToken, this,
  11.                 intent, requestCode, options);
  12.         if (ar != null) {
  13.             mMainThread.sendActivityResult(
  14.                 mToken, mEmbeddedID, requestCode, ar.getResultCode(),
  15.                 ar.getResultData());
  16.         }
  17.         //此时requestCode =-1
  18.         if (requestCode >= 0) {
  19.             mStartedActivity = true;
  20.         }
  21.         cancelInputsAndStartExitTransition(options);
  22.     } else {
  23.         ...
  24.     }
  25. }

execStartActivity()方法的参数:

  • mAppThread: 数据类型为ApplicationThread，通过mMainThread.getApplicationThread()方法获取。
  • mToken: 数据类型为IBinder.

2.3 execStartActivity

[-> Instrumentation.java]

  1. public ActivityResult execStartActivity( Context who, IBinder contextThread, IBinder token, Activity target, Intent intent, int requestCode, Bundle options) {
  2.  
  3.     IApplicationThread whoThread = (IApplicationThread) contextThread;
  4.     ...
  5.  
  6.     if (mActivityMonitors != null) {
  7.         synchronized (mSync) {
  8.             final int N = mActivityMonitors.size();
  9.             for (int i=0; i<N; i++) {
  10.                 final ActivityMonitor am = mActivityMonitors.get(i);
  11.                 if (am.match(who, null, intent)) {
  12.                     am.mHits++;
  13.                     //当该monitor阻塞activity启动,则直接返回
  14.                     if (am.isBlocking()) {
  15.                         return requestCode >= 0 ? am.getResult() : null;
  16.                     }
  17.                     break;
  18.                 }
  19.             }
  20.         }
  21.     }
  22.     try {
  23.         intent.migrateExtraStreamToClipData();
  24.         intent.prepareToLeaveProcess();
  25.         //[见小节2.4]
  26.         int result = ActivityManagerNative.getDefault()
  27.             .startActivity(whoThread, who.getBasePackageName(), intent,
  28.                     intent.resolveTypeIfNeeded(who.getContentResolver()),
  29.                     token, target != null ? target.mEmbeddedID : null,
  30.                     requestCode, 0, null, options);
  31.         //检查activity是否启动成功
  32.         checkStartActivityResult(result, intent);
  33.     } catch (RemoteException e) {
  34.         throw new RuntimeException("Failure from system", e);
  35.     }
  36.     return null;
  37. }

关于 ActivityManagerNative.getDefault()返回的是ActivityManagerProxy对象. 此处startActivity()的共有10个参数, 下面说说每个参数传递AMP.startActivity()每一项的对应值:

  • caller: 当前应用的ApplicationThread对象mAppThread;
  • callingPackage: 调用当前ContextImpl.getBasePackageName(),获取当前Activity所在包名;
  • intent: 这便是启动Activity时,传递过来的参数;
  • resolvedType: 调用intent.resolveTypeIfNeeded而获取;
  • resultTo: 来自于当前Activity.mToken
  • resultWho: 来自于当前Activity.mEmbeddedID
  • requestCode = -1;
  • startFlags = 0;
  • profilerInfo = null;
  • options = null;

2.4 AMP.startActivity

[-> ActivityManagerNative.java :: ActivityManagerProxy]

  1. class ActivityManagerProxy implements IActivityManager {
  2.     ...
  3.     public int startActivity(IApplicationThread caller, String callingPackage, Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode, int startFlags, ProfilerInfo profilerInfo, Bundle options) throws RemoteException {
  4.         Parcel data = Parcel.obtain();
  5.         Parcel reply = Parcel.obtain();
  6.         data.writeInterfaceToken(IActivityManager.descriptor);
  7.         data.writeStrongBinder(caller != null ? caller.asBinder() : null);
  8.         data.writeString(callingPackage);
  9.         intent.writeToParcel(data, 0);
  10.         data.writeString(resolvedType);
  11.         data.writeStrongBinder(resultTo);
  12.         data.writeString(resultWho);
  13.         data.writeInt(requestCode);
  14.         data.writeInt(startFlags);
  15.         if (profilerInfo != null) {
  16.             data.writeInt(1);
  17.             profilerInfo.writeToParcel(data, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
  18.         } else {
  19.             data.writeInt(0);
  20.         }
  21.         if (options != null) {
  22.             data.writeInt(1);
  23.             options.writeToParcel(data, 0);
  24.         } else {
  25.             data.writeInt(0);
  26.         }
  27.         //[见流程2.5]
  28.         mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);
  29.         reply.readException();
  30.         int result = reply.readInt();
  31.         reply.recycle();
  32.         data.recycle();
  33.         return result;
  34.     }
  35.     ...
  36. }

AMP经过binder IPC,进入ActivityManagerNative(简称AMN)。接下来程序进入了system_servr进程，开始继续执行。

2.5 AMN.onTransact

[-> ActivityManagerNative.java]

  1. public boolean onTransact(int code, Parcel data, Parcel reply, int flags) throws RemoteException {
  2.     switch (code) {
  3.     case START_ACTIVITY_TRANSACTION:
  4.     {
  5.       data.enforceInterface(IActivityManager.descriptor);
  6.       IBinder b = data.readStrongBinder();
  7.       IApplicationThread app = ApplicationThreadNative.asInterface(b);
  8.       String callingPackage = data.readString();
  9.       Intent intent = Intent.CREATOR.createFromParcel(data);
  10.       String resolvedType = data.readString();
  11.       IBinder resultTo = data.readStrongBinder();
  12.       String resultWho = data.readString();
  13.       int requestCode = data.readInt();
  14.       int startFlags = data.readInt();
  15.       ProfilerInfo profilerInfo = data.readInt() != 0
  16.               ? ProfilerInfo.CREATOR.createFromParcel(data) : null;
  17.       Bundle options = data.readInt() != 0
  18.               ? Bundle.CREATOR.createFromParcel(data) : null;
  19.       //[见流程2.6]
  20.       int result = startActivity(app, callingPackage, intent, resolvedType,
  21.               resultTo, resultWho, requestCode, startFlags, profilerInfo, options);
  22.       reply.writeNoException();
  23.       reply.writeInt(result);
  24.       return true;
  25.     }
  26.     ...
  27.     }    }

2.6 AMS.startActivity

[-> ActivityManagerService.java]

  1. public final int startActivity(IApplicationThread caller, String callingPackage, Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode, int startFlags, ProfilerInfo profilerInfo, Bundle options) {
  2.     return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
  3.         resultWho, requestCode, startFlags, profilerInfo, options,
  4.         UserHandle.getCallingUserId());
  5. }
  6.  
  7. public final int startActivityAsUser(IApplicationThread caller, String callingPackage, Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode, int startFlags, ProfilerInfo profilerInfo, Bundle options, int userId) {
  8.     enforceNotIsolatedCaller("startActivity");
  9.     userId = handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(), userId,
  10.             false, ALLOW_FULL_ONLY, "startActivity", null);
  11.     //[见小节2.7]
  12.     return mStackSupervisor.startActivityMayWait(caller, -1, callingPackage, intent,
  13.             resolvedType, null, null, resultTo, resultWho, requestCode, startFlags,
  14.             profilerInfo, null, null, options, false, userId, null, null);
  15. }

此处mStackSupervisor的数据类型为ActivityStackSupervisor

2.7 ASS.startActivityMayWait

当程序运行到这里时, ASS.startActivityMayWait的各个参数取值如下:

  • caller = ApplicationThreadProxy, 用于跟调用者进程ApplicationThread进行通信的binder代理类.
  • callingUid = -1;
  • callingPackage = ContextImpl.getBasePackageName(),获取调用者Activity所在包名
  • intent: 这是启动Activity时传递过来的参数;
  • resolvedType = intent.resolveTypeIfNeeded
  • voiceSession = null;
  • voiceInteractor = null;
  • resultTo = Activity.mToken, 其中Activity是指调用者所在Activity, mToken对象保存自己所处的ActivityRecord信息
  • resultWho = Activity.mEmbeddedID, 其中Activity是指调用者所在Activity
  • requestCode = -1;
  • startFlags = 0;
  • profilerInfo = null;
  • outResult = null;
  • config = null;
  • options = null;
  • ignoreTargetSecurity = false;
  • userId = AMS.handleIncomingUser, 当调用者userId跟当前处于同一个userId,则直接返回该userId;当不相等时则根据调用者userId来决定是否需要将callingUserId转换为mCurrentUserId.
  • iContainer = null;
  • inTask = null;

再来看看这个方法的源码:

[-> ActivityStackSupervisor.java]

  1. ​
  2. ​
  3. ​
  4. final int startActivityMayWait(IApplicationThread caller, int callingUid, String 
  5.  
  6. callingPackage, Intent intent, String resolvedType, IVoiceInteractionSession 
  7.  
  8. voiceSession, IVoiceInteractor voiceInteractor, IBinder resultTo, String 
  9.  
  10. resultWho, int requestCode, int startFlags, ProfilerInfo profilerInfo, WaitResult 
  11.  
  12. outResult, Configuration config, Bundle options, boolean ignoreTargetSecurity, 
  13.  
  14. int userId, IActivityContainer iContainer, TaskRecord inTask) {
  15.     ...
  16.     boolean componentSpecified = intent.getComponent() != null;
  17.     //创建新的Intent对象，即便intent被修改也不受影响
  18.     intent = new Intent(intent);
  19.  
  20.     //收集Intent所指向的Activity信息, 当存在多个可供选择的Activity,则直接向用户弹出resolveActivity [见2.7.1]
  21.     ActivityInfo aInfo = resolveActivity(intent, resolvedType, startFlags, profilerInfo, userId);
  22.  
  23.     ActivityContainer container = (ActivityContainer)iContainer;
  24.     synchronized (mService) {
  25.         if (container != null && container.mParentActivity != null &&
  26.                 container.mParentActivity.state != RESUMED) {
  27.             ... //不进入该分支, container == nul
  28.         }
  29.  
  30.         final int realCallingPid = Binder.getCallingPid();
  31.         final int realCallingUid = Binder.getCallingUid();
  32.         int callingPid;
  33.         if (callingUid >= 0) {
  34.             callingPid = -1;
  35.         } else if (caller == null) {
  36.             callingPid = realCallingPid;
  37.             callingUid = realCallingUid;
  38.         } else {
  39.             callingPid = callingUid = -1;
  40.         }
  41.  
  42.         final ActivityStack stack;
  43.         if (container == null || container.mStack.isOnHomeDisplay()) {
  44.             stack = mFocusedStack; // 进入该分支
  45.         } else {
  46.             stack = container.mStack;
  47.         }
  48.  
  49.         //此时mConfigWillChange = false
  50.         stack.mConfigWillChange = config != null && mService.mConfiguration.diff(config) != 0;
  51.  
  52.         final long origId = Binder.clearCallingIdentity();
  53.  
  54.         if (aInfo != null &&
  55.                 (aInfo.applicationInfo.privateFlags
  56.                         &ApplicationInfo.PRIVATE_FLAG_CANT_SAVE_STATE) != 0) {
  57.             // heavy-weight进程处理流程, 一般情况下不进入该分支
  58.             if (aInfo.processName.equals(aInfo.applicationInfo.packageName)) {
  59.                 ...
  60.             }
  61.         }
  62.  
  63.         //[见流程2.8]
  64.         int res = startActivityLocked(caller, intent, resolvedType, aInfo,
  65.                 voiceSession, voiceInteractor, resultTo, resultWho,
  66.                 requestCode, callingPid, callingUid, callingPackage,
  67.                 realCallingPid, realCallingUid, startFlags, options, ignoreTargetSecurity,
  68.                 componentSpecified, null, container, inTask);
  69.  
  70.         Binder.restoreCallingIdentity(origId);
  71.  
  72.         if (stack.mConfigWillChange) {
  73.             ... //不进入该分支
  74.         }
  75.  
  76.         if (outResult != null) {
  77.             ... //不进入该分支
  78.         }
  79.  
  80.         return res;
  81.     }
  82. }
  83.  
  84. ​
  85.  
  86. ​
  87.  
  88. ​

该过程主要功能：通过resolveActivity来获取ActivityInfo信息, 然后再进入ASS.startActivityLocked().先来看看

2.7.1 ASS.resolveActivity

  1. // startFlags = 0; profilerInfo = null; userId代表caller UserId
  2. ActivityInfo resolveActivity(Intent intent, String resolvedType, int startFlags, ProfilerInfo profilerInfo, int userId) {
  3.     ActivityInfo aInfo;
  4.     ResolveInfo rInfo =
  5.         AppGlobals.getPackageManager().resolveIntent(
  6.                 intent, resolvedType,
  7.                 PackageManager.MATCH_DEFAULT_ONLY
  8.                             | ActivityManagerService.STOCK_PM_FLAGS, userId);
  9.     aInfo = rInfo != null ? rInfo.activityInfo : null;
  10.     if (aInfo != null) {
  11.         intent.setComponent(new ComponentName(
  12.                 aInfo.applicationInfo.packageName, aInfo.name));
  13.  
  14.         if (!aInfo.processName.equals("system")) {
  15.             ... //对于非system进程，根据flags来设置相应的debug信息
  16.         }
  17.     }
  18.     return aInfo;
  19. }

ActivityManager类有如下4个flags用于调试：

  • START_FLAG_DEBUG：用于调试debug app
  • START_FLAG_OPENGL_TRACES：用于调试OpenGL tracing
  • START_FLAG_NATIVE_DEBUGGING：用于调试native
  • START_FLAG_TRACK_ALLOCATION: 用于调试allocation tracking

2.7.2 PKMS.resolveIntent

AppGlobals.getPackageManager()经过函数层层调用，获取的是ApplicationPackageManager对象。经过binder IPC调用，最终会调用PackageManagerService对象。故此时调用方法为PMS.resolveIntent().

[-> PackageManagerService.java]

  1. public ResolveInfo resolveIntent(Intent intent, String resolvedType, int flags, int userId) {
  2.      if (!sUserManager.exists(userId)) return null;
  3.      enforceCrossUserPermission(Binder.getCallingUid(), userId, false, false, "resolve intent");
  4.      //[见流程2.7.3]
  5.      List<ResolveInfo> query = queryIntentActivities(intent, resolvedType, flags, userId);
  6.      //根据priority，preferred选择最佳的Activity
  7.      return chooseBestActivity(intent, resolvedType, flags, query, userId);
  8.  }

2.7.3 PMS.queryIntentActivities

  1. public List<ResolveInfo> queryIntentActivities(Intent intent,
  2.         String resolvedType, int flags, int userId) {
  3.     ...
  4.     ComponentName comp = intent.getComponent();
  5.     if (comp == null) {
  6.         if (intent.getSelector() != null) {
  7.             intent = intent.getSelector();
  8.             comp = intent.getComponent();
  9.         }
  10.     }
  11.  
  12.     if (comp != null) {
  13.         final List<ResolveInfo> list = new ArrayList<ResolveInfo>(1);
  14.         //获取Activity信息
  15.         final ActivityInfo ai = getActivityInfo(comp, flags, userId);
  16.         if (ai != null) {
  17.             final ResolveInfo ri = new ResolveInfo();
  18.             ri.activityInfo = ai;
  19.             list.add(ri);
  20.         }
  21.         return list;
  22.     }
  23.     ...
  24. }

ASS.resolveActivity()方法的核心功能是找到相应的Activity组件，并保存到intent对象。

2.8 ASS.startActivityLocked

[-> ActivityStackSupervisor.java]

  1. ​
  2. ​
  3. final int startActivityLocked(IApplicationThread caller, Intent intent, String resolvedType, ActivityInfo aInfo, IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor, IBinder resultTo, String resultWho, int requestCode, int callingPid, int callingUid, String callingPackage, int realCallingPid, int realCallingUid, int startFlags, Bundle options, boolean ignoreTargetSecurity, boolean componentSpecified, ActivityRecord[] outActivity, ActivityContainer container, TaskRecord inTask) {
  4.     int err = ActivityManager.START_SUCCESS;
  5.  
  6.     //获取调用者的进程记录对象
  7.     ProcessRecord callerApp = null;
  8.     if (caller != null) {
  9.         callerApp = mService.getRecordForAppLocked(caller);
  10.         if (callerApp != null) {
  11.             callingPid = callerApp.pid;
  12.             callingUid = callerApp.info.uid;
  13.         } else {
  14.             err = ActivityManager.START_PERMISSION_DENIED;
  15.         }
  16.     }
  17.  
  18.     final int userId = aInfo != null ?  UserHandle.getUserId(aInfo.applicationInfo.uid) : 0;
  19.  
  20.     ActivityRecord sourceRecord = null;
  21.     ActivityRecord resultRecord = null;
  22.     if (resultTo != null) {
  23.         //获取调用者所在的Activity
  24.         sourceRecord = isInAnyStackLocked(resultTo);
  25.         if (sourceRecord != null) {
  26.             if (requestCode >= 0 && !sourceRecord.finishing) {
  27.                 ... //requestCode = -1 则不进入
  28.             }
  29.         }
  30.     }
  31.  
  32.     final int launchFlags = intent.getFlags();
  33.  
  34.     if ((launchFlags & Intent.FLAG_ACTIVITY_FORWARD_RESULT) != 0 && sourceRecord != null) {
  35.         ... // activity执行结果的返回由源Activity转换到新Activity, 不需要返回结果则不会进入该分支
  36.     }
  37.  
  38.     if (err == ActivityManager.START_SUCCESS && intent.getComponent() == null) {
  39.         //从Intent中无法找到相应的Component
  40.         err = ActivityManager.START_INTENT_NOT_RESOLVED;
  41.     }
  42.  
  43.     if (err == ActivityManager.START_SUCCESS && aInfo == null) {
  44.         //从Intent中无法找到相应的ActivityInfo
  45.         err = ActivityManager.START_INTENT_NOT_RESOLVED;
  46.     }
  47.  
  48.     if (err == ActivityManager.START_SUCCESS
  49.             && !isCurrentProfileLocked(userId)
  50.             && (aInfo.flags & FLAG_SHOW_FOR_ALL_USERS) == 0) {
  51.         //尝试启动一个后台Activity, 但该Activity对当前用户不可见
  52.         err = ActivityManager.START_NOT_CURRENT_USER_ACTIVITY;
  53.     }
  54.     ...
  55.  
  56.     //执行后resultStack = null
  57.     final ActivityStack resultStack = resultRecord == null ? null : resultRecord.task.stack;
  58.  
  59.     ... //权限检查
  60.  
  61.     // ActivityController不为空的情况，比如monkey测试过程
  62.     if (mService.mController != null) {
  63.         Intent watchIntent = intent.cloneFilter();
  64.         abort |= !mService.mController.activityStarting(watchIntent,
  65.                 aInfo.applicationInfo.packageName);
  66.     }
  67.  
  68.     if (abort) {
  69.         ... //权限检查不满足,才进入该分支则直接返回；
  70.         return ActivityManager.START_SUCCESS;
  71.     }
  72.     // 创建Activity记录对象
  73.     ActivityRecord r = new ActivityRecord(mService, callerApp, callingUid, callingPackage,
  74.             intent, resolvedType, aInfo, mService.mConfiguration, resultRecord, resultWho,
  75.             requestCode, componentSpecified, voiceSession != null, this, container, options);
  76.     if (outActivity != null) {
  77.         outActivity[0] = r;
  78.     }
  79.  
  80.     if (r.appTimeTracker == null && sourceRecord != null) {
  81.         r.appTimeTracker = sourceRecord.appTimeTracker;
  82.     }
  83.     // 将mFocusedStack赋予当前stack
  84.     final ActivityStack stack = mFocusedStack;
  85.     if (voiceSession == null && (stack.mResumedActivity == null
  86.             || stack.mResumedActivity.info.applicationInfo.uid != callingUid)) {
  87.         // 前台stack还没有resume状态的Activity时, 则检查app切换是否允许
  88.         if (!mService.checkAppSwitchAllowedLocked(callingPid, callingUid,
  89.                 realCallingPid, realCallingUid, "Activity start")) {
  90.             PendingActivityLaunch pal =
  91.                     new PendingActivityLaunch(r, sourceRecord, startFlags, stack);
  92.             // 当不允许切换,则把要启动的Activity添加到mPendingActivityLaunches对象, 并且直接返回.
  93.             mPendingActivityLaunches.add(pal);
  94.             ActivityOptions.abort(options);
  95.             return ActivityManager.START_SWITCHES_CANCELED;
  96.         }
  97.     }
  98.  
  99.     if (mService.mDidAppSwitch) {
  100.         //从上次禁止app切换以来,这是第二次允许app切换,因此将允许切换时间设置为0,则表示可以任意切换app
  101.         mService.mAppSwitchesAllowedTime = 0;
  102.     } else {
  103.         mService.mDidAppSwitch = true;
  104.     }
  105.     //处理 pendind Activity的启动, 这些Activity是由于app switch禁用从而被hold的等待启动activity 
  106.     doPendingActivityLaunchesLocked(false);
  107.  
  108.     //[见流程2.9]
  109.     err = startActivityUncheckedLocked(r, sourceRecord, voiceSession, voiceInteractor,
  110.             startFlags, true, options, inTask);
  111.  
  112.     if (err < 0) {
  113.         notifyActivityDrawnForKeyguard();
  114.     }
  115.     return err;
  116. }
  117.  
  118. ​

其中有两个返回值代表启动Activity失败：

  • START_INTENT_NOT_RESOLVED: 从Intent中无法找到相应的Component或者ActivityInfo
  • START_NOT_CURRENT_USER_ACTIVITY：该Activity对当前用户不可见

2.9 ASS.startActivityUncheckedLocked

[-> ActivityStackSupervisor.java]

  1. ​
  2. ​
  3. ​
  4. // sourceRecord是指调用者， r是指本次将要启动的Activity
  5. final int startActivityUncheckedLocked(final ActivityRecord r, ActivityRecord sourceRecord, IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor, int startFlags, boolean doResume, Bundle options, TaskRecord inTask) {
  6.     final Intent intent = r.intent;
  7.     final int callingUid = r.launchedFromUid;
  8.  
  9.     if (inTask != null && !inTask.inRecents) {
  10.         inTask = null;
  11.     }
  12.  
  13.     final boolean launchSingleTop = r.launchMode == ActivityInfo.LAUNCH_SINGLE_TOP;
  14.     final boolean launchSingleInstance = r.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE;
  15.     final boolean launchSingleTask = r.launchMode == ActivityInfo.LAUNCH_SINGLE_TASK;
  16.  
  17.     int launchFlags = intent.getFlags();
  18.     // 当intent和activity manifest存在冲突，则manifest优先
  19.     if ((launchFlags & Intent.FLAG_ACTIVITY_NEW_DOCUMENT) != 0 &&
  20.             (launchSingleInstance || launchSingleTask)) {
  21.         launchFlags &=
  22.                 ~(Intent.FLAG_ACTIVITY_NEW_DOCUMENT | Intent.FLAG_ACTIVITY_MULTIPLE_TASK);
  23.     } else {
  24.         ...
  25.     }
  26.  
  27.     ...
  28.  
  29.     mUserLeaving = (launchFlags & Intent.FLAG_ACTIVITY_NO_USER_ACTION) == 0;
  30.     //当本次不需要resume，则设置为延迟resume的状态
  31.     if (!doResume) {
  32.         r.delayedResume = true;
  33.     }
  34.  
  35.     ActivityRecord notTop =
  36.             (launchFlags & Intent.FLAG_ACTIVITY_PREVIOUS_IS_TOP) != 0 ? r : null;
  37.  
  38.     if ((startFlags&ActivityManager.START_FLAG_ONLY_IF_NEEDED) != 0) {
  39.         ActivityRecord checkedCaller = sourceRecord;
  40.         if (checkedCaller == null) {
  41.             checkedCaller = mFocusedStack.topRunningNonDelayedActivityLocked(notTop);
  42.         }
  43.         if (!checkedCaller.realActivity.equals(r.realActivity)) {
  44.             //调用者 与将要启动的Activity不相同时，进入该分支。
  45.             startFlags &= ~ActivityManager.START_FLAG_ONLY_IF_NEEDED;
  46.         }
  47.     }
  48.  
  49.     boolean addingToTask = false;
  50.     TaskRecord reuseTask = null;
  51.  
  52.     //当调用者不是来自activity，而是明确指定task的情况。
  53.     if (sourceRecord == null && inTask != null && inTask.stack != null) {
  54.         ... //目前sourceRecord不为空，则不进入该分支
  55.     } else {
  56.         inTask = null;
  57.     }
  58.  
  59.     if (inTask == null) {
  60.         if (sourceRecord == null) {
  61.             //调用者并不是Activity context,则强制创建新task
  62.             if ((launchFlags & Intent.FLAG_ACTIVITY_NEW_TASK) == 0 && inTask == null) {
  63.                 launchFlags |= Intent.FLAG_ACTIVITY_NEW_TASK;
  64.             }
  65.         } else if (sourceRecord.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE) {
  66.             //调用者activity带有single instance，则创建新task
  67.             launchFlags |= Intent.FLAG_ACTIVITY_NEW_TASK;
  68.         } else if (launchSingleInstance || launchSingleTask) {
  69.             //目标activity带有single instance或者single task，则创建新task
  70.             launchFlags |= Intent.FLAG_ACTIVITY_NEW_TASK;
  71.         }
  72.     }
  73.  
  74.     ActivityInfo newTaskInfo = null;
  75.     Intent newTaskIntent = null;
  76.     ActivityStack sourceStack;
  77.     if (sourceRecord != null) {
  78.         if (sourceRecord.finishing) {
  79.             //调用者处于即将finish状态，则创建新task
  80.             if ((launchFlags & Intent.FLAG_ACTIVITY_NEW_TASK) == 0) {
  81.                 launchFlags |= Intent.FLAG_ACTIVITY_NEW_TASK;
  82.                 newTaskInfo = sourceRecord.info;
  83.                 newTaskIntent = sourceRecord.task.intent;
  84.             }
  85.             sourceRecord = null;
  86.             sourceStack = null;
  87.         } else {
  88.             //当调用者Activity不为空，且不处于finishing状态，则其所在栈赋于sourceStack
  89.             sourceStack = sourceRecord.task.stack;
  90.         }
  91.     } else {
  92.         sourceStack = null;
  93.     }
  94.     ...
  95.     targetStack.mLastPausedActivity = null;
  96.     //创建activity [见流程2.10]
  97.     targetStack.startActivityLocked(r, newTask, doResume, keepCurTransition, options);
  98.     if (!launchTaskBehind) {
  99.         mService.setFocusedActivityLocked(r, "startedActivity");
  100.     }
  101.     return ActivityManager.START_SUCCESS;
  102. }

找到或创建新的Activit所属于的Task对象，之后调用AS.startActivityLocked

2.9.1 Launch Mode

先来说说在ActivityInfo.java中定义了4类Launch Mode：

  • LAUNCH_MULTIPLE(standard)：最常见的情形，每次启动Activity都是创建新的Activity;
  • LAUNCH_SINGLE_TOP: 当Task顶部存在同一个Activity则不再重新创建；其余情况同上；
  • LAUNCH_SINGLE_TASK：当Task栈存在同一个Activity(不在task顶部)，则不重新创建，而移除该Activity上面其他的Activity；其余情况同上；
  • LAUNCH_SINGLE_INSTANCE：每个Task只有一个Activity.

再来说说几个常见的flag含义：

  • FLAG_ACTIVITY_NEW_TASK：将Activity放入一个新启动的Task；
  • FLAG_ACTIVITY_CLEAR_TASK：启动Activity时，将目标Activity关联的Task清除，再启动新Task，将该Activity放入该Task。该flags跟FLAG_ACTIVITY_NEW_TASK配合使用。
  • FLAG_ACTIVITY_CLEAR_TOP：启动非栈顶Activity时，先清除该Activity之上的Activity。例如Task已有A、B、C3个Activity，启动A，则清除B，C。类似于SingleTop。

最后再说说：设置FLAG_ACTIVITY_NEW_TASK的几个情况：

  • 调用者并不是Activity context；
  • 调用者activity带有single instance；
  • 目标activity带有single instance或者single task；
  • 调用者处于finishing状态；

2.10 AS.startActivityLocked

[-> ActivityStack.java]

  1. final void startActivityLocked(ActivityRecord r, boolean newTask, boolean doResume, boolean keepCurTransition, Bundle options) {
  2.     TaskRecord rTask = r.task;
  3.     final int taskId = rTask.taskId;
  4.     if (!r.mLaunchTaskBehind && (taskForIdLocked(taskId) == null || newTask)) {
  5.         //task中的上一个activity已被移除，或者ams重用该task,则将该task移到顶部
  6.         insertTaskAtTop(rTask, r);
  7.         mWindowManager.moveTaskToTop(taskId);
  8.     }
  9.     TaskRecord task = null;
  10.     if (!newTask) {
  11.         boolean startIt = true;
  12.         for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
  13.             task = mTaskHistory.get(taskNdx);
  14.             if (task.getTopActivity() == null) {
  15.                 //该task所有activity都finishing
  16.                 continue;
  17.             }
  18.             if (task == r.task) {
  19.                 if (!startIt) {
  20.                     task.addActivityToTop(r);
  21.                     r.putInHistory();
  22.                     mWindowManager.addAppToken(task.mActivities.indexOf(r), r.appToken,
  23.                             r.task.taskId, mStackId, r.info.screenOrientation, r.fullscreen,
  24.                             (r.info.flags & ActivityInfo.FLAG_SHOW_FOR_ALL_USERS) != 0,
  25.                             r.userId, r.info.configChanges, task.voiceSession != null,
  26.                             r.mLaunchTaskBehind);
  27.                     ActivityOptions.abort(options);
  28.                     return;
  29.                 }
  30.                 break;
  31.             } else if (task.numFullscreen > 0) {
  32.                 startIt = false;
  33.             }
  34.         }
  35.     }
  36.  
  37.     if (task == r.task && mTaskHistory.indexOf(task) != (mTaskHistory.size() - 1)) {
  38.         mStackSupervisor.mUserLeaving = false;
  39.     }
  40.  
  41.     task = r.task;
  42.     task.addActivityToTop(r);
  43.     task.setFrontOfTask();
  44.  
  45.     r.putInHistory();
  46.     mActivityTrigger.activityStartTrigger(r.intent, r.info, r.appInfo);
  47.     if (!isHomeStack() || numActivities() > 0) {
  48.         //当切换到新的task，或者下一个activity进程目前并没有运行，则
  49.         boolean showStartingIcon = newTask;
  50.         ProcessRecord proc = r.app;
  51.         if (proc == null) {
  52.             proc = mService.mProcessNames.get(r.processName, r.info.applicationInfo.uid);
  53.         }
  54.  
  55.         if (proc == null || proc.thread == null) {
  56.             showStartingIcon = true;
  57.         }
  58.         if ((r.intent.getFlags() & Intent.FLAG_ACTIVITY_NO_ANIMATION) != 0) {
  59.             mWindowManager.prepareAppTransition(AppTransition.TRANSIT_NONE, keepCurTransition);
  60.             mNoAnimActivities.add(r);
  61.         } else {
  62.             mWindowManager.prepareAppTransition(newTask
  63.                     ? r.mLaunchTaskBehind
  64.                             ? AppTransition.TRANSIT_TASK_OPEN_BEHIND
  65.                             : AppTransition.TRANSIT_TASK_OPEN
  66.                     : AppTransition.TRANSIT_ACTIVITY_OPEN, keepCurTransition);
  67.             mNoAnimActivities.remove(r);
  68.         }
  69.         mWindowManager.addAppToken(task.mActivities.indexOf(r),
  70.                 r.appToken, r.task.taskId, mStackId, r.info.screenOrientation, r.fullscreen,
  71.                 (r.info.flags & ActivityInfo.FLAG_SHOW_FOR_ALL_USERS) != 0, r.userId,
  72.                 r.info.configChanges, task.voiceSession != null, r.mLaunchTaskBehind);
  73.         boolean doShow = true;
  74.         if (newTask) {
  75.             if ((r.intent.getFlags() & Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED) != 0) {
  76.                 resetTaskIfNeededLocked(r, r);
  77.                 doShow = topRunningNonDelayedActivityLocked(null) == r;
  78.             }
  79.         } else if (options != null && new ActivityOptions(options).getAnimationType()
  80.                 == ActivityOptions.ANIM_SCENE_TRANSITION) {
  81.             doShow = false;
  82.         }
  83.         if (r.mLaunchTaskBehind) {
  84.             mWindowManager.setAppVisibility(r.appToken, true);
  85.             ensureActivitiesVisibleLocked(null, 0);
  86.         } else if (SHOW_APP_STARTING_PREVIEW && doShow) {
  87.             ActivityRecord prev = mResumedActivity;
  88.             if (prev != null) {
  89.                 //当前activity所属不同的task
  90.                 if (prev.task != r.task) {
  91.                     prev = null;
  92.                 }
  93.                 //当前activity已经displayed
  94.                 else if (prev.nowVisible) {
  95.                     prev = null;
  96.                 }
  97.             }
  98.  
  99.             mWindowManager.setAppStartingWindow(
  100.                     r.appToken, r.packageName, r.theme,
  101.                     mService.compatibilityInfoForPackageLocked(
  102.                              r.info.applicationInfo), r.nonLocalizedLabel,
  103.                     r.labelRes, r.icon, r.logo, r.windowFlags,
  104.                     prev != null ? prev.appToken : null, showStartingIcon);
  105.             r.mStartingWindowShown = true;
  106.         }
  107.     } else {
  108.         mWindowManager.addAppToken(task.mActivities.indexOf(r), r.appToken,
  109.                 r.task.taskId, mStackId, r.info.screenOrientation, r.fullscreen,
  110.                 (r.info.flags & ActivityInfo.FLAG_SHOW_FOR_ALL_USERS) != 0, r.userId,
  111.                 r.info.configChanges, task.voiceSession != null, r.mLaunchTaskBehind);
  112.         ActivityOptions.abort(options);
  113.         options = null;
  114.     }
  115.  
  116.     if (doResume) {
  117.         // [见流程2.11]
  118.         mStackSupervisor.resumeTopActivitiesLocked(this, r, options);
  119.     }
  120. }

2.11 ASS.resumeTopActivitiesLocked

  1. boolean resumeTopActivitiesLocked(ActivityStack targetStack, ActivityRecord target, Bundle targetOptions) {
  2.     if (targetStack == null) {
  3.         targetStack = mFocusedStack;
  4.     }
  5.  
  6.     boolean result = false;
  7.     if (isFrontStack(targetStack)) {
  8.         //[见流程2.12]
  9.         result = targetStack.resumeTopActivityLocked(target, targetOptions);
  10.     }
  11.  
  12.     for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
  13.         final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
  14.         for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
  15.             final ActivityStack stack = stacks.get(stackNdx);
  16.             if (stack == targetStack) {
  17.                 //上面刚已启动
  18.                 continue;
  19.             }
  20.             if (isFrontStack(stack)) {
  21.                 stack.resumeTopActivityLocked(null);
  22.             }
  23.         }
  24.     }
  25.     return result;
  26. }

2.12 AS.resumeTopActivityLocked

  1. final boolean resumeTopActivityLocked(ActivityRecord prev, Bundle options) {
  2.     if (mStackSupervisor.inResumeTopActivity) {
  3.         return false; //防止递归启动
  4.     }
  5.  
  6.     boolean result = false;
  7.     try {
  8.         mStackSupervisor.inResumeTopActivity = true;
  9.         if (mService.mLockScreenShown == ActivityManagerService.LOCK_SCREEN_LEAVING) {
  10.             mService.mLockScreenShown = ActivityManagerService.LOCK_SCREEN_HIDDEN;
  11.             mService.updateSleepIfNeededLocked();
  12.         }
  13.         //[见流程2.13]
  14.         result = resumeTopActivityInnerLocked(prev, options);
  15.     } finally {
  16.         mStackSupervisor.inResumeTopActivity = false;
  17.     }
  18.     return result;
  19. }

inResumeTopActivity用于保证每次只有一个Activity执行resumeTopActivityLocked()操作.

2.13 AS.resumeTopActivityInnerLocked

  1. ​
  2. private boolean resumeTopActivityInnerLocked(ActivityRecord prev, Bundle options) {
  3.     ... //系统没有进入booting或booted状态，则不允许启动Activity
  4.  
  5.     ActivityRecord parent = mActivityContainer.mParentActivity;
  6.     if ((parent != null && parent.state != ActivityState.RESUMED) ||
  7.             !mActivityContainer.isAttachedLocked()) {
  8.         return false;
  9.     }
  10.     //top running之后的任意处于初始化状态且有显示StartingWindow, 则移除StartingWindow
  11.     cancelInitializingActivities();
  12.  
  13.     //找到第一个没有finishing的栈顶activity
  14.     final ActivityRecord next = topRunningActivityLocked(null);
  15.  
  16.     final boolean userLeaving = mStackSupervisor.mUserLeaving;
  17.     mStackSupervisor.mUserLeaving = false;
  18.  
  19.     final TaskRecord prevTask = prev != null ? prev.task : null;
  20.     if (next == null) {
  21.         final String reason = "noMoreActivities";
  22.         if (!mFullscreen) {
  23.             //当该栈没有全屏，则尝试聚焦到下一个可见的stack
  24.             final ActivityStack stack = getNextVisibleStackLocked();
  25.             if (adjustFocusToNextVisibleStackLocked(stack, reason)) {
  26.                 return mStackSupervisor.resumeTopActivitiesLocked(stack, prev, null);
  27.             }
  28.         }
  29.         ActivityOptions.abort(options);
  30.         final int returnTaskType = prevTask == null || !prevTask.isOverHomeStack() ?
  31.                 HOME_ACTIVITY_TYPE : prevTask.getTaskToReturnTo();
  32.         //启动home桌面activity
  33.         return isOnHomeDisplay() &&
  34.                 mStackSupervisor.resumeHomeStackTask(returnTaskType, prev, reason);
  35.     }
  36.  
  37.     ......
  38.  
  39.     //处于睡眠或者关机状态，top activity已暂停的情况下
  40.     if (mService.isSleepingOrShuttingDown()
  41.             && mLastPausedActivity == next
  42.             && mStackSupervisor.allPausedActivitiesComplete()) {
  43.         mWindowManager.executeAppTransition();
  44.         mNoAnimActivities.clear();
  45.         ActivityOptions.abort(options);
  46.         return false;
  47.     }
  48.  
  49.     if (mService.mStartedUsers.get(next.userId) == null) {
  50.         return false; //拥有该activity的用户没有启动则直接返回
  51.     }
  52.  
  53.     mStackSupervisor.mStoppingActivities.remove(next);
  54.     mStackSupervisor.mGoingToSleepActivities.remove(next);
  55.     next.sleeping = false;
  56.     mStackSupervisor.mWaitingVisibleActivities.remove(next);
  57.  
  58.     mActivityTrigger.activityResumeTrigger(next.intent, next.info, next.appInfo);
  59.  
  60.     if (!mStackSupervisor.allPausedActivitiesComplete()) {
  61.         return false; //当正处于暂停activity，则直接返回
  62.     }
  63.  
  64.     mStackSupervisor.setLaunchSource(next.info.applicationInfo.uid);
  65.  
  66.     //需要等待暂停当前activity完成，再resume top activity
  67.     boolean dontWaitForPause = (next.info.flags&ActivityInfo.FLAG_RESUME_WHILE_PAUSING) != 0;
  68.     //暂停其他Activity[见小节2.13.1]
  69.     boolean pausing = mStackSupervisor.pauseBackStacks(userLeaving, true, dontWaitForPause);
  70.     if (mResumedActivity != null) {
  71.         //当前resumd状态activity不为空，则需要先暂停该Activity
  72.         pausing |= startPausingLocked(userLeaving, false, true, dontWaitForPause);
  73.     }
  74.     if (pausing) {
  75.         if (next.app != null && next.app.thread != null) {
  76.             mService.updateLruProcessLocked(next.app, true, null);
  77.         }
  78.         return true;
  79.     }
  80.     ......
  81.  
  82.     Bundle resumeAnimOptions = null;
  83.     if (anim) {
  84.         ActivityOptions opts = next.getOptionsForTargetActivityLocked();
  85.         if (opts != null) {
  86.             resumeAnimOptions = opts.toBundle();
  87.         }
  88.         next.applyOptionsLocked();
  89.     } else {
  90.         next.clearOptionsLocked();
  91.     }
  92.  
  93.     ActivityStack lastStack = mStackSupervisor.getLastStack();
  94.     //进程已存在的情况
  95.     if (next.app != null && next.app.thread != null) {
  96.         //activity正在成为可见
  97.         mWindowManager.setAppVisibility(next.appToken, true);
  98.  
  99.         next.startLaunchTickingLocked();
  100.  
  101.         ActivityRecord lastResumedActivity = lastStack == null ? null :lastStack.mResumedActivity;
  102.         ActivityState lastState = next.state;
  103.  
  104.         mService.updateCpuStats();
  105.         //设置Activity状态为resumed
  106.         next.state = ActivityState.RESUMED;
  107.         mResumedActivity = next;
  108.         next.task.touchActiveTime();
  109.         mRecentTasks.addLocked(next.task);
  110.         mService.updateLruProcessLocked(next.app, true, null);
  111.         updateLRUListLocked(next);
  112.         mService.updateOomAdjLocked();
  113.  
  114.         boolean notUpdated = true;
  115.         if (mStackSupervisor.isFrontStack(this)) {
  116.             Configuration config = mWindowManager.updateOrientationFromAppTokens(
  117.                     mService.mConfiguration,
  118.                     next.mayFreezeScreenLocked(next.app) ? next.appToken : null);
  119.             if (config != null) {
  120.                 next.frozenBeforeDestroy = true;
  121.             }
  122.             notUpdated = !mService.updateConfigurationLocked(config, next, false, false);
  123.         }
  124.  
  125.         if (notUpdated) {
  126.             ActivityRecord nextNext = topRunningActivityLocked(null);
  127.  
  128.             if (nextNext != next) {
  129.                 mStackSupervisor.scheduleResumeTopActivities();
  130.             }
  131.             if (mStackSupervisor.reportResumedActivityLocked(next)) {
  132.                 mNoAnimActivities.clear();
  133.                 return true;
  134.             }
  135.             return false;
  136.         }
  137.  
  138.         try {
  139.             //分发所有pending结果.
  140.             ArrayList<ResultInfo> a = next.results;
  141.             if (a != null) {
  142.                 final int N = a.size();
  143.                 if (!next.finishing && N > 0) {
  144.                     next.app.thread.scheduleSendResult(next.appToken, a);
  145.                 }
  146.             }
  147.  
  148.             if (next.newIntents != null) {
  149.                 next.app.thread.scheduleNewIntent(next.newIntents, next.appToken);
  150.             }
  151.  
  152.             next.sleeping = false;
  153.             mService.showAskCompatModeDialogLocked(next);
  154.             next.app.pendingUiClean = true;
  155.             next.app.forceProcessStateUpTo(mService.mTopProcessState);
  156.             next.clearOptionsLocked();
  157.             //触发onResume()
  158.             next.app.thread.scheduleResumeActivity(next.appToken, next.app.repProcState,
  159.                     mService.isNextTransitionForward(), resumeAnimOptions);
  160.  
  161.             mStackSupervisor.checkReadyForSleepLocked();
  162.  
  163.         } catch (Exception e) {
  164.             ...
  165.             return true;
  166.         }
  167.         next.visible = true;
  168.         completeResumeLocked(next);
  169.         next.stopped = false;
  170.  
  171.     } else {
  172.         if (!next.hasBeenLaunched) {
  173.             next.hasBeenLaunched = true;
  174.         } else {
  175.             if (SHOW_APP_STARTING_PREVIEW) {
  176.                 mWindowManager.setAppStartingWindow(
  177.                         next.appToken, next.packageName, next.theme,
  178.                         mService.compatibilityInfoForPackageLocked(
  179.                                 next.info.applicationInfo),
  180.                         next.nonLocalizedLabel,
  181.                         next.labelRes, next.icon, next.logo, next.windowFlags,
  182.                         null, true);
  183.             }
  184.         }
  185.         //见流程2.14
  186.         mStackSupervisor.startSpecificActivityLocked(next, true, true);
  187.     }
  188.     return true;
  189. }
  190.  
  191. ​

主要分支功能：

  • 当找不到需要resume的Activity，则直接回到桌面；
  • 否则，当mResumedActivity不为空，则执行startPausingLocked()暂停该activity;
  • 然后再进入startSpecificActivityLocked环节，接下来从这里继续往下说。

2.14 ASS.startSpecificActivityLocked

  1. void startSpecificActivityLocked(ActivityRecord r, boolean andResume, boolean checkConfig) {
  2.     ProcessRecord app = mService.getProcessRecordLocked(r.processName,
  3.             r.info.applicationInfo.uid, true);
  4.  
  5.     r.task.stack.setLaunchTime(r);
  6.  
  7.     if (app != null && app.thread != null) {
  8.         try {
  9.             if ((r.info.flags&ActivityInfo.FLAG_MULTIPROCESS) == 0
  10.                     || !"android".equals(r.info.packageName)) {
  11.                 app.addPackage(r.info.packageName, r.info.applicationInfo.versionCode,
  12.                         mService.mProcessStats);
  13.             }
  14.             //真正的启动Activity【见流程2.17】
  15.             realStartActivityLocked(r, app, andResume, checkConfig);
  16.             return;
  17.         } catch (RemoteException e) {
  18.             Slog.w(TAG, "Exception when starting activity "
  19.                     + r.intent.getComponent().flattenToShortString(), e);
  20.         }
  21.  
  22.     }
  23.     //当进程不存在则创建进程 [见流程2.14.1]
  24.     mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,
  25.             "activity", r.intent.getComponent(), false, false, true);
  26. }

2.15 AMS.startProcessLocked

    在文章理解Android进程启动之全过程中，详细介绍了AMS.startProcessLocked()整个过程，创建完新进程后会在新进程中调用AMP.attachApplication ，该方法经过binder ipc后调用到AMS.attachApplicationLocked。

  1. private final boolean attachApplicationLocked(IApplicationThread thread, int pid) {
  2.     ...
  3.     只有当系统启动完，或者app允许启动过程允许，则会true
  4.     boolean normalMode = mProcessesReady || isAllowedWhileBooting(app.info);
  5.     thread.bindApplication(...);
  6.  
  7.     if (normalMode) {
  8.         //【见流程2.16】
  9.         if (mStackSupervisor.attachApplicationLocked(app)) {
  10.             didSomething = true;
  11.         }
  12.     }
  13.     ...
  14. }

在执行完bindApplication()之后进入ASS.attachApplicationLocked()

2.16 ASS.attachApplicationLocked

  1. boolean attachApplicationLocked(ProcessRecord app) throws RemoteException {
  2.     final String processName = app.processName;
  3.     boolean didSomething = false;
  4.     for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
  5.         ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
  6.         for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
  7.             final ActivityStack stack = stacks.get(stackNdx);
  8.             if (!isFrontStack(stack)) {
  9.                 continue;
  10.             }
  11.             //获取前台stack中栈顶第一个非finishing的Activity
  12.             ActivityRecord hr = stack.topRunningActivityLocked(null);
  13.             if (hr != null) {
  14.                 if (hr.app == null && app.uid == hr.info.applicationInfo.uid
  15.                         && processName.equals(hr.processName)) {
  16.                     try {
  17.                         //真正的启动Activity【见流程2.17】
  18.                         if (realStartActivityLocked(hr, app, true, true)) {
  19.                             didSomething = true;
  20.                         }
  21.                     } catch (RemoteException e) {
  22.                         throw e;
  23.                     }
  24.                 }
  25.             }
  26.         }
  27.     }
  28.     if (!didSomething) {
  29.         //启动Activity不成功，则确保有可见的Activity
  30.         ensureActivitiesVisibleLocked(null, 0);
  31.     }
  32.     return didSomething;
  33. }

2.17 ASS.realStartActivityLocked

  1. final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app, boolean andResume, boolean checkConfig) throws RemoteException {
  2.  
  3.     if (andResume) {
  4.         r.startFreezingScreenLocked(app, 0);
  5.         mWindowManager.setAppVisibility(r.appToken, true);
  6.         //调度启动ticks用以收集应用启动慢的信息
  7.         r.startLaunchTickingLocked();
  8.     }
  9.  
  10.     if (checkConfig) {
  11.         Configuration config = mWindowManager.updateOrientationFromAppTokens(
  12.                 mService.mConfiguration,
  13.                 r.mayFreezeScreenLocked(app) ? r.appToken : null);
  14.         //更新Configuration
  15.         mService.updateConfigurationLocked(config, r, false, false);
  16.     }
  17.  
  18.     r.app = app;
  19.     app.waitingToKill = null;
  20.     r.launchCount++;
  21.     r.lastLaunchTime = SystemClock.uptimeMillis();
  22.  
  23.     int idx = app.activities.indexOf(r);
  24.     if (idx < 0) {
  25.         app.activities.add(r);
  26.     }
  27.     mService.updateLruProcessLocked(app, true, null);
  28.     mService.updateOomAdjLocked();
  29.  
  30.     final TaskRecord task = r.task;
  31.     if (task.mLockTaskAuth == LOCK_TASK_AUTH_LAUNCHABLE ||
  32.             task.mLockTaskAuth == LOCK_TASK_AUTH_LAUNCHABLE_PRIV) {
  33.         setLockTaskModeLocked(task, LOCK_TASK_MODE_LOCKED, "mLockTaskAuth==LAUNCHABLE", false);
  34.     }
  35.  
  36.     final ActivityStack stack = task.stack;
  37.     try {
  38.         if (app.thread == null) {
  39.             throw new RemoteException();
  40.         }
  41.         List<ResultInfo> results = null;
  42.         List<ReferrerIntent> newIntents = null;
  43.         if (andResume) {
  44.             results = r.results;
  45.             newIntents = r.newIntents;
  46.         }
  47.         if (r.isHomeActivity() && r.isNotResolverActivity()) {
  48.             //home进程是该栈的根进程
  49.             mService.mHomeProcess = task.mActivities.get(0).app;
  50.         }
  51.         mService.ensurePackageDexOpt(r.intent.getComponent().getPackageName());
  52.         ...
  53.  
  54.         if (andResume) {
  55.             app.hasShownUi = true;
  56.             app.pendingUiClean = true;
  57.         }
  58.         //将该进程设置为前台进程PROCESS_STATE_TOP
  59.         app.forceProcessStateUpTo(mService.mTopProcessState);
  60.         //【见流程2.18】
  61.         app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,
  62.                 System.identityHashCode(r), r.info, new Configuration(mService.mConfiguration),
  63.                 new Configuration(stack.mOverrideConfig), r.compat, r.launchedFromPackage,
  64.                 task.voiceInteractor, app.repProcState, r.icicle, r.persistentState, results,
  65.                 newIntents, !andResume, mService.isNextTransitionForward(), profilerInfo);
  66.  
  67.         if ((app.info.privateFlags&ApplicationInfo.PRIVATE_FLAG_CANT_SAVE_STATE) != 0) {
  68.             ... //处理heavy-weight进程
  69.         }
  70.  
  71.     } catch (RemoteException e) {
  72.         if (r.launchFailed) {
  73.             //第二次启动失败，则结束该activity
  74.             mService.appDiedLocked(app);
  75.             stack.requestFinishActivityLocked(r.appToken, Activity.RESULT_CANCELED, null,
  76.                     "2nd-crash", false);
  77.             return false;
  78.         }
  79.         //这是第一个启动失败，则重启进程
  80.         app.activities.remove(r);
  81.         throw e;
  82.     }
  83.  
  84.     //将该进程加入到mLRUActivities队列顶部
  85.     stack.updateLRUListLocked(r)；
  86.  
  87.     if (andResume) {
  88.         //启动过程的一部分
  89.         stack.minimalResumeActivityLocked(r);
  90.     } else {
  91.         r.state = STOPPED;
  92.         r.stopped = true;
  93.     }
  94.  
  95.     if (isFrontStack(stack)) {
  96.         //当系统发生更新时，只会执行一次的用户向导
  97.         mService.startSetupActivityLocked();
  98.     }
  99.     //更新所有与该Activity具有绑定关系的Service连接
  100.     mService.mServices.updateServiceConnectionActivitiesLocked(r.app);
  101.  
  102.     return true;
  103. }

2.18 ATP.scheduleLaunchActivity

[-> ApplicationThreadProxy.java]

  1. public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident, ActivityInfo info, Configuration curConfig, Configuration overrideConfig, CompatibilityInfo compatInfo, String referrer, IVoiceInteractor voiceInteractor, int procState, Bundle state, PersistableBundle persistentState, List<ResultInfo> pendingResults, List<ReferrerIntent> pendingNewIntents, boolean notResumed, boolean isForward, ProfilerInfo profilerInfo) throws RemoteException {
  2.      Parcel data = Parcel.obtain();
  3.      data.writeInterfaceToken(IApplicationThread.descriptor);
  4.      intent.writeToParcel(data, 0);
  5.      data.writeStrongBinder(token);
  6.      data.writeInt(ident);
  7.      info.writeToParcel(data, 0);
  8.      curConfig.writeToParcel(data, 0);
  9.      if (overrideConfig != null) {
  10.          data.writeInt(1);
  11.          overrideConfig.writeToParcel(data, 0);
  12.      } else {
  13.          data.writeInt(0);
  14.      }
  15.      compatInfo.writeToParcel(data, 0);
  16.      data.writeString(referrer);
  17.      data.writeStrongBinder(voiceInteractor != null ? voiceInteractor.asBinder() : null);
  18.      data.writeInt(procState);
  19.      data.writeBundle(state);
  20.      data.writePersistableBundle(persistentState);
  21.      data.writeTypedList(pendingResults);
  22.      data.writeTypedList(pendingNewIntents);
  23.      data.writeInt(notResumed ? 1 : 0);
  24.      data.writeInt(isForward ? 1 : 0);
  25.      if (profilerInfo != null) {
  26.          data.writeInt(1);
  27.          profilerInfo.writeToParcel(data, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
  28.      } else {
  29.          data.writeInt(0);
  30.      }
  31.      //【见流程2.19】
  32.      mRemote.transact(SCHEDULE_LAUNCH_ACTIVITY_TRANSACTION, data, null,
  33.              IBinder.FLAG_ONEWAY);
  34.      data.recycle();
  35.  }

2.19 ATN.onTransact

[-> ApplicationThreadNative.java]

  1. public boolean onTransact(int code, Parcel data, Parcel reply, int flags) throws RemoteException {
  2.     switch (code) {
  3.     case SCHEDULE_LAUNCH_ACTIVITY_TRANSACTION:
  4.     {
  5.         data.enforceInterface(IApplicationThread.descriptor);
  6.         Intent intent = Intent.CREATOR.createFromParcel(data);
  7.         IBinder b = data.readStrongBinder();
  8.         int ident = data.readInt();
  9.         ActivityInfo info = ActivityInfo.CREATOR.createFromParcel(data);
  10.         Configuration curConfig = Configuration.CREATOR.createFromParcel(data);
  11.         Configuration overrideConfig = null;
  12.         if (data.readInt() != 0) {
  13.             overrideConfig = Configuration.CREATOR.createFromParcel(data);
  14.         }
  15.         CompatibilityInfo compatInfo = CompatibilityInfo.CREATOR.createFromParcel(data);
  16.         String referrer = data.readString();
  17.         IVoiceInteractor voiceInteractor = IVoiceInteractor.Stub.asInterface(
  18.                 data.readStrongBinder());
  19.         int procState = data.readInt();
  20.         Bundle state = data.readBundle();
  21.         PersistableBundle persistentState = data.readPersistableBundle();
  22.         List<ResultInfo> ri = data.createTypedArrayList(ResultInfo.CREATOR);
  23.         List<ReferrerIntent> pi = data.createTypedArrayList(ReferrerIntent.CREATOR);
  24.         boolean notResumed = data.readInt() != 0;
  25.         boolean isForward = data.readInt() != 0;
  26.         ProfilerInfo profilerInfo = data.readInt() != 0
  27.                 ? ProfilerInfo.CREATOR.createFromParcel(data) : null;
  28.         //【见流程2.20】
  29.         scheduleLaunchActivity(intent, b, ident, info, curConfig, overrideConfig, compatInfo,
  30.                 referrer, voiceInteractor, procState, state, persistentState, ri, pi,
  31.                 notResumed, isForward, profilerInfo);
  32.         return true;
  33.     }
  34.     ...
  35.     }
  36. }

2.20 AT.scheduleLaunchActivity

[-> ApplicationThread.java]

  1. public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident, ActivityInfo info, Configuration curConfig, Configuration overrideConfig, CompatibilityInfo compatInfo, String referrer, IVoiceInteractor voiceInteractor, int procState, Bundle state, PersistableBundle persistentState, List<ResultInfo> pendingResults, List<ReferrerIntent> pendingNewIntents, boolean notResumed, boolean isForward, ProfilerInfo profilerInfo) {
  2.  
  3.      updateProcessState(procState, false);
  4.  
  5.      ActivityClientRecord r = new ActivityClientRecord();
  6.  
  7.      r.token = token;
  8.      r.ident = ident;
  9.      r.intent = intent;
  10.      r.referrer = referrer;
  11.      r.voiceInteractor = voiceInteractor;
  12.      r.activityInfo = info;
  13.      r.compatInfo = compatInfo;
  14.      r.state = state;
  15.      r.persistentState = persistentState;
  16.  
  17.      r.pendingResults = pendingResults;
  18.      r.pendingIntents = pendingNewIntents;
  19.  
  20.      r.startsNotResumed = notResumed;
  21.      r.isForward = isForward;
  22.  
  23.      r.profilerInfo = profilerInfo;
  24.  
  25.      r.overrideConfig = overrideConfig;
  26.      updatePendingConfiguration(curConfig);
  27.      //【见流程2.21】
  28.      sendMessage(H.LAUNCH_ACTIVITY, r);
  29.  }

2.21 H.handleMessage

[-> ActivityThread.java ::H]

  1. public void handleMessage(Message msg) {
  2.     switch (msg.what) {
  3.         case LAUNCH_ACTIVITY: {
  4.             final ActivityClientRecord r = (ActivityClientRecord) msg.obj;
  5.             r.packageInfo = getPackageInfoNoCheck(
  6.                     r.activityInfo.applicationInfo, r.compatInfo);
  7.             //【见流程2.22】
  8.             handleLaunchActivity(r, null);
  9.         } break;
  10.         ...
  11.     }
  12. }

2.22 ActivityThread.handleLaunchActivity

[-> ActivityThread.java]

  1. private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent) {
  2.     unscheduleGcIdler();
  3.     mSomeActivitiesChanged = true;
  4.  
  5.     //最终回调目标Activity的onConfigurationChanged()
  6.     handleConfigurationChanged(null, null);
  7.     //初始化wms
  8.     WindowManagerGlobal.initialize();
  9.     //最终回调目标Activity的onCreate[见流程2.23]
  10.     Activity a = performLaunchActivity(r, customIntent);
  11.     if (a != null) {
  12.         r.createdConfig = new Configuration(mConfiguration);
  13.         Bundle oldState = r.state;
  14.         //最终回调目标Activity的onStart,onResume.
  15.         handleResumeActivity(r.token, false, r.isForward,
  16.                 !r.activity.mFinished && !r.startsNotResumed);
  17.  
  18.         if (!r.activity.mFinished && r.startsNotResumed) {
  19.             r.activity.mCalled = false;
  20.             mInstrumentation.callActivityOnPause(r.activity);
  21.             r.paused = true;
  22.         }
  23.     } else {
  24.         //存在error则停止该Activity
  25.         ActivityManagerNative.getDefault()
  26.             .finishActivity(r.token, Activity.RESULT_CANCELED, null, false);
  27.     }
  28. }

2.23 ActivityThread.performLaunchActivity

[-> ActivityThread.java]

  1. ​
  2. private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
  3.  
  4.     ActivityInfo aInfo = r.activityInfo;
  5.     if (r.packageInfo == null) {
  6.         r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo,
  7.                 Context.CONTEXT_INCLUDE_CODE);
  8.     }
  9.  
  10.     ComponentName component = r.intent.getComponent();
  11.     if (component == null) {
  12.         component = r.intent.resolveActivity(
  13.             mInitialApplication.getPackageManager());
  14.         r.intent.setComponent(component);
  15.     }
  16.  
  17.     if (r.activityInfo.targetActivity != null) {
  18.         component = new ComponentName(r.activityInfo.packageName,
  19.                 r.activityInfo.targetActivity);
  20.     }
  21.  
  22.     Activity activity = null;
  23.     try {
  24.         java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
  25.         activity = mInstrumentation.newActivity(
  26.                 cl, component.getClassName(), r.intent);
  27.         StrictMode.incrementExpectedActivityCount(activity.getClass());
  28.         r.intent.setExtrasClassLoader(cl);
  29.         r.intent.prepareToEnterProcess();
  30.         if (r.state != null) {
  31.             r.state.setClassLoader(cl);
  32.         }
  33.     } catch (Exception e) {
  34.         ...
  35.     }
  36.  
  37.     try {
  38.         //创建Application对象
  39.         Application app = r.packageInfo.makeApplication(false, mInstrumentation);
  40.  
  41.         if (activity != null) {
  42.             Context appContext = createBaseContextForActivity(r, activity);
  43.             CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
  44.             Configuration config = new Configuration(mCompatConfiguration);
  45.  
  46.             activity.attach(appContext, this, getInstrumentation(), r.token,
  47.                     r.ident, app, r.intent, r.activityInfo, title, r.parent,
  48.                     r.embeddedID, r.lastNonConfigurationInstances, config,
  49.                     r.referrer, r.voiceInteractor);
  50.  
  51.             if (customIntent != null) {
  52.                 activity.mIntent = customIntent;
  53.             }
  54.             r.lastNonConfigurationInstances = null;
  55.             activity.mStartedActivity = false;
  56.             int theme = r.activityInfo.getThemeResource();
  57.             if (theme != 0) {
  58.                 activity.setTheme(theme);
  59.             }
  60.  
  61.             activity.mCalled = false;
  62.             if (r.isPersistable()) {
  63.                 mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
  64.             } else {
  65.                 mInstrumentation.callActivityOnCreate(activity, r.state);
  66.             }
  67.             ...
  68.             r.activity = activity;
  69.             r.stopped = true;
  70.             if (!r.activity.mFinished) {
  71.                 activity.performStart();
  72.                 r.stopped = false;
  73.             }
  74.             if (!r.activity.mFinished) {
  75.                 if (r.isPersistable()) {
  76.                     if (r.state != null || r.persistentState != null) {
  77.                         mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state,
  78.                                 r.persistentState);
  79.                     }
  80.                 } else if (r.state != null) {
  81.                     mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);
  82.                 }
  83.             }
  84.             if (!r.activity.mFinished) {
  85.                 activity.mCalled = false;
  86.                 if (r.isPersistable()) {
  87.                     //调用Activity.onCreat方法
  88.                     mInstrumentation.callActivityOnPostCreate(activity, r.state,
  89.                             r.persistentState);
  90.                 } else {
  91.                     mInstrumentation.callActivityOnPostCreate(activity, r.state);
  92.                 }
  93.                 ...
  94.             }
  95.         }
  96.         r.paused = true;
  97.  
  98.         mActivities.put(r.token, r);
  99.  
  100.     }  catch (Exception e) {
  101.         ...
  102.     }
  103.  
  104.     return activity;
  105. }
  106.  
  107. ​

到此，正式进入了Activity的onCreate, onStart, onResume这些生命周期的过程。

三. 总结

本文详细startActivity的整个启动流程，

  • 流程[2.1 ~2.4]:运行在调用者所在进程，比如从桌面启动Activity，则调用者所在进程为launcher进程，launcher进程利用ActivityManagerProxy作为Binder Client，进入system_server进程(AMS相应的Server端)。
  • 流程[2.5 ~2.18]:运行在system_server系统进程，整个过程最为复杂、核心的过程，下面其中部分步骤：
    • 流程[2.7]：会调用到resolveActivity()，借助PackageManager来查询系统中所有符合要求的Activity，当存在多个满足条件的Activity则会弹框让用户来选择;
    • 流程[2.8]：创建ActivityRecord对象，并检查是否运行App切换，然后再处理mPendingActivityLaunches中的activity;
    • 流程[2.9]：为Activity找到或创建新的Task对象，设置flags信息；
    • 流程[2.13]：当没有处于非finishing状态的Activity，则直接回到桌面； 否则，当mResumedActivity不为空则执行startPausingLocked()暂停该activity;然后再进入startSpecificActivityLocked()环节;
    • 流程[2.14]：当目标进程已存在则直接进入流程[2.17]，当进程不存在则创建进程，经过层层调用还是会进入流程[2.17];
    • 流程[2.17]：system_server进程利用的ATP(Binder Client)，经过Binder，程序接下来进入目标进程。
  • 流程[2.19 ~2.18]:运行在目标进程，通过Handler消息机制，该进程中的Binder线程向主线程发送H.LAUNCH_ACTIVITY，最终会通过反射创建目标Activity，然后进入onCreate()生命周期。

从另一个角度下图来概括：

                 

启动流程：

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

到此，App便正式启动，开始进入Activity生命周期，执行完onCreate/onStart/onResume方法，UI渲染结束后便可以看到App的主界面。 启动Activity较为复杂，后续计划再进一步讲解生命周期过程与系统是如何交互，以及UI渲染过程，敬请期待。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/2023面试高手/article/detail/680182
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号