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

Android App 启动流程梳理（基于 Android 10）_android app启动流程

作者：Monodyee | 2024-02-21 20:28:59

赞

踩

android app启动流程

1. 概述

当我们点击桌面的应用图标，直到应用的启动页出来，这期间的在源代码的流程中到底是什么样子的？之前追过 Android App 启动的相关源码，由于没有做相关记录，时间一久，已经忘得差不多了。现在有时间，也下载了 Android 10  的源码，就重新追一遍并且画一画相关的流程图。

2. 从点击桌面图标开始

Android 的桌面本身也是一个 APP，为 Launcher。由于 Android 是开源的，很多手机厂商都做了相关的修改，甚至重新做一个新的启动页。之前做公司做电视系统的定制化，就没有用系统的这个 Launcher。

当我们点击桌面的应用图标开始，就是 Launcher 中的一次点击事件：

Launcher.java (\packages\apps\launcher3\src\com\android\launcher3)

  1.     /**
  2.      * Creates a view representing a shortcut.
  3.      *
  4.      * @param info The data structure describing the shortcut.
  5.      */
  6.     View createShortcut(WorkspaceItemInfo info) {
  7.         return createShortcut((ViewGroup) mWorkspace.getChildAt(mWorkspace.getCurrentPage()), info);
  8.     }
  9.  
  10.     /**
  11.      * Creates a view representing a shortcut inflated from the specified resource.
  12.      *
  13.      * @param parent The group the shortcut belongs to.
  14.      * @param info The data structure describing the shortcut.
  15.      *
  16.      * @return A View inflated from layoutResId.
  17.      */
  18.     public View createShortcut(ViewGroup parent, WorkspaceItemInfo info) {
  19.         BubbleTextView favorite = (BubbleTextView) LayoutInflater.from(parent.getContext())
  20.                 .inflate(R.layout.app_icon, parent, false);
  21.         favorite.applyFromWorkspaceItem(info);
  22.         favorite.setOnClickListener(ItemClickHandler.INSTANCE);
  23.         favorite.setOnFocusChangeListener(mFocusHandler);
  24.         return favorite;
  25.     }

真正的点击事件位于 ItemClickHandler.java 中：

ItemClickHandler.java (\packages\apps\launcher3\src\com\android\launcher3\touch)

  1.     private static void onClick(View v, String sourceContainer) {
  2.         // Make sure that rogue clicks don't get through while allapps is launching, or after the
  3.         // view has detached (it's possible for this to happen if the view is removed mid touch).
  4.         if (v.getWindowToken() == null) return;
  5.  
  6.         Launcher launcher = Launcher.getLauncher(v.getContext());
  7.         if (!launcher.getWorkspace().isFinishedSwitchingState()) return;
  8.  
  9.         Object tag = v.getTag();
  10.         if (tag instanceof WorkspaceItemInfo) {
  11.             onClickAppShortcut(v, (WorkspaceItemInfo) tag, launcher, sourceContainer);
  12.         } else if (tag instanceof FolderInfo) {
  13.             if (v instanceof FolderIcon) {
  14.                 onClickFolderIcon(v);
  15.             }
  16.         } else if (tag instanceof AppInfo) {
  17.             startAppShortcutOrInfoActivity(v, (AppInfo) tag, launcher,
  18.                     sourceContainer == null ? CONTAINER_ALL_APPS: sourceContainer);
  19.         } else if (tag instanceof LauncherAppWidgetInfo) {
  20.             if (v instanceof PendingAppWidgetHostView) {
  21.                 onClickPendingWidget((PendingAppWidgetHostView) v, launcher);
  22.             }
  23.         }

调用的是 startAppShortcutOrInfoActivity 方法：

  1.     private static void startAppShortcutOrInfoActivity(View v, ItemInfo item, Launcher launcher,
  2.             @Nullable String sourceContainer) {
  3.  
  4.         ...
  5.         ...
  6.  
  7.         launcher.startActivitySafely(v, intent, item, sourceContainer);
  8.     }

主要代码是 startActivitySafely 方法：

  1.     public boolean startActivitySafely(View v, Intent intent, ItemInfo item,
  2.             @Nullable String sourceContainer) {
  3.  
  4.         ...
  5.  
  6.         boolean success = super.startActivitySafely(v, intent, item, sourceContainer);
  7.         
  8.         ...
  9.         ...
  10.  
  11.         return success;
  12.     }

这里调用的是父类的 startActivitySafely 方法：

Launcher 的父类为 BaseDraggingActivity，其中 startActivitySafely 方法如下：

  1.     public boolean startActivitySafely(View v, Intent intent, @Nullable ItemInfo item,
  2.             @Nullable String sourceContainer) {
  3.         
  4.         ...
  5.  
  6.         // Prepare intent
  7.         intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);    //1
  8.         if (v != null) {
  9.             intent.setSourceBounds(getViewBounds(v));
  10.         }
  11.         try {
  12.             boolean isShortcut = (item instanceof WorkspaceItemInfo)
  13.                     && (item.itemType == Favorites.ITEM_TYPE_SHORTCUT
  14.                     || item.itemType == Favorites.ITEM_TYPE_DEEP_SHORTCUT)
  15.                     && !((WorkspaceItemInfo) item).isPromise();
  16.             if (isShortcut) {
  17.                 // Shortcuts need some special checks due to legacy reasons.
  18.                 startShortcutIntentSafely(intent, optsBundle, item, sourceContainer);
  19.             } else if (user == null || user.equals(Process.myUserHandle())) {
  20.                 // Could be launching some bookkeeping activity
  21.                 startActivity(intent, optsBundle);    //2
  22.             ...
  23.             ...
  24.  
  25.         return false;
  26.     }

注释1 中：要在一个新的 Task 中启动 Activity；

注释2 中：调用的是 Activity 的 startActivity 方法。

Launcher 的相关类继承关系如下：

3. Activity

Activity.java (framework\base\core\java\android\app) 

在第 2 步中，从 Launcher 中的代码追溯到了 Activity ，调用了熟悉的 startActivity 方法：

  1.     @Override
  2.     public void startActivity(Intent intent) {
  3.         this.startActivity(intent, null);
  4.     }

 接着调用了两个参数的 startActivity 方法，这里第二个参数为 null：

  1.     @Override
  2.     public void startActivity(Intent intent, @Nullable Bundle options) {
  3.         if (options != null) {
  4.             startActivityForResult(intent, -1, options);
  5.         } else {
  6.             // Note we want to go through this call for compatibility with
  7.             // applications that may have overridden the method.
  8.             startActivityForResult(intent, -1);
  9.         }
  10.     }

由于第2个参数为 null，所以 startActivityForResult(intent, -1, options)，因为 Launcher 启动应用并不需要应用给予回复，所以 这里 requestCode 为 -1。startActivityForResult 的代码如下：

  1.     public void startActivityForResult(
  2.             String who, Intent intent, int requestCode, @Nullable Bundle options) {
  3.         Uri referrer = onProvideReferrer();
  4.         if (referrer != null) {
  5.             intent.putExtra(Intent.EXTRA_REFERRER, referrer);
  6.         }
  7.         options = transferSpringboardActivityOptions(options);
  8.         Instrumentation.ActivityResult ar =
  9.             mInstrumentation.execStartActivity(
  10.                 this, mMainThread.getApplicationThread(), mToken, who,
  11.                 intent, requestCode, options);
  12.         if (ar != null) {
  13.             mMainThread.sendActivityResult(
  14.                 mToken, who, requestCode,
  15.                 ar.getResultCode(), ar.getResultData());
  16.         }
  17.         cancelInputsAndStartExitTransition(options);
  18.     }

这里的核心代码是调用了 Instrumentation 的 execStartActivity 方法。

4. Instrumentation

Instrumentation.java (framework\base\core\java\android\app)

Instrumentation 是 Android 系统中启动 Activity 的一个实际操作类，它用来监控应用程序和系统的交互。execStartActivity  方法如下：

  1.     public ActivityResult execStartActivity(
  2.             Context who, IBinder contextThread, IBinder token, Activity target,
  3.             Intent intent, int requestCode, Bundle options) {
  4.         ...
  5.         ...
  6.  
  7.         try {
  8.             intent.migrateExtraStreamToClipData();
  9.             intent.prepareToLeaveProcess(who);
  10.             int result = ActivityTaskManager.getService()    //3
  11.                 .startActivity(whoThread, who.getBasePackageName(), intent,
  12.                         intent.resolveTypeIfNeeded(who.getContentResolver()),
  13.                         token, target != null ? target.mEmbeddedID : null,
  14.                         requestCode, 0, null, options);
  15.             checkStartActivityResult(result, intent);
  16.         } catch (RemoteException e) {
  17.             throw new RuntimeException("Failure from system", e);
  18.         }
  19.         return null;
  20.     }

这个方法的核心代码是注释3：ActivityTaskManager.getService().startActivity

5. ActivityTaskManager

ActivityTaskManager.java (framework\base\core\java\android\app) 

ActivityTaskManager 的 getService 方法：

  1. public class ActivityTaskManager {
  2.     
  3.     ...
  4.     ...
  5.  
  6.    public static IActivityTaskManager getService() {
  7.         return IActivityTaskManagerSingleton.get();
  8.     }
  9.  
  10.     @UnsupportedAppUsage(trackingBug = 129726065)
  11.     private static final Singleton<IActivityTaskManager> IActivityTaskManagerSingleton =
  12.             new Singleton<IActivityTaskManager>() {
  13.                 @Override
  14.                 protected IActivityTaskManager create() {
  15.                     final IBinder b = ServiceManager.getService(Context.ACTIVITY_TASK_SERVICE);
  16.                     return IActivityTaskManager.Stub.asInterface(b);
  17.                 }
  18.             };
  19.  
  20.     ...
  21. }

从这里代码可以看出这是一个 AIDL 的调用，此处是 AIDL 的 client 端，那 Server 端在哪里呢？这里的 Server 端是 ActivityTaskManagerService。Instrumentation 中 execStartActivity  方法实际调用的是 ActivityTaskManagerService 中的 startActivity 方法。

6. ActivityTaskManagerService

ActivityTaskManagerService.java (framework\base\services\core\java\com\android\server\wm)

  1. public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
  2.  
  3.     ...
  4.  
  5.     @Override
  6.     public final int startActivity(IApplicationThread caller, String callingPackage,
  7.             Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
  8.             int startFlags, ProfilerInfo profilerInfo, Bundle bOptions) {
  9.         return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
  10.                 resultWho, requestCode, startFlags, profilerInfo, bOptions,
  11.                 UserHandle.getCallingUserId());
  12.     }
  13.  
  14.     @Override
  15.     public int startActivityAsUser(IApplicationThread caller, String callingPackage,
  16.             Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
  17.             int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId) {
  18.         return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
  19.                 resultWho, requestCode, startFlags, profilerInfo, bOptions, userId,
  20.                 true /*validateIncomingUser*/);
  21.     }
  22.  
  23.     int startActivityAsUser(IApplicationThread caller, String callingPackage,
  24.             Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
  25.             int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId,
  26.             boolean validateIncomingUser) {
  27.         enforceNotIsolatedCaller("startActivityAsUser");
  28.  
  29.         userId = getActivityStartController().checkTargetUser(userId, validateIncomingUser,
  30.                 Binder.getCallingPid(), Binder.getCallingUid(), "startActivityAsUser");
  31.  
  32.         // TODO: Switch to user app stacks here.
  33.         return getActivityStartController().obtainStarter(intent, "startActivityAsUser")
  34.                 .setCaller(caller)
  35.                 .setCallingPackage(callingPackage)
  36.                 .setResolvedType(resolvedType)
  37.                 .setResultTo(resultTo)
  38.                 .setResultWho(resultWho)
  39.                 .setRequestCode(requestCode)
  40.                 .setStartFlags(startFlags)
  41.                 .setProfilerInfo(profilerInfo)
  42.                 .setActivityOptions(bOptions)
  43.                 .setMayWait(userId)
  44.                 .execute();
  45.  
  46.     }
  47.  
  48.     ...
  49. }

这边的核心代码是 startActivityAsUser 中的 return。

首先通过 getActivityStartController 方法获取 ActivityStartController 的实例，接着调用 ActivityStartController  的 obtainStarter 方法。

7. ActivityStartController 

ActivityStartController.java (framework\base\services\core\java\com\android\server\wm) 

obtainStarter 方法如下：

  1.     ActivityStarter obtainStarter(Intent intent, String reason) {
  2.         return mFactory.obtain().setIntent(intent).setReason(reason);
  3.     }

这里返回的是 ActivityStarter  对象。看到了 “Factory”，自然而然的想到了工厂模式，这里梳理下该工厂模式的具体调用流程：

mFactory 是在 ActivityStartController 的构造方法中以参数的方式传递进来的：

  1.     @VisibleForTesting
  2.     ActivityStartController(ActivityTaskManagerService service, ActivityStackSupervisor supervisor,
  3.             Factory factory) {
  4.         mService = service;
  5.         mSupervisor = supervisor;
  6.         mHandler = new StartHandler(mService.mH.getLooper());
  7.         mFactory = factory;
  8.         mFactory.setController(this);
  9.         mPendingRemoteAnimationRegistry = new PendingRemoteAnimationRegistry(service,
  10.                 service.mH);
  11.     }

在 ActivityTaskManagerService 对于 ActivityStartController 的初始化：

  1.     public void initialize(IntentFirewall intentFirewall, PendingIntentController intentController,
  2.             Looper looper) {
  3.         mH = new H(looper);
  4.         mUiHandler = new UiHandler();
  5.  
  6.         ...
  7.         
  8.         mActivityStartController = new ActivityStartController(this);
  9.         
  10.         ...
  11.     }

这是一个参数的构造方法：

  1.     ActivityStartController(ActivityTaskManagerService service) {
  2.         this(service, service.mStackSupervisor,
  3.                 new DefaultFactory(service, service.mStackSupervisor,
  4.                     new ActivityStartInterceptor(service, service.mStackSupervisor)));
  5.     }

所以刚才的 mFactory 就是这里的 DefaultFactory，从导包可以看出这里的 DefaultFactory 是 ActivityStarter 中的类：

  1. import com.android.server.wm.ActivityStarter.DefaultFactory;
  2. import com.android.server.wm.ActivityStarter.Factory;

接着把关注对象转为 ActivityStarter。

8. ActivityStarter

ActivityStarter.java (framework\base\services\core\java\com\android\server\wm) 

DefaultFactory 是 ActivityStarter 中的一个静态内部类，并且实现了接口 Factory

  1.     static class DefaultFactory implements Factory {
  2.         /**
  3.          * The maximum count of starters that should be active at one time:
  4.          * 1. last ran starter (for logging and post activity processing)
  5.          * 2. current running starter
  6.          * 3. starter from re-entry in (2)
  7.          */
  8.         private final int MAX_STARTER_COUNT = 3;
  9.  
  10.         private ActivityStartController mController;
  11.         private ActivityTaskManagerService mService;
  12.         private ActivityStackSupervisor mSupervisor;
  13.         private ActivityStartInterceptor mInterceptor;
  14.  
  15.         private SynchronizedPool<ActivityStarter> mStarterPool =
  16.                 new SynchronizedPool<>(MAX_STARTER_COUNT);
  17.  
  18.         DefaultFactory(ActivityTaskManagerService service,
  19.                 ActivityStackSupervisor supervisor, ActivityStartInterceptor interceptor) {
  20.             mService = service;
  21.             mSupervisor = supervisor;
  22.             mInterceptor = interceptor;
  23.         }
  24.  
  25.         @Override
  26.         public void setController(ActivityStartController controller) {
  27.             mController = controller;
  28.         }
  29.  
  30.         @Override
  31.         public ActivityStarter obtain() {
  32.             ActivityStarter starter = mStarterPool.acquire();
  33.  
  34.             if (starter == null) {
  35.                 starter = new ActivityStarter(mController, mService, mSupervisor, mInterceptor);
  36.             }
  37.  
  38.             return starter;
  39.         }
  40.  
  41.         @Override
  42.         public void recycle(ActivityStarter starter) {
  43.             starter.reset(true /* clearRequest*/);
  44.             mStarterPool.release(starter);
  45.         }
  46.     }
  47.  
  48.  
  49.     interface Factory {
  50.         /**
  51.          * Sets the {@link ActivityStartController} to be passed to {@link ActivityStarter}.
  52.          */
  53.         void setController(ActivityStartController controller);
  54.  
  55.         /**
  56.          * Generates an {@link ActivityStarter} that is ready to handle a new start request.
  57.          * @param controller The {@link ActivityStartController} which the starter who will own
  58.          *                   this instance.
  59.          * @return an {@link ActivityStarter}
  60.          */
  61.         ActivityStarter obtain();
  62.  
  63.         /**
  64.          * Recycles a starter for reuse.
  65.          */
  66.         void recycle(ActivityStarter starter);
  67.     }

工厂模式的好处就是外界不用管如何创造 ActivityStarter 对象，只要告诉 Factory 要获取 ActivityStarter 对象就能得到想要的 ActivityStarter 对象。关于工厂模式的相关介绍可以看另外的三篇文章：

Java设计模式：简单工厂模式
Java设计模式：工厂方法模式
Java设计模式：抽象工厂模式

切回流程主线，在 6 中 通过 obtainStarter 方法获取到了 ActivityStarter 对象：

  1.         return getActivityStartController().obtainStarter(intent, "startActivityAsUser")
  2.                 .setCaller(caller)
  3.                 .setCallingPackage(callingPackage)
  4.                 .setResolvedType(resolvedType)
  5.                 .setResultTo(resultTo)
  6.                 .setResultWho(resultWho)
  7.                 .setRequestCode(requestCode)
  8.                 .setStartFlags(startFlags)
  9.                 .setProfilerInfo(profilerInfo)
  10.                 .setActivityOptions(bOptions)
  11.                 .setMayWait(userId)
  12.                 .execute();
  1.         public ActivityStarter obtain() {
  2.             ActivityStarter starter = mStarterPool.acquire();
  3.  
  4.             if (starter == null) {
  5.                 starter = new ActivityStarter(mController, mService, mSupervisor, mInterceptor);
  6.             }
  7.  
  8.             return starter;
  9.         }

在 obtain 方法中创建了 ActivityStarter 对象，随后通过多个 set 方法设置相关参数，最后调用 execute 方法：

  1.     /**
  2.      * Starts an activity based on the request parameters provided earlier.
  3.      * @return The starter result.
  4.      */
  5.     int execute() {
  6.         try {
  7.             // TODO(b/64750076): Look into passing request directly to these methods to allow
  8.             // for transactional diffs and preprocessing.
  9.             if (mRequest.mayWait) {
  10.                 return startActivityMayWait(mRequest.caller, mRequest.callingUid,
  11.                         mRequest.callingPackage, mRequest.realCallingPid, mRequest.realCallingUid,
  12.                         mRequest.intent, mRequest.resolvedType,
  13.                         mRequest.voiceSession, mRequest.voiceInteractor, mRequest.resultTo,
  14.                         mRequest.resultWho, mRequest.requestCode, mRequest.startFlags,
  15.                         mRequest.profilerInfo, mRequest.waitResult, mRequest.globalConfig,
  16.                         mRequest.activityOptions, mRequest.ignoreTargetSecurity, mRequest.userId,
  17.                         mRequest.inTask, mRequest.reason,
  18.                         mRequest.allowPendingRemoteAnimationRegistryLookup,
  19.                         mRequest.originatingPendingIntent, mRequest.allowBackgroundActivityStart);
  20.             } else {
  21.                 return startActivity(mRequest.caller, mRequest.intent, mRequest.ephemeralIntent,
  22.                         mRequest.resolvedType, mRequest.activityInfo, mRequest.resolveInfo,
  23.                         mRequest.voiceSession, mRequest.voiceInteractor, mRequest.resultTo,
  24.                         mRequest.resultWho, mRequest.requestCode, mRequest.callingPid,
  25.                         mRequest.callingUid, mRequest.callingPackage, mRequest.realCallingPid,
  26.                         mRequest.realCallingUid, mRequest.startFlags, mRequest.activityOptions,
  27.                         mRequest.ignoreTargetSecurity, mRequest.componentSpecified,
  28.                         mRequest.outActivity, mRequest.inTask, mRequest.reason,
  29.                         mRequest.allowPendingRemoteAnimationRegistryLookup,
  30.                         mRequest.originatingPendingIntent, mRequest.allowBackgroundActivityStart);
  31.             }
  32.         } finally {
  33.             onExecutionComplete();
  34.         }
  35.     }

这里该走的是哪条呢？由于上面执行多个set 方法中有 setMayWait 方法中 mayWait 设置了 true，所以执行的 if 中的语句：

  1.     ActivityStarter setMayWait(int userId) {
  2.         mRequest.mayWait = true;
  3.         mRequest.userId = userId;
  4.  
  5.         return this;
  6.     }

接着看看 startActivityMayWait 方法：

  1.     private int startActivityMayWait(IApplicationThread caller, int callingUid,
  2.             String callingPackage, int requestRealCallingPid, int requestRealCallingUid,
  3.             Intent intent, String resolvedType, IVoiceInteractionSession voiceSession,
  4.             IVoiceInteractor voiceInteractor, IBinder resultTo, String resultWho, int requestCode,
  5.             int startFlags, ProfilerInfo profilerInfo, WaitResult outResult,
  6.             Configuration globalConfig, SafeActivityOptions options, boolean ignoreTargetSecurity,
  7.             int userId, TaskRecord inTask, String reason,
  8.             boolean allowPendingRemoteAnimationRegistryLookup,
  9.             PendingIntentRecord originatingPendingIntent, boolean allowBackgroundActivityStart) {
  10.  
  11.             ...
  12.             ...
  13.  
  14.             final ActivityRecord[] outRecord = new ActivityRecord[1];
  15.             int res = startActivity(caller, intent, ephemeralIntent, resolvedType, aInfo, rInfo,
  16.                     voiceSession, voiceInteractor, resultTo, resultWho, requestCode, callingPid,
  17.                     callingUid, callingPackage, realCallingPid, realCallingUid, startFlags, options,
  18.                     ignoreTargetSecurity, componentSpecified, outRecord, inTask, reason,
  19.                     allowPendingRemoteAnimationRegistryLookup, originatingPendingIntent,
  20.                     allowBackgroundActivityStart);
  21.  
  22.             Binder.restoreCallingIdentity(origId);
  23.             
  24.             ...
  25.             ...
  26.  
  27.             return res;
  28.         }
  29.     }

这里又调用了 startActivity 方法：

  1.     private int startActivity(IApplicationThread caller, Intent intent, Intent ephemeralIntent,
  2.             String resolvedType, ActivityInfo aInfo, ResolveInfo rInfo,
  3.             IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
  4.             IBinder resultTo, String resultWho, int requestCode, int callingPid, int callingUid,
  5.             String callingPackage, int realCallingPid, int realCallingUid, int startFlags,
  6.             SafeActivityOptions options, boolean ignoreTargetSecurity, boolean componentSpecified,
  7.             ActivityRecord[] outActivity, TaskRecord inTask, String reason,
  8.             boolean allowPendingRemoteAnimationRegistryLookup,
  9.             PendingIntentRecord originatingPendingIntent, boolean allowBackgroundActivityStart) {
  10.  
  11.         ...
  12.  
  13.         mLastStartActivityResult = startActivity(caller, intent, ephemeralIntent, resolvedType,
  14.                 aInfo, rInfo, voiceSession, voiceInteractor, resultTo, resultWho, requestCode,
  15.                 callingPid, callingUid, callingPackage, realCallingPid, realCallingUid, startFlags,
  16.                 options, ignoreTargetSecurity, componentSpecified, mLastStartActivityRecord,
  17.                 inTask, allowPendingRemoteAnimationRegistryLookup, originatingPendingIntent,
  18.                 allowBackgroundActivityStart);
  19.  
  20.         ...
  21.         ...
  22.  
  23.         return getExternalResult(mLastStartActivityResult);
  24.     }

再次调用不同参数的 startActivity 方法：

  1.     private int startActivity(IApplicationThread caller, Intent intent, Intent ephemeralIntent,
  2.             String resolvedType, ActivityInfo aInfo, ResolveInfo rInfo,
  3.             IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
  4.             IBinder resultTo, String resultWho, int requestCode, int callingPid, int callingUid,
  5.             String callingPackage, int realCallingPid, int realCallingUid, int startFlags,
  6.             SafeActivityOptions options,
  7.             boolean ignoreTargetSecurity, boolean componentSpecified, ActivityRecord[] outActivity,
  8.             TaskRecord inTask, boolean allowPendingRemoteAnimationRegistryLookup,
  9.             PendingIntentRecord originatingPendingIntent, boolean allowBackgroundActivityStart) {
  10.  
  11.     ...
  12.     
  13.     ...
  14.  
  15.         final int res = startActivity(r, sourceRecord, voiceSession, voiceInteractor, startFlags,
  16.                 true /* doResume */, checkedOptions, inTask, outActivity, restrictedBgActivity);
  17.         mSupervisor.getActivityMetricsLogger().notifyActivityLaunched(res, outActivity[0]);
  18.         return res;
  19. }

再次调用 startActivity 方法：

  1.     private int startActivity(final ActivityRecord r, ActivityRecord sourceRecord,
  2.                 IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
  3.                 int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
  4.                 ActivityRecord[] outActivity, boolean restrictedBgActivity) {
  5.         int result = START_CANCELED;
  6.         final ActivityStack startedActivityStack;
  7.         try {
  8.             mService.mWindowManager.deferSurfaceLayout();
  9.             result = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor,
  10.                     startFlags, doResume, options, inTask, outActivity, restrictedBgActivity);
  11.         } finally {
  12.  
  13.             ...
  14.             ...
  15.  
  16.         }
  17.  
  18.         postStartActivityProcessing(r, result, startedActivityStack);
  19.  
  20.         return result;
  21.     }

这里的核心调用了 startActivityUnchecked 方法：

  1.     // Note: This method should only be called from {@link startActivity}.
  2.     private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
  3.             IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
  4.             int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
  5.             ActivityRecord[] outActivity, boolean restrictedBgActivity) {
  6.  
  7.         ...
  8.  
  9.         mTargetStack.startActivityLocked(mStartActivity, topFocused, newTask, mKeepCurTransition,
  10.                 mOptions);
  11.  
  12.         if (mDoResume) {    // mDoResume 的值由上面参数传递过来，值为 true
  13.             final ActivityRecord topTaskActivity =
  14.                     mStartActivity.getTaskRecord().topRunningActivityLocked();
  15.             if (!mTargetStack.isFocusable()
  16.                     || (topTaskActivity != null && topTaskActivity.mTaskOverlay
  17.                     && mStartActivity != topTaskActivity)) {
  18.                 // If the activity is not focusable, we can't resume it, but still would like to
  19.                 // make sure it becomes visible as it starts (this will also trigger entry
  20.                 // animation). An example of this are PIP activities.
  21.                 // Also, we don't want to resume activities in a task that currently has an overlay
  22.                 // as the starting activity just needs to be in the visible paused state until the
  23.                 // over is removed.
  24.                 mTargetStack.ensureActivitiesVisibleLocked(mStartActivity, 0, !PRESERVE_WINDOWS);
  25.                 // Go ahead and tell window manager to execute app transition for this activity
  26.                 // since the app transition will not be triggered through the resume channel.
  27.                 mTargetStack.getDisplay().mDisplayContent.executeAppTransition();
  28.             } else {
  29.                 // If the target stack was not previously focusable (previous top running activity
  30.                 // on that stack was not visible) then any prior calls to move the stack to the
  31.                 // will not update the focused stack.  If starting the new activity now allows the
  32.                 // task stack to be focusable, then ensure that we now update the focused stack
  33.                 // accordingly.
  34.                 if (mTargetStack.isFocusable()
  35.                         && !mRootActivityContainer.isTopDisplayFocusedStack(mTargetStack)) {
  36.                     mTargetStack.moveToFront("startActivityUnchecked");
  37.                 }
  38.                 mRootActivityContainer.resumeFocusedStacksTopActivities(
  39.                         mTargetStack, mStartActivity, mOptions);
  40.             }
  41.         } else if (mStartActivity != null) {
  42.             mSupervisor.mRecentTasks.add(mStartActivity.getTaskRecord());
  43.         }
  44.         mRootActivityContainer.updateUserStack(mStartActivity.mUserId, mTargetStack);
  45.  
  46.         mSupervisor.handleNonResizableTaskIfNeeded(mStartActivity.getTaskRecord(),
  47.                 preferredWindowingMode, mPreferredDisplayId, mTargetStack);
  48.  
  49.         return START_SUCCESS;
  50.     }

这里走的是 RootActivityContainer 的 resumeFocusedStacksTopActivities 方法。

9. RootActivityContainer

RootActivityContainer.java (framework\base\services\core\java\com\android\server\wm) 

RootActivityContainer是10.0新引入的类，从类的注释可以看出这个类是暂时用来分担 ActivityStackSupervisor 的部分职责的。

  1. /**
  2.  * Root node for activity containers.
  3.  * TODO: This class is mostly temporary to separate things out of ActivityStackSupervisor.java. The
  4.  * intention is to have this merged with RootWindowContainer.java as part of unifying the hierarchy.
  5.  */
  6. class RootActivityContainer extends ConfigurationContainer
  7.         implements DisplayManager.DisplayListener {
  8.  
  9.     ...
  10.  
  11.     boolean resumeFocusedStacksTopActivities(
  12.             ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
  13.  
  14.         if (!mStackSupervisor.readyToResume()) {
  15.             return false;
  16.         }
  17.  
  18.         boolean result = false;
  19.         if (targetStack != null && (targetStack.isTopStackOnDisplay()
  20.                 || getTopDisplayFocusedStack() == targetStack)) {
  21.             result = targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
  22.         }
  23.  
  24.     ...
  25.  
  26.         return result;
  27.     }
  28.  
  29.     ...
  30.  
  31. }

主要调用了 ActivityStack 的 resumeTopActivityUncheckedLocked 方法。

10. ActivityStack

ActivityStack.java (framework\base\services\core\java\com\android\server\wm) 

  1.     /**
  2.      * Ensure that the top activity in the stack is resumed.
  3.      *
  4.      * @param prev The previously resumed activity, for when in the process
  5.      * of pausing; can be null to call from elsewhere.
  6.      * @param options Activity options.
  7.      *
  8.      * @return Returns true if something is being resumed, or false if
  9.      * nothing happened.
  10.      *
  11.      * NOTE: It is not safe to call this method directly as it can cause an activity in a
  12.      *       non-focused stack to be resumed.
  13.      *       Use {@link RootActivityContainer#resumeFocusedStacksTopActivities} to resume the
  14.      *       right activity for the current system state.
  15.      */
  16.     @GuardedBy("mService")
  17.     boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
  18.         if (mInResumeTopActivity) {
  19.             // Don't even start recursing.
  20.             return false;
  21.         }
  22.  
  23.         boolean result = false;
  24.         try {
  25.             // Protect against recursion.
  26.             mInResumeTopActivity = true;
  27.             result = resumeTopActivityInnerLocked(prev, options);
  28.  
  29.             // When resuming the top activity, it may be necessary to pause the top activity (for
  30.             // example, returning to the lock screen. We suppress the normal pause logic in
  31.             // {@link #resumeTopActivityUncheckedLocked}, since the top activity is resumed at the
  32.             // end. We call the {@link ActivityStackSupervisor#checkReadyForSleepLocked} again here
  33.             // to ensure any necessary pause logic occurs. In the case where the Activity will be
  34.             // shown regardless of the lock screen, the call to
  35.             // {@link ActivityStackSupervisor#checkReadyForSleepLocked} is skipped.
  36.             final ActivityRecord next = topRunningActivityLocked(true /* focusableOnly */);
  37.             if (next == null || !next.canTurnScreenOn()) {
  38.                 checkReadyForSleep();
  39.             }
  40.         } finally {
  41.             mInResumeTopActivity = false;
  42.         }
  43.  
  44.         return result;
  45.     }

核心代码是调用了 resumeTopActivityInnerLocked 方法：

  1.     @GuardedBy("mService")
  2.     private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
  3.  
  4.         ...
  5.  
  6.         boolean pausing = getDisplay().pauseBackStacks(userLeaving, next, false);
  7.         if (mResumedActivity != null) {    // 4
  8.             if (DEBUG_STATES) Slog.d(TAG_STATES,
  9.                     "resumeTopActivityLocked: Pausing " + mResumedActivity);
  10.             pausing |= startPausingLocked(userLeaving, false, next, false);
  11.         }
  12.  
  13.         ...
  14.  
  15.         if (next.attachedToProcess()) {
  16.             
  17.             ...
  18.  
  19.                 mStackSupervisor.startSpecificActivityLocked(next, true, false);   // 5-1
  20.                 return true;
  21.             }
  22.  
  23.             // From this point on, if something goes wrong there is no way
  24.             // to recover the activity.
  25.             try {
  26.                 next.completeResumeLocked();
  27.             } catch (Exception e) {
  28.                 // If any exception gets thrown, toss away this
  29.                 // activity and try the next one.
  30.                 Slog.w(TAG, "Exception thrown during resume of " + next, e);
  31.                 requestFinishActivityLocked(next.appToken, Activity.RESULT_CANCELED, null,
  32.                         "resume-exception", true);
  33.                 return true;
  34.             }
  35.         } else {
  36.             // Whoops, need to restart this activity!
  37.             if (!next.hasBeenLaunched) {
  38.                 next.hasBeenLaunched = true;
  39.             } else {
  40.                 if (SHOW_APP_STARTING_PREVIEW) {
  41.                     next.showStartingWindow(null /* prev */, false /* newTask */,
  42.                             false /* taskSwich */);
  43.                 }
  44.                 if (DEBUG_SWITCH) Slog.v(TAG_SWITCH, "Restarting: " + next);
  45.             }
  46.             if (DEBUG_STATES) Slog.d(TAG_STATES, "resumeTopActivityLocked: Restarting " + next);
  47.             mStackSupervisor.startSpecificActivityLocked(next, true, true);    // 5-2
  48.         }
  49.  
  50. }

注释 4：首先会去判断是否有 Activity 处于 Resume 状态，有的话会先调用  startPausingLocked 方法让 Activity 执行 Pausing 过程。接着才会调用 注释5-1 或者 5-2 中 ActivityStackSupervisor 中 的 startSpecificActivityLocked 方法。

这里先追 注释4 的 startPausingLocked 方法：

  1.     final boolean startPausingLocked(boolean userLeaving, boolean uiSleeping,
  2.             ActivityRecord resuming, boolean pauseImmediately) {
  3.         
  4.         ...
  5.  
  6.         if (prev.attachedToProcess()) {
  7.             if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Enqueueing pending pause: " + prev);
  8.             try {
  9.                 EventLogTags.writeAmPauseActivity(prev.mUserId, System.identityHashCode(prev),
  10.                         prev.shortComponentName, "userLeaving=" + userLeaving);
  11.  
  12.                 mService.getLifecycleManager().scheduleTransaction(prev.app.getThread(),
  13.                         prev.appToken, PauseActivityItem.obtain(prev.finishing, userLeaving,
  14.                                 prev.configChangeFlags, pauseImmediately));
  15.             } catch (Exception e) {
  16.                 // Ignore exception, if process died other code will cleanup.
  17.                 Slog.w(TAG, "Exception thrown during pause", e);
  18.                 mPausingActivity = null;
  19.                 mLastPausedActivity = null;
  20.                 mLastNoHistoryActivity = null;
  21.             }
  22.         } else {
  23.             mPausingActivity = null;
  24.             mLastPausedActivity = null;
  25.             mLastNoHistoryActivity = null;
  26.         }
  27.  
  28.         ...
  29.  
  30.     }

这里的核心是 mService.getLifecycleManager().scheduleTransaction，这里的 mService 是 ActivityTaskManagerService。而

getLifecycleManager 方法获取到的是 ClientLifecycleManager。

11. ClientLifecycleManager

ClientLifecycleManager.java (framework\base\services\core\java\com\android\server\wm) 

在 ClientLifecycleManager 的中 scheduleTransaction 重载了四个方法：

  1.     void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
  2.         final IApplicationThread client = transaction.getClient();
  3.         transaction.schedule();
  4.         if (!(client instanceof Binder)) {
  5.             // If client is not an instance of Binder - it's a remote call and at this point it is
  6.             // safe to recycle the object. All objects used for local calls will be recycled after
  7.             // the transaction is executed on client in ActivityThread.
  8.             transaction.recycle();
  9.         }
  10.     }
  11.  
  12.     /**
  13.      * Schedule a single lifecycle request or callback to client activity.
  14.      * @param client Target client.
  15.      * @param activityToken Target activity token.
  16.      * @param stateRequest A request to move target activity to a desired lifecycle state.
  17.      * @throws RemoteException
  18.      *
  19.      * @see ClientTransactionItem
  20.      */
  21.     void scheduleTransaction(@NonNull IApplicationThread client, @NonNull IBinder activityToken,
  22.             @NonNull ActivityLifecycleItem stateRequest) throws RemoteException {
  23.         final ClientTransaction clientTransaction = transactionWithState(client, activityToken,
  24.                 stateRequest);
  25.         scheduleTransaction(clientTransaction);
  26.     }
  27.  
  28.     /**
  29.      * Schedule a single callback delivery to client activity.
  30.      * @param client Target client.
  31.      * @param activityToken Target activity token.
  32.      * @param callback A request to deliver a callback.
  33.      * @throws RemoteException
  34.      *
  35.      * @see ClientTransactionItem
  36.      */
  37.     void scheduleTransaction(@NonNull IApplicationThread client, @NonNull IBinder activityToken,
  38.             @NonNull ClientTransactionItem callback) throws RemoteException {
  39.         final ClientTransaction clientTransaction = transactionWithCallback(client, activityToken,
  40.                 callback);
  41.         scheduleTransaction(clientTransaction);
  42.     }
  43.  
  44.     /**
  45.      * Schedule a single callback delivery to client application.
  46.      * @param client Target client.
  47.      * @param callback A request to deliver a callback.
  48.      * @throws RemoteException
  49.      *
  50.      * @see ClientTransactionItem
  51.      */
  52.     void scheduleTransaction(@NonNull IApplicationThread client,
  53.             @NonNull ClientTransactionItem callback) throws RemoteException {
  54.         final ClientTransaction clientTransaction = transactionWithCallback(client,
  55.                 null /* activityToken */, callback);
  56.         scheduleTransaction(clientTransaction);
  57.     }

最后都调用到了：

  1.     void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
  2.         final IApplicationThread client = transaction.getClient();
  3.         transaction.schedule();
  4.         if (!(client instanceof Binder)) {
  5.             // If client is not an instance of Binder - it's a remote call and at this point it is
  6.             // safe to recycle the object. All objects used for local calls will be recycled after
  7.             // the transaction is executed on client in ActivityThread.
  8.             transaction.recycle();
  9.         }
  10.     }

通过 ClientTransaction  的 getClient 方法获取到 client 对象，client 是 IApplicationThread 类型，在 ClientTransaction 的静态方法 obtain 中进行初始化：

  1.     public static ClientTransaction obtain(IApplicationThread client, IBinder activityToken) {
  2.         ClientTransaction instance = ObjectPool.obtain(ClientTransaction.class);
  3.         if (instance == null) {
  4.             instance = new ClientTransaction();
  5.         }
  6.         instance.mClient = client;
  7.         instance.mActivityToken = activityToken;
  8.  
  9.         return instance;
  10.     }

12. ActivityThread

ActivityThread.java (framework\base\core\java\android\app) 

在 ActivityThread 中的内部类 ApplicationThread 继承了 IApplicationThread.Stub，这里又是一个 AIDL，这里是 AIDL 的 Server 端：

  1. public final class ActivityThread extends ClientTransactionHandler {
  2.     
  3.     ...
  4.  
  5.     private class ApplicationThread extends IApplicationThread.Stub {
  6.  
  7.         ...
  8.  
  9.         @Override
  10.         public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
  11.             ActivityThread.this.scheduleTransaction(transaction);
  12.         }
  13.         
  14.         ...
  15.     }
  16.     
  17.     ...
  18. }

这里  ActivityThread.this.scheduleTransaction(transaction)，但是在 ActivityThread 中并找不到 方法 scheduleTransaction，在父类 ClientTransactionHandler  中可以找到该方法。

13. ClientTransactionHandler 

ClientTransactionHandler.java (framework\base\core\java\android\app)

  1. public abstract class ClientTransactionHandler {
  2.  
  3.     // Schedule phase related logic and handlers.
  4.  
  5.     /** Prepare and schedule transaction for execution. */
  6.     void scheduleTransaction(ClientTransaction transaction) {
  7.         transaction.preExecute(this);
  8.         sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
  9.     }
  10.  
  11.     ...
  12.  
  13. }

ClientTransactionHandler 为抽象类，这里调用了 sendMessage 方法，这里 sendMessage 为抽象方法：

abstract void sendMessage(int what, Object obj);

回到子类 ActivityThread 中，sendMessage 方法：

  1.     void sendMessage(int what, Object obj) {
  2.         sendMessage(what, obj, 0, 0, false);
  3.     }
  4.  
  5.     private void sendMessage(int what, Object obj, int arg1) {
  6.         sendMessage(what, obj, arg1, 0, false);
  7.     }
  8.  
  9.     private void sendMessage(int what, Object obj, int arg1, int arg2) {
  10.         sendMessage(what, obj, arg1, arg2, false);
  11.     }
  12.  
  13.     private void sendMessage(int what, Object obj, int arg1, int arg2, boolean async) {
  14.         if (DEBUG_MESSAGES) {
  15.             Slog.v(TAG,
  16.                     "SCHEDULE " + what + " " + mH.codeToString(what) + ": " + arg1 + " / " + obj);
  17.         }
  18.         Message msg = Message.obtain();
  19.         msg.what = what;
  20.         msg.obj = obj;
  21.         msg.arg1 = arg1;
  22.         msg.arg2 = arg2;
  23.         if (async) {
  24.             msg.setAsynchronous(true);
  25.         }
  26.         mH.sendMessage(msg);
  27.     }
  28.  
  29.     private void sendMessage(int what, Object obj, int arg1, int arg2, int seq) {
  30.         if (DEBUG_MESSAGES) Slog.v(
  31.                 TAG, "SCHEDULE " + mH.codeToString(what) + " arg1=" + arg1 + " arg2=" + arg2 +
  32.                         "seq= " + seq);
  33.         Message msg = Message.obtain();
  34.         msg.what = what;
  35.         SomeArgs args = SomeArgs.obtain();
  36.         args.arg1 = obj;
  37.         args.argi1 = arg1;
  38.         args.argi2 = arg2;
  39.         args.argi3 = seq;
  40.         msg.obj = args;
  41.         mH.sendMessage(msg);
  42.     }

如果之前有去研究：主线程 Looper.loop() 死循环为何不会ANR 就会知道有个 H 类，H类就是负责生命周期的驱动，由于上面 传递了 ActivityThread.H.EXECUTE_TRANSACTION：

  1. class H extends Handler {
  2.  
  3.     ...
  4.     public void handleMessage(Message msg) {    
  5.  
  6.         switch (msg.what) {
  7.                     ...
  8.  
  9.                     case EXECUTE_TRANSACTION:
  10.                     final ClientTransaction transaction = (ClientTransaction) msg.obj;
  11.                     mTransactionExecutor.execute(transaction);
  12.                     if (isSystem()) {
  13.                         // Client transactions inside system process are recycled on the client side
  14.                         // instead of ClientLifecycleManager to avoid being cleared before this
  15.                         // message is handled.
  16.                         transaction.recycle();
  17.                     }
  18.                     // TODO(lifecycler): Recycle locally scheduled transactions.
  19.                     break;
  20.  
  21.                     ...
  22.  
  23.         }
  24.     }
  25. }

这里调用了 TransactionExecutor 的方法 execute(transaction)。

14. TransactionExecutor

TransactionExecutor.java (framework\base\core\java\android\app\servertransaction) 

execute 方法如下：

  1.  
  2.     public void execute(ClientTransaction transaction) {
  3.         
  4.         ...
  5.  
  6.         executeLifecycleState(transaction);
  7.         
  8.         ...
  9.     }

这里的核心就是方法 executeLifecycleState：

  1.     private void executeLifecycleState(ClientTransaction transaction) {
  2.         final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();
  3.         
  4.         ...
  5.             
  6.         // Execute the final transition with proper parameters.
  7.         lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
  8.         lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
  9.     }

这里返回一个 ActivityLifecycleItem  类型的对象，而 ActivityLifecycleItem 是一个抽象类，必然要有实现类，通过全局搜索存在三个实现类：PauseActivityItem，ResumeActivityItem，StopActivityItem，由于这里是要让 Activity 进入 Pause 状态，所以这里是 PauseActivityItem。

15. PauseActivityItem

PauseActivityItem.java (framework\base\core\java\android\app\servertransaction) 
 

  1. public class PauseActivityItem extends ActivityLifecycleItem {
  2.  
  3.     ...
  4.  
  5.     @Override
  6.     public void execute(ClientTransactionHandler client, IBinder token,
  7.             PendingTransactionActions pendingActions) {
  8.         Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityPause");
  9.         client.handlePauseActivity(token, mFinished, mUserLeaving, mConfigChanges, pendingActions,
  10.                 "PAUSE_ACTIVITY_ITEM");
  11.         Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
  12.     }
  13.  
  14.     ...
  15.  
  16. }

在 execute 中调用了 ActivityThread 中的 handlePauseActivity 方法：

  1.     @Override
  2.     public void handlePauseActivity(IBinder token, boolean finished, boolean userLeaving,
  3.             int configChanges, PendingTransactionActions pendingActions, String reason) {
  4.         ActivityClientRecord r = mActivities.get(token);
  5.         if (r != null) {
  6.             if (userLeaving) {
  7.                 performUserLeavingActivity(r);
  8.             }
  9.  
  10.             r.activity.mConfigChangeFlags |= configChanges;
  11.             performPauseActivity(r, finished, reason, pendingActions);
  12.  
  13.             // Make sure any pending writes are now committed.
  14.             if (r.isPreHoneycomb()) {
  15.                 QueuedWork.waitToFinish();
  16.             }
  17.             mSomeActivitiesChanged = true;
  18.         }
  19.     }

接着看 performPauseActivity 方法：

  1.     /**
  2.      * Pause the activity.
  3.      * @return Saved instance state for pre-Honeycomb apps if it was saved, {@code null} otherwise.
  4.      */
  5.     private Bundle performPauseActivity(ActivityClientRecord r, boolean finished, String reason,
  6.             PendingTransactionActions pendingActions) {
  7.         if (r.paused) {
  8.             if (r.activity.mFinished) {
  9.                 // If we are finishing, we won't call onResume() in certain cases.
  10.                 // So here we likewise don't want to call onPause() if the activity
  11.                 // isn't resumed.
  12.                 return null;
  13.             }
  14.             RuntimeException e = new RuntimeException(
  15.                     "Performing pause of activity that is not resumed: "
  16.                     + r.intent.getComponent().toShortString());
  17.             Slog.e(TAG, e.getMessage(), e);
  18.         }
  19.         if (finished) {
  20.             r.activity.mFinished = true;
  21.         }
  22.  
  23.         // Pre-Honeycomb apps always save their state before pausing
  24.         final boolean shouldSaveState = !r.activity.mFinished && r.isPreHoneycomb();
  25.         if (shouldSaveState) {
  26.             callActivityOnSaveInstanceState(r);
  27.         }
  28.  
  29.         performPauseActivityIfNeeded(r, reason);
  30.  
  31.         // Notify any outstanding on paused listeners
  32.         ArrayList<OnActivityPausedListener> listeners;
  33.         synchronized (mOnPauseListeners) {
  34.             listeners = mOnPauseListeners.remove(r.activity);
  35.         }
  36.         int size = (listeners != null ? listeners.size() : 0);
  37.         for (int i = 0; i < size; i++) {
  38.             listeners.get(i).onPaused(r.activity);
  39.         }
  40.  
  41.         final Bundle oldState = pendingActions != null ? pendingActions.getOldState() : null;
  42.         if (oldState != null) {
  43.             // We need to keep around the original state, in case we need to be created again.
  44.             // But we only do this for pre-Honeycomb apps, which always save their state when
  45.             // pausing, so we can not have them save their state when restarting from a paused
  46.             // state. For HC and later, we want to (and can) let the state be saved as the
  47.             // normal part of stopping the activity.
  48.             if (r.isPreHoneycomb()) {
  49.                 r.state = oldState;
  50.             }
  51.         }
  52.  
  53.         return shouldSaveState ? r.state : null;
  54.     }

调用 performPauseActivityIfNeeded 方法：

  1.     private void performPauseActivityIfNeeded(ActivityClientRecord r, String reason) {
  2.         if (r.paused) {
  3.             // You are already paused silly...
  4.             return;
  5.         }
  6.  
  7.         // Always reporting top resumed position loss when pausing an activity. If necessary, it
  8.         // will be restored in performResumeActivity().
  9.         reportTopResumedActivityChanged(r, false /* onTop */, "pausing");
  10.  
  11.         try {
  12.             r.activity.mCalled = false;
  13.             mInstrumentation.callActivityOnPause(r.activity);
  14.             if (!r.activity.mCalled) {
  15.                 throw new SuperNotCalledException("Activity " + safeToComponentShortString(r.intent)
  16.                         + " did not call through to super.onPause()");
  17.             }
  18.         } catch (SuperNotCalledException e) {
  19.             throw e;
  20.         } catch (Exception e) {
  21.             if (!mInstrumentation.onException(r.activity, e)) {
  22.                 throw new RuntimeException("Unable to pause activity "
  23.                         + safeToComponentShortString(r.intent) + ": " + e.toString(), e);
  24.             }
  25.         }
  26.         r.setState(ON_PAUSE);
  27.     }

这里有回到了 Instrumentation 类中的 callActivityOnPause 方法：

  1.     public void callActivityOnPause(Activity activity) {
  2.         activity.performPause();
  3.     }

接着回到 Activity 中的方法 performPause：

  1.     final void performPause() {
  2.         dispatchActivityPrePaused();
  3.         mDoReportFullyDrawn = false;
  4.         mFragments.dispatchPause();
  5.         mCalled = false;
  6.         onPause();
  7.         writeEventLog(LOG_AM_ON_PAUSE_CALLED, "performPause");
  8.         mResumed = false;
  9.         if (!mCalled && getApplicationInfo().targetSdkVersion
  10.                 >= android.os.Build.VERSION_CODES.GINGERBREAD) {
  11.             throw new SuperNotCalledException(
  12.                     "Activity " + mComponent.toShortString() +
  13.                     " did not call through to super.onPause()");
  14.         }
  15.         dispatchActivityPostPaused();
  16.     }

在这里就看到了我们熟悉的 onPause 方法。

16. 小结

从第 10 开始存在着两条线，从 10 到 15 是其中将 Activity 切换为 onPause 状态的逻辑，相应的流程图如下所示：

17. ActivityStackSupervisor

ActivityStackSupervisor.java (framework\base\services\core\java\com\android\server\wm) 
在第10 中的注释5-1 和 5-2 中 调用了ActivityStackSupervisor 中 的 startSpecificActivityLocked 方法：

  1.     void startSpecificActivityLocked(ActivityRecord r, boolean andResume, boolean checkConfig) {
  2.         // Is this activity's application already running?
  3.         final WindowProcessController wpc =
  4.                 mService.getProcessController(r.processName, r.info.applicationInfo.uid);
  5.  
  6.         boolean knownToBeDead = false;
  7.         if (wpc != null && wpc.hasThread()) {      // 6
  8.             try {
  9.                 realStartActivityLocked(r, wpc, andResume, checkConfig);    // 7
  10.                 return;
  11.             } catch (RemoteException e) {
  12.                 Slog.w(TAG, "Exception when starting activity "
  13.                         + r.intent.getComponent().flattenToShortString(), e);
  14.             }
  15.  
  16.             // If a dead object exception was thrown -- fall through to
  17.             // restart the application.
  18.             knownToBeDead = true;
  19.         }
  20.  
  21.         // Suppress transition until the new activity becomes ready, otherwise the keyguard can
  22.         // appear for a short amount of time before the new process with the new activity had the
  23.         // ability to set its showWhenLocked flags.
  24.         if (getKeyguardController().isKeyguardLocked()) {
  25.             r.notifyUnknownVisibilityLaunched();
  26.         }
  27.  
  28.         try {
  29.             if (Trace.isTagEnabled(TRACE_TAG_ACTIVITY_MANAGER)) {
  30.                 Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "dispatchingStartProcess:"
  31.                         + r.processName);
  32.             }
  33.             // Post message to start process to avoid possible deadlock of calling into AMS with the
  34.             // ATMS lock held.
  35.             final Message msg = PooledLambda.obtainMessage(    // 8
  36.                     ActivityManagerInternal::startProcess, mService.mAmInternal, r.processName,
  37.                     r.info.applicationInfo, knownToBeDead, "activity", r.intent.getComponent());
  38.             mService.mH.sendMessage(msg);    
  39.         } finally {
  40.             Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
  41.         }
  42.     }

注释 6 中：判断 App 进程是否存在，并且已经启动，如果存在而且已经启动，则调用方法 realStartActivityLocked。

注释 8 ：如果 App 进程不存在，从注释可以看出通过 sendMessage 启动新的进程。因为这里追的是从 Launcher 启动 App，所以进程必然不存在，这里追如果创建进程。

这里的 mService 是 ActivityTaskManagerService，它的内部和 ActivityThread 一样也存在一个 H 类，只是它比 ActivityThread 简单很多：

  1.     final class H extends Handler {
  2.         static final int REPORT_TIME_TRACKER_MSG = 1;
  3.  
  4.  
  5.         static final int FIRST_ACTIVITY_STACK_MSG = 100;
  6.         static final int FIRST_SUPERVISOR_STACK_MSG = 200;
  7.  
  8.         H(Looper looper) {
  9.             super(looper);
  10.         }
  11.  
  12.         @Override
  13.         public void handleMessage(Message msg) {
  14.             switch (msg.what) {
  15.                 case REPORT_TIME_TRACKER_MSG: {
  16.                     AppTimeTracker tracker = (AppTimeTracker) msg.obj;
  17.                     tracker.deliverResult(mContext);
  18.                 } break;
  19.             }
  20.         }
  21.     }

这里看起来不像是启动进程的地方，这时候回头看这段代码：

  1.             final Message msg = PooledLambda.obtainMessage(    // 8
  2.                     ActivityManagerInternal::startProcess, mService.mAmInternal, r.processName,
  3.                     r.info.applicationInfo, knownToBeDead, "activity", r.intent.getComponent());

猜测启动进程在 ActivityManagerInternal::startProcess，真的有 ActivityManagerInternal 类，而且在它的内部也有方法 startProcess，只不过此类为抽象类，方法也为抽象方法。在庞大的 ActivityManagerService 类中存在一个内部类 LocalService，它的父类就是 ActivityManagerInternal。

18. ActivityManagerService

ActivityManagerService.java (framework\base\services\core\java\com\android\server\am) 

ActivityManagerService 类之前有 2w多行的代码，在 Android 10 中仍然还是 19000多行，说它庞大一点也不冤枉。看看它里面的 LocalService 的 startProcess 方法：

  1.         @Override
  2.         public void startProcess(String processName, ApplicationInfo info,
  3.                 boolean knownToBeDead, String hostingType, ComponentName hostingName) {
  4.             try {
  5.                 if (Trace.isTagEnabled(Trace.TRACE_TAG_ACTIVITY_MANAGER)) {
  6.                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "startProcess:"
  7.                             + processName);
  8.                 }
  9.                 synchronized (ActivityManagerService.this) {
  10.                     startProcessLocked(processName, info, knownToBeDead, 0 /* intentFlags */,
  11.                             new HostingRecord(hostingType, hostingName),
  12.                             false /* allowWhileBooting */, false /* isolated */,
  13.                             true /* keepIfLarge */);
  14.                 }
  15.             } finally {
  16.                 Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
  17.             }
  18.         }

调用了方法 startProcessLocked 方法：

  1.     @GuardedBy("this")
  2.     final ProcessRecord startProcessLocked(String processName,
  3.             ApplicationInfo info, boolean knownToBeDead, int intentFlags,
  4.             HostingRecord hostingRecord, boolean allowWhileBooting,
  5.             boolean isolated, boolean keepIfLarge) {
  6.         return mProcessList.startProcessLocked(processName, info, knownToBeDead, intentFlags,
  7.                 hostingRecord, allowWhileBooting, isolated, 0 /* isolatedUid */, keepIfLarge,
  8.                 null /* ABI override */, null /* entryPoint */, null /* entryPointArgs */,
  9.                 null /* crashHandler */);
  10.     }

调用了 ProcessList 的 startProcessLocked 方法。

19. ProcessList

ProcessList.java (framework\base\services\core\java\com\android\server\am)

startProcessLocked  方法中调用了 startProcess 方法：

  1.     private Process.ProcessStartResult startProcess(HostingRecord hostingRecord, String entryPoint,
  2.             ProcessRecord app, int uid, int[] gids, int runtimeFlags, int mountExternal,
  3.             String seInfo, String requiredAbi, String instructionSet, String invokeWith,
  4.             long startTime) {
  5.         try {
  6.             Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "Start proc: " +
  7.                     app.processName);
  8.             checkSlow(startTime, "startProcess: asking zygote to start proc");
  9.             final Process.ProcessStartResult startResult;
  10.             if (hostingRecord.usesWebviewZygote()) {
  11.                 startResult = startWebView(entryPoint,
  12.                         app.processName, uid, uid, gids, runtimeFlags, mountExternal,
  13.                         app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,
  14.                         app.info.dataDir, null, app.info.packageName,
  15.                         new String[] {PROC_START_SEQ_IDENT + app.startSeq});
  16.             } else if (hostingRecord.usesAppZygote()) {
  17.                 final AppZygote appZygote = createAppZygoteForProcessIfNeeded(app);
  18.  
  19.                 startResult = appZygote.getProcess().start(entryPoint,
  20.                         app.processName, uid, uid, gids, runtimeFlags, mountExternal,
  21.                         app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,
  22.                         app.info.dataDir, null, app.info.packageName,
  23.                         /*useUsapPool=*/ false,
  24.                         new String[] {PROC_START_SEQ_IDENT + app.startSeq});
  25.             } else {
  26.                 startResult = Process.start(entryPoint,    // 9
  27.                         app.processName, uid, uid, gids, runtimeFlags, mountExternal,
  28.                         app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,
  29.                         app.info.dataDir, invokeWith, app.info.packageName,
  30.                         new String[] {PROC_START_SEQ_IDENT + app.startSeq});
  31.             }
  32.             checkSlow(startTime, "startProcess: returned from zygote!");
  33.             return startResult;
  34.         } finally {
  35.             Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
  36.         }
  37.     }

最后调用了 注释 9 中的 Process 的 start 方法。

20. Process

Process.java (framework\base\core\java\android\os)  

start 方法：

  1.     public static ProcessStartResult start(@NonNull final String processClass,
  2.                                            @Nullable final String niceName,
  3.                                            int uid, int gid, @Nullable int[] gids,
  4.                                            int runtimeFlags,
  5.                                            int mountExternal,
  6.                                            int targetSdkVersion,
  7.                                            @Nullable String seInfo,
  8.                                            @NonNull String abi,
  9.                                            @Nullable String instructionSet,
  10.                                            @Nullable String appDataDir,
  11.                                            @Nullable String invokeWith,
  12.                                            @Nullable String packageName,
  13.                                            @Nullable String[] zygoteArgs) {
  14.         return ZYGOTE_PROCESS.start(processClass, niceName, uid, gid, gids,
  15.                     runtimeFlags, mountExternal, targetSdkVersion, seInfo,
  16.                     abi, instructionSet, appDataDir, invokeWith, packageName,
  17.                     /*useUsapPool=*/ true, zygoteArgs);
  18.     }

调用了 ZygoteProcess 的 start 方法。

21. ZygoteProcess

ZygoteProcess.java (framework\base\core\java\android\os)

  1.     public final Process.ProcessStartResult start(@NonNull final String processClass,
  2.                                                   final String niceName,
  3.                                                   int uid, int gid, @Nullable int[] gids,
  4.                                                   int runtimeFlags, int mountExternal,
  5.                                                   int targetSdkVersion,
  6.                                                   @Nullable String seInfo,
  7.                                                   @NonNull String abi,
  8.                                                   @Nullable String instructionSet,
  9.                                                   @Nullable String appDataDir,
  10.                                                   @Nullable String invokeWith,
  11.                                                   @Nullable String packageName,
  12.                                                   boolean useUsapPool,
  13.                                                   @Nullable String[] zygoteArgs) {
  14.         // TODO (chriswailes): Is there a better place to check this value?
  15.         if (fetchUsapPoolEnabledPropWithMinInterval()) {
  16.             informZygotesOfUsapPoolStatus();
  17.         }
  18.  
  19.         try {
  20.             return startViaZygote(processClass, niceName, uid, gid, gids,
  21.                     runtimeFlags, mountExternal, targetSdkVersion, seInfo,
  22.                     abi, instructionSet, appDataDir, invokeWith, /*startChildZygote=*/ false,
  23.                     packageName, useUsapPool, zygoteArgs);
  24.         } catch (ZygoteStartFailedEx ex) {
  25.             Log.e(LOG_TAG,
  26.                     "Starting VM process through Zygote failed");
  27.             throw new RuntimeException(
  28.                     "Starting VM process through Zygote failed", ex);
  29.         }
  30.     }

继续调用 startViaZygote 方法：

  1.     private Process.ProcessStartResult startViaZygote(@NonNull final String processClass,
  2.                                                       @Nullable final String niceName,
  3.                                                       final int uid, final int gid,
  4.                                                       @Nullable final int[] gids,
  5.                                                       int runtimeFlags, int mountExternal,
  6.                                                       int targetSdkVersion,
  7.                                                       @Nullable String seInfo,
  8.                                                       @NonNull String abi,
  9.                                                       @Nullable String instructionSet,
  10.                                                       @Nullable String appDataDir,
  11.                                                       @Nullable String invokeWith,
  12.                                                       boolean startChildZygote,
  13.                                                       @Nullable String packageName,
  14.                                                       boolean useUsapPool,
  15.                                                       @Nullable String[] extraArgs)
  16.                                                       throws ZygoteStartFailedEx {
  17.         ...
  18.  
  19.         synchronized(mLock) {
  20.             // The USAP pool can not be used if the application will not use the systems graphics
  21.             // driver.  If that driver is requested use the Zygote application start path.
  22.             return zygoteSendArgsAndGetResult(openZygoteSocketIfNeeded(abi),
  23.                                               useUsapPool,
  24.                                               argsForZygote);
  25.         }
  26.     }

两个核心方法：openZygoteSocketIfNeeded 和 zygoteSendArgsAndGetResult。

openZygoteSocketIfNeeded ：

  1.     @GuardedBy("mLock")
  2.     private ZygoteState openZygoteSocketIfNeeded(String abi) throws ZygoteStartFailedEx {
  3.         try {
  4.             attemptConnectionToPrimaryZygote();
  5.  
  6.             if (primaryZygoteState.matches(abi)) {
  7.                 return primaryZygoteState;
  8.             }
  9.  
  10.             if (mZygoteSecondarySocketAddress != null) {
  11.                 // The primary zygote didn't match. Try the secondary.
  12.                 attemptConnectionToSecondaryZygote();
  13.  
  14.                 if (secondaryZygoteState.matches(abi)) {
  15.                     return secondaryZygoteState;
  16.                 }
  17.             }
  18.         } catch (IOException ioe) {
  19.             throw new ZygoteStartFailedEx("Error connecting to zygote", ioe);
  20.         }
  21.  
  22.         throw new ZygoteStartFailedEx("Unsupported zygote ABI: " + abi);
  23.     }

通过 attemptConnectionToPrimaryZygote 方法向主 Zygote 发起连接请求。

zygoteSendArgsAndGetResult：

  1.     private Process.ProcessStartResult zygoteSendArgsAndGetResult(
  2.             ZygoteState zygoteState, boolean useUsapPool, @NonNull ArrayList<String> args)
  3.             throws ZygoteStartFailedEx {
  4.         
  5.         ...
  6.  
  7.         return attemptZygoteSendArgsAndGetResult(zygoteState, msgStr);
  8.     }

调用了方法 attemptZygoteSendArgsAndGetResult：

  1.     private Process.ProcessStartResult attemptZygoteSendArgsAndGetResult(
  2.             ZygoteState zygoteState, String msgStr) throws ZygoteStartFailedEx {
  3.         try {
  4.             final BufferedWriter zygoteWriter = zygoteState.mZygoteOutputWriter;
  5.             final DataInputStream zygoteInputStream = zygoteState.mZygoteInputStream;
  6.  
  7.             zygoteWriter.write(msgStr);
  8.             zygoteWriter.flush();
  9.  
  10.             // Always read the entire result from the input stream to avoid leaving
  11.             // bytes in the stream for future process starts to accidentally stumble
  12.             // upon.
  13.             Process.ProcessStartResult result = new Process.ProcessStartResult();
  14.             result.pid = zygoteInputStream.readInt();
  15.             result.usingWrapper = zygoteInputStream.readBoolean();
  16.  
  17.             if (result.pid < 0) {
  18.                 throw new ZygoteStartFailedEx("fork() failed");
  19.             }
  20.     
  21.             ...
  22.     }

这个方法中通过 socket 向 Zygote 进程发送参数列表，然后进入“阻塞等待”状态，直到 socket 服务端发送回来新创建的进程 pid。关于 Zygote 的创建请查看一位大神写的文章：【 Android 10 进程线程 】系列 -- 关于 "进程" -> "创建" 的原理。Zygote 进程源码的最后调用到了 ActivityThread.main() 方法。

附上以上流程的流程图：

22. 再次梳理 ActivityThread

ActivityThread.java (framework\base\core\java\android\app) 

  1. public final class ActivityThread extends ClientTransactionHandler {
  2.  
  3.     ...
  4.  
  5.     public static void main(String[] args) {
  6.         Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");
  7.  
  8.         // Install selective syscall interception
  9.         AndroidOs.install();
  10.  
  11.         // CloseGuard defaults to true and can be quite spammy.  We
  12.         // disable it here, but selectively enable it later (via
  13.         // StrictMode) on debug builds, but using DropBox, not logs.
  14.         CloseGuard.setEnabled(false);
  15.  
  16.         Environment.initForCurrentUser();
  17.  
  18.         // Make sure TrustedCertificateStore looks in the right place for CA certificates
  19.         final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());
  20.         TrustedCertificateStore.setDefaultUserDirectory(configDir);
  21.  
  22.         Process.setArgV0("<pre-initialized>");
  23.  
  24.         Looper.prepareMainLooper();    // 10
  25.  
  26.         // Find the value for {@link #PROC_START_SEQ_IDENT} if provided on the command line.
  27.         // It will be in the format "seq=114"
  28.         long startSeq = 0;
  29.         if (args != null) {
  30.             for (int i = args.length - 1; i >= 0; --i) {
  31.                 if (args[i] != null && args[i].startsWith(PROC_START_SEQ_IDENT)) {
  32.                     startSeq = Long.parseLong(
  33.                             args[i].substring(PROC_START_SEQ_IDENT.length()));
  34.                 }
  35.             }
  36.         }
  37.         ActivityThread thread = new ActivityThread();    // 11
  38.         thread.attach(false, startSeq);
  39.  
  40.         if (sMainThreadHandler == null) {
  41.             sMainThreadHandler = thread.getHandler();
  42.         }
  43.  
  44.         if (false) {
  45.             Looper.myLooper().setMessageLogging(new
  46.                     LogPrinter(Log.DEBUG, "ActivityThread"));
  47.         }
  48.  
  49.         // End of event ActivityThreadMain.
  50.         Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
  51.         Looper.loop();
  52.  
  53.         throw new RuntimeException("Main thread loop unexpectedly exited");
  54.     }
  55.  
  56.     ...
  57.  
  58. }

看到这个 main 方法，第一眼就是觉得这不就是 Java 的 main 方法吗？没错，这就是 Java 中的 main 方法。

注释 10：这里创建主线程的 Looper，主线程的 Handler 不需要创建 Looper。相关联的文章可以看下之前写过的：

Android Handler 消息机制，主线程 Looper.loop() 死循环为何不会ANR。

注释 11：初始化 ActivityThread，并且 attach 到系统进程。

attach 方法：

  1.     @UnsupportedAppUsage
  2.     private void attach(boolean system, long startSeq) {
  3.         sCurrentActivityThread = this;
  4.         mSystemThread = system;
  5.         if (!system) {
  6.             android.ddm.DdmHandleAppName.setAppName("<pre-initialized>",
  7.                                                     UserHandle.myUserId());
  8.             RuntimeInit.setApplicationObject(mAppThread.asBinder());
  9.             final IActivityManager mgr = ActivityManager.getService();    // 12
  10.             try {
  11.                 mgr.attachApplication(mAppThread, startSeq);    // 13
  12.             } catch (RemoteException ex) {
  13.                 throw ex.rethrowFromSystemServer();
  14.             }
  15.             ...
  16.  
  17.         } else {
  18.             ...
  19.         }
  20.  
  21.         ...
  22.  
  23.         ViewRootImpl.addConfigCallback(configChangedCallback);
  24.     }

注释 12：这里的 IActivityManager 类型对象是 ActivityManagerService；

注释 13：通过 ActivityManagerService 的 attachApplication 方法绑定一个 Application，这里的 mAppThread 是 ApplicationThread 对象。

23. 再次梳理 ActivityManagerService

ActivityManagerService.java (framework\base\services\core\java\com\android\server\am) 

  1.     public final void attachApplication(IApplicationThread thread, long startSeq) {
  2.         synchronized (this) {
  3.             int callingPid = Binder.getCallingPid();
  4.             final int callingUid = Binder.getCallingUid();
  5.             final long origId = Binder.clearCallingIdentity();
  6.             attachApplicationLocked(thread, callingPid, callingUid, startSeq);
  7.             Binder.restoreCallingIdentity(origId);
  8.         }
  9.     }

这里调用了方法 attachApplicationLocked：

  1.     private final boolean attachApplicationLocked(IApplicationThread thread,
  2.             int pid, int callingUid, long startSeq) {
  3.  
  4.         ...
  5.  
  6.         boolean badApp = false;
  7.         boolean didSomething = false;
  8.  
  9.         // See if the top visible activity is waiting to run in this process...
  10.         if (normalMode) {    // 14
  11.             try {
  12.                 didSomething = mAtmInternal.attachApplication(app.getWindowProcessController());
  13.             } catch (Exception e) {
  14.                 Slog.wtf(TAG, "Exception thrown launching activities in " + app, e);
  15.                 badApp = true;
  16.             }
  17.         }
  18.  
  19.         ...
  20.  
  21.         // Find any services that should be running in this process...
  22.         if (!badApp) {    // 15
  23.             try {
  24.                 didSomething |= mServices.attachApplicationLocked(app, processName);
  25.                 checkTime(startTime, "attachApplicationLocked: after mServices.attachApplicationLocked");
  26.             } catch (Exception e) {
  27.                 Slog.wtf(TAG, "Exception thrown starting services in " + app, e);
  28.                 badApp = true;
  29.             }
  30.         }
  31.         
  32.         // Check if a next-broadcast receiver is in this process...
  33.         if (!badApp && isPendingBroadcastProcessLocked(pid)) {    // 16
  34.             try {
  35.                 didSomething |= sendPendingBroadcastsLocked(app);
  36.                 checkTime(startTime, "attachApplicationLocked: after sendPendingBroadcastsLocked");
  37.             } catch (Exception e) {
  38.                 // If the app died trying to launch the receiver we declare it 'bad'
  39.                 Slog.wtf(TAG, "Exception thrown dispatching broadcasts in " + app, e);
  40.                 badApp = true;
  41.             }
  42.         }
  43.  
  44.     ...
  45. }

注释 14、15、16  是对于Activity、Service、BroadcastReceiver的处理逻辑。这里追的是 Activity 的启动流程，所以这里只追注释 14 。

注释 14 ：调用了 ActivityTaskManagerInternal 的 attachApplication 方法。

ActivityTaskManagerInternal  在 ActivityManagerService 的构造方法中进行初始化：

mAtmInternal = LocalServices.getService(ActivityTaskManagerInternal.class);

24. ActivityTaskManagerInternal

ActivityTaskManagerInternal.java (framework\base\services\core\java\com\android\server\wm) 

ActivityTaskManagerInternal 是一个抽象类，attachApplication 也是一个抽象方法：

  1. public abstract class ActivityTaskManagerInternal {
  2.  
  3.     ...
  4.  
  5.     /** Called by AM when an application process attaches. */
  6.     public abstract boolean attachApplication(WindowProcessController wpc) throws RemoteException;
  7.  
  8.     ...
  9.  
  10. }

而 ActivityTaskManagerInternal 的实现类是 ActivityTaskManagerService 中的内部类 LocalService 继承了此抽象方法：

  1.     final class LocalService extends ActivityTaskManagerInternal {
  2.  
  3.         ...
  4.  
  5.         @HotPath(caller = HotPath.PROCESS_CHANGE)
  6.         @Override
  7.         public boolean attachApplication(WindowProcessController wpc) throws RemoteException {
  8.             synchronized (mGlobalLockWithoutBoost) {
  9.                 return mRootActivityContainer.attachApplication(wpc);
  10.             }
  11.         }
  12.  
  13.         ...
  14. }

这里调用了 RootActivityContainer 的 attachApplication 方法。

25. 再次回到 RootActivityContainer

RootActivityContainer.java (framework\base\services\core\java\com\android\server\wm) 

attachApplication  方法：

  1.     boolean attachApplication(WindowProcessController app) throws RemoteException {
  2.             
  3.             ...
  4.  
  5.             if (stack != null) {
  6.                 stack.getAllRunningVisibleActivitiesLocked(mTmpActivityList);
  7.                 final ActivityRecord top = stack.topRunningActivityLocked();
  8.                 final int size = mTmpActivityList.size();
  9.                 for (int i = 0; i < size; i++) {
  10.                     final ActivityRecord activity = mTmpActivityList.get(i);
  11.                     if (activity.app == null && app.mUid == activity.info.applicationInfo.uid
  12.                             && processName.equals(activity.processName)) {
  13.                         try {
  14.                             if (mStackSupervisor.realStartActivityLocked(activity, app,
  15.                                     top == activity /* andResume */, true /* checkConfig */)) {
  16.                                 didSomething = true;
  17.                             }
  18.                         } catch (RemoteException e) {
  19.                             Slog.w(TAG, "Exception in new application when starting activity "
  20.                                     + top.intent.getComponent().flattenToShortString(), e);
  21.                             throw e;
  22.                         }
  23.                     }
  24.                 }
  25.             }
  26.         }
  27.  
  28.         return didSomething;
  29.     }

核心代码是调用 ActivityStackSupervisor 的 realStartActivityLocked 方法。

26. 再次回到 ActivityStackSupervisor

ActivityStackSupervisor.java (framework\base\services\core\java\com\android\server\wm) 

realStartActivityLocked 方法：

  1.     boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,
  2.             boolean andResume, boolean checkConfig) throws RemoteException {
  3.  
  4.     ...
  5.                 // Schedule transaction.
  6.                 mService.getLifecycleManager().scheduleTransaction(clientTransaction);    
  7.     ...
  8. }

mService.getLifecycleManager().scheduleTransaction，这里的 mService 是 ActivityTaskManagerService。而

getLifecycleManager 方法获取到的是 ClientLifecycleManager。又再次回到了 ClientLifecycleManager 的 scheduleTransaction 方法了。接下来的流程在第11 已经分析过了，最终都会走到 Activity 的生命周期。

附上第 22 到 26 的流程图：

27. 总结

1. 当在桌面点击 App 图标后，会调用 startActivity 转而调用 startActivityForResult，接着调用 Instrumentation 的 execStartActivity 方法。

2. 通过 AIDL 调用到 ActivityTaskManagerService 的 startActivity以及 startActivityAsUser，最终会调用到 ActivityStarter 。

3. ActivityStarter 中会调用 的 execute 方法接着调用 startActivityUnchecked，此方法中调用 RootActivityContainer。RootActivityContainer是10.0新引入的类，这个类是暂时用来分担 ActivityStackSupervisor 的部分职责的。RootActivityContainer 会调用到 ActivityStack。

4.ActivityStack 会先去判断是否有 Activity 处于 Resume 状态，有的话会先调用  startPausingLocked 方法让 Activity 执行 onPause 过程。

5.ActivityStack 的 startPausingLocked执行之后。会调用ActivityStackSupervisor 中 的 startSpecificActivityLocked。

6. ActivityStackSupervisor 先判断进程是否存在，当进程不存在时候，则调用 ActivityTaskManagerService 的 sendMessage，最终调用 ActivityManagerService 的 startProcessLocked。

7. ActivityManagerService 中通过 socket 的方式去通知 Zygote 进程 fork 一个新的进程，当进程创建完毕后，会寻找子进程的 main 方法，也就是新进程 ActivityThread 中的 main 方法。

8. 在 ActivityThread 的 main 方法中会去创建 Looper 并且执行 loop 方法以及调用了 attach 方法。attach 方法中调用 ActivityManagerService 的 attachApplication 方法。

9. ActivityManagerService 的 attachApplication 中首先会调用 ApplicationThread 的 bindApplication 方法。ApplicationThread 是 ActivityThread 的一个内部类。在 bindApplication 中发送消息给 ActivityThread 的 H 类，调用 handleBindApplication 方法。

10. handleBindApplication 方法创建 application，并且调用 callApplicationOnCreate，执行 Application 的 onCreate 方法。

11. ActivityManagerService 中会调用 ActivityTaskManagerInternal 的 attachApplication，最终调用的是 ActivityTaskManagerService 的内部类 LocalService 的 attachApplication。

12. 接着调用到 ActivityStackSupervisor 的 realStartActivityLocked，经过一系列的调用后执行到 ActivityThread 的 handleLaunchActivity，最终调用到 Activity 的 onCreate 方法。

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

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

  

闽ICP备14008679号