上线了 做商务网站,怎样电脑登录网站,网页设计图片大小怎么改,可以自己做网站赚钱吗Activity 的启动过程分为两种#xff1a;一种是普通 Activity 的启动过程#xff0c;另一种是根 Activity 的启动过程。普通 Activity 指的是除应用程序启动的第一个 Activity 之外的其他 Activity。根 Activity 指的是应用程序启动的第一个 Activity#xff0c;因此#x…Activity 的启动过程分为两种一种是普通 Activity 的启动过程另一种是根 Activity 的启动过程。普通 Activity 指的是除应用程序启动的第一个 Activity 之外的其他 Activity。根 Activity 指的是应用程序启动的第一个 Activity因此根 Activity 的启动过程一般情况下也可以理解为应用程序的启动过程。
1 普通 Activity 的启动流程
普通 Activity 的启动流程比较复杂比如用 Activity A 打开 Activity B这一过程开始于 A.startActivity(Intent) 经过 system_server 进程的处理最终调用 B.finish() 结束生命周期。
普通 Activity 的启动流程可以分为以下 3 部分
Activity 请求 ActivityTaskManagerService(ATMS) 的过程ATMS 到 ApplicationThread 的调用过程ActivityThread 启动 Activity
1.1 Activity 请求 ActivityTaskManagerService(ATMS) 的过程
以下是 Activity 请求 ATMS 的时序图 Instrumentation 负责调用 Activity 和 Application 的生命周期具有跟踪 Application 和 Activity 生命周期的功能。 以下是 Instrumentation.execStartActivity 方法的相关源码
public class Instrumentation {public ActivityResult execStartActivity(Context who, IBinder contextThread, IBinder token, Activity target,Intent intent, int requestCode, Bundle options) {......try {int result ActivityTaskManager.getService().startActivity(whoThread,who.getOpPackageName(), who.getAttributionTag(), intent,intent.resolveTypeIfNeeded(who.getContentResolver()), token,target ! null ? target.mEmbeddedID : null, requestCode, 0, null, options); // 1...} catch (RemoteException e) {.....}return null;}
}注释 1 处调用了 ActivityTaskManager.getService() 方法来获取 ATMS 的代理对象接着调用了它的 startActivity 方法。以下是 ActivityTaskManager.getService() 的相关源码
SystemService(Context.ACTIVITY_TASK_SERVICE)
public class ActivityTaskManager {public static IActivityTaskManager getService() {return IActivityTaskManagerSingleton.get();}private static final SingletonIActivityTaskManager IActivityTaskManagerSingleton new SingletonIActivityTaskManager() {Overrideprotected IActivityTaskManager create() {final IBinder b ServiceManager.getService(Context.ACTIVITY_TASK_SERVICE); // 1return IActivityTaskManager.Stub.asInterface(b); // 2}};}// /frameworks/base/core/java/android/content/Context.java
public abstract class Context {public static final String ACTIVITY_TASK_SERVICE activity_task;
}ActivityTaskManager是实现 Activity 与 ATMS 跨进程交互的接口ATMS 的辅助类。
从上述代码中可知ActivityTaskManager.getService() 调用了 IActivityTaskManagerSingleton.get() 方法IActivityTaskManagerSingleton 是一个 Singleton 类。注释 1 处得到一个名为 “activity_task” 的 Service 的引用也就是 IBinder 类型的 ATMS 的引用。
在注释 2 处将它转换成 IActivityTaskManager 类型的对象这段代码采用的 AIDLIActivityManager.java 类是由 AIDL 工具在编译时自动生成的IActivityTaskManager.aidl 的文件路径为 /frameworks/base/core/java/android/app/IActivityTaskManager.aidl。要实现进程间通信服务器端也就是 ATMS 只需要继承 IActivityTaskManager.Stub 类并实现相应的方法就可以了。IActivityTaskManager 是 ATMS 在本地的代理。
以下是相关相关源码
interface IActivityTaskManager {int startActivity(in IApplicationThread caller, in String callingPackage,in String callingFeatureId, in Intent intent, in String resolvedType,in IBinder resultTo, in String resultWho, int requestCode,int flags, in ProfilerInfo profilerInfo, in Bundle options);......
}/*** System service for managing activities and their containers(task, displays, ...)* */
public class ActivityTaskManagerService extends IActivityTaskManager.Stub {Overridepublic final int startActivity(IApplicationThread caller, String callingPackage,String callingFeatureId, Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode, int startFlags, ProfilerInfo profilerInfo, Bundle bOptions) {return startActivityAsUser(caller, callingPackage, callingFeatureId, intent, resolvedType, resultTo, resultWho, requestCode, startFlags, profilerInfo, bOptions,UserHandle.getCallingUserId());}
}ActivityTaskManagerService是管理 Activity 以及其容器task、stacks、displays的系统服务负责 Activity 管理和调度工作Android 10 中新增。ATMS 是 AMS 的一个辅助类分担了 AMS 的一部分功能继承自 IActivityTaskManager.Stub。
1.2 ATMS 到 ApplicationThread 的调用过程
Activity 请求 ATMS 后代码逻辑就就进入到 ATMS 中接着就是 ATMS 到 ApplicationThread 的调用流程时序图如下所示 ATMS.startActivity 方法会调用其 startActivityAsUser 方法在 ATMS.startActivityAsUser 方法中会调用 ATMS.getActivityStartController() 方法获取 ActivityStartController 对象
public class ActivityTaskManagerService extends IActivityTaskManager.Stub {private ActivityStartController mActivityStartController;ActivityStartController getActivityStartController() {return mActivityStartController;}private int startActivityAsUser(IApplicationThread caller, String callingPackage,Nullable String callingFeatureId, Intent intent, String resolvedType,IBinder resultTo, String resultWho, int requestCode, int startFlags,ProfilerInfo profilerInfo, Bundle bOptions, int userId, boolean validateIncomingUser) {...return getActivityStartController().obtainStarter(intent, startActivityAsUser).setCaller(caller).setCallingPackage(callingPackage).setCallingFeatureId(callingFeatureId).setResolvedType(resolvedType).setResultTo(resultTo).setResultWho(resultWho).setRequestCode(requestCode).setStartFlags(startFlags).setProfilerInfo(profilerInfo).setActivityOptions(opts).setUserId(userId).execute();}
}**ActivityStartController 是用于 Activity 启动的控制器。**通过调用其 obtainStarter 方法来获取 ActivityStarter 对象
/*** Controller for delegating activity launches. * Activity 的启动的控制器*/
public class ActivityStartController {/*** 返回一个启动器来配置和执行 Activity 的启动*/ActivityStarter obtainStarter(Intent intent, String reason) {return mFactory.obtain().setIntent(intent).setReason(reason);}}ActivityStarter 是 Android 7.0 中新加入的类是 Activity 的控制器讲如何启动一个 Activity会收集所有的逻辑来决定如何将 Intent 和 Flags 转换为 Activity并将 Activity 和 Task 以及 Stack 相关联。
/*** Controller for interpreting how and then launching an activity.* * This class collects all the logic for determining how an intent and flags should be * turned into an activity and associated task and root task.*/
class ActivityStarter {}Task 就是用户在执行某项工作时与之相关联的 Activity 集合。系统通过任务栈来管理这些 Activity它们按照打开的顺序进入任务栈中。这些 Activity 可以来自同一个 APP也可以来自不同的 APPActivity 之间不一定非要有关联。
当按 Home 键旁边的那个方形键recent-apps时屏幕上展示的就是一个个的 Task。
/*** {link Task} is a TaskFragment that can contain a group of activities to perform a certain * job. Task 是 TaskFragment 的子类可以包含执行某个任务的一组 activities。* * Activities of the same task affinities usually group in the same {link Task}. * 具有相同的 task affinities 的 activities 通常分在同一个 Task 中* * A {link Task} can also be an entity that showing in the Recents Screen for a job that * user interacted with.* 按下 Home 键旁边的那个方形键recent-apps时屏幕上展示的就是一个个的 Task* * A {link Task} can also contain other {link Task}s.* 一个 Task 也可以包含其他的 Task*/
class Task extends TaskFragment {}/*** A basic container that can be used to contain activities or other {link TaskFragment}, * which also able to manage the activity lifecycle and updates the visibilities of the * activities in it.* 一个容器可以用来放 activities 或者其它的 TaskFragment也能够管理 activity 的生命周期或者更新* activities 的可见性。*/
class TaskFragment extends WindowContainerWindowContainer {}task affinity在 manifest 文件中注册 activity 时如果不申明 taskAffinity 属性就是 APP 程序的默认包名默认情况下一个 APP 中所有的 Activity 都在一个 Task 中
activityandroid:taskAffinity...
/启动根 Activity 时会将 Intent 的 Flag 设置为 FLAG_ACTIVITY_NEW_TASK表示要创建一个新的 Task
class ActivityStarter {private Task mTargetRootTask;private final RootWindowContainer mRootWindowContainer;private Task computeTargetTask() {if (mStartActivity.resultTo null mInTask null !mAddingToTask (mLaunchFlags FLAG_ACTIVITY_NEW_TASK) ! 0) { // 1// A new task should be created instead of using existing one.return null;} else if (mSourceRecord ! null) {return mSourceRecord.getTask();} else if (mInTask ! null) {if (!mInTask.isAttached()) {getOrCreateRootTask(mStartActivity, mLaunchFlags, mInTask, mOptions);}return mInTask;} else {final Task rootTask getOrCreateRootTask(mStartActivity, mLaunchFlags, null /* task */, mOptions);final ActivityRecord top rootTask.getTopNonFinishingActivity();if (top ! null) {return top.getTask();} else {rootTask.removeIfPossible(computeTargetTask);}}return null;}private void setNewTask(Task taskToAffiliate) {final boolean toTop !mLaunchTaskBehind !mAvoidMoveToFront;final Task task mTargetRootTask.reuseOrCreateTask(mStartActivity.info, mIntent, mVoiceSession,mVoiceInteractor, toTop, mStartActivity, mSourceRecord, mOptions);task.mTransitionController.collectExistenceChange(task);addOrReparentStartingActivity(task, setTaskFromReuseOrCreateNewTask);ProtoLog.v(WM_DEBUG_TASKS, Starting new activity %s in new task %s,mStartActivity, mStartActivity.getTask());if (taskToAffiliate ! null) {mStartActivity.setTaskToAffiliateWith(taskToAffiliate);}}int startActivityInner(final ActivityRecord r, ActivityRecord sourceRecord,IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,int startFlags, boolean doResume, ActivityOptions options, Task inTask,TaskFragment inTaskFragment, BalCode int balCode,NeededUriGrants intentGrants) {...// Compute if there is an existing task that should be used for.final Task targetTask reusedTask ! null ? reusedTask : computeTargetTask(); // 2final boolean newTask targetTask null; // 3mTargetTask targetTask;...if (newTask) { // 4final Task taskToAffiliate (mLaunchTaskBehind mSourceRecord ! null)? mSourceRecord.getTask() : null;setNewTask(taskToAffiliate); // 5} else if (mAddingToTask) {addOrReparentStartingActivity(targetTask, adding to task);}...final boolean isTaskSwitch startedTask ! prevTopTask !startedTask.isEmbedded();mTargetRootTask.startActivityLocked(mStartActivity, topRootTask, newTask, isTaskSwitch, mOptions, sourceRecord); // 6if (mDoResume) {...} else {...mRootWindowContainer.resumeFocusedTasksTopActivities(mTargetRootTask, mStartActivity, mOptions, mTransientLaunch); // 7}}...return START_SUCCESS;}}如果注释 4 处的条件满足表示需要创建一个新的 Task。在注释 6 处调用的是 Task.startActivityLocked 方法注释 7 处调用的是 RootWindowContainer.resumeFocusedTasksTopActivities 方法。
RootWindowContainer 表示窗口容器的根容器是整个屏幕最顶层的容器。
/** * Root {link WindowContainer} for the device. * 设备的根*/
class RootWindowContainer extends WindowContainerDisplayContentimplements DisplayManager.DisplayListener {}ActivityRecord记录 Activity 的信息TaskRecord记录 Task 的信息ActivityStack栈信息
class Task extends TaskFragment {private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options, boolean deferPause) {...// 1final ActivityRecord topActivity topRunningActivity(true /* focusableOnly */); if (topActivity null) {// There are no activities left in this task, lets look somewhere else.return resumeNextFocusableActivityWhenRootTaskIsEmpty(prev, options);}final boolean[] resumed new boolean[1];final TaskFragment topFragment topActivity.getTaskFragment();resumed[0] topFragment.resumeTopActivity(prev, options, deferPause);...return resumed[0];}ActivityRecord topRunningActivity(IBinder token, int taskId) {final PooledPredicate p PooledLambda.obtainPredicate(Task::isTopRunning,PooledLambda.__(ActivityRecord.class), taskId, token);final ActivityRecord r getActivity(p);p.recycle();return r;}}注释 1 处调用 topRunningActivity 方法获取栈顶不是处于停止状态的 ActivityRecord此处的栈指的是要启动的 Activity 所在的栈。
从注释上来看ActivityTaskSupervisor翻译过来是“活动任务主管”从注释中可以看出这个类已经变成了垃圾倾倒场页面层级相关的代码移动到 RootWindowContainer 中与 Activity 生命周期相关的移动到 ActivityLifeCycler 中接口相关的代码移动到 ATMS 中等等。
从功能上来看可以理解成 ActivityTaskSupervisor 是用来辅助 ATMS 来对 Activity 和 Task 进行管理的。
// TODO: This class has become a dumping ground. Lets
// 这个类已经变成了垃圾请倒场
// - Move things relating to the hierarchy to RootWindowContainer
// - 把与层级相关的代码移动到 RootWindowContainer 中
// - Move things relating to activity life cycles to maybe a new class called ActivityLifeCycler
// - 与 Activity 生命周期相关的代码移动到 ActivityLifeCycler 中
// - Move interface things to ActivityTaskManagerService.
// - 接口相关的移动到 ActivityTaskManagerService 中
// - All other little things to other files.
public class ActivityTaskSupervisor implements RecentTasks.Callbacks {final ActivityTaskManagerService mService;void startSpecificActivity(ActivityRecord r, boolean andResume, boolean checkConfig) {// 1 Is this activitys application already running?final WindowProcessController wpc mService.getProcessController(r.processName, r.info.applicationInfo.uid);boolean knownToBeDead false;if (wpc ! null wpc.hasThread()) {try {realStartActivityLocked(r, wpc, andResume, checkConfig); // 2return;} catch (RemoteException e) {Slog.w(TAG, Exception when starting activity r.intent.getComponent().flattenToShortString(), e);}...}r.notifyUnknownVisibilityLaunchedForKeyguardTransition();final boolean isTop andResume r.isTopRunningActivity();mService.startProcessAsync(r, knownToBeDead, isTop,isTop ? HostingRecord.HOSTING_TYPE_TOP_ACTIVITY: HostingRecord.HOSTING_TYPE_ACTIVITY); // 3}
}注释 1 处的来判断当前的 Activity 所在的应用程序进程是否存在如果存在则调用注释 2 处的 realStartActivityLocked 方法继续 Activity 的启动流程如果不存在在调用注释 3 处 ATMS.startProcessAsync 方法创建进程。
/*** The Activity Manager (AM) package manages the lifecycle of processes in the system through* ProcessRecord. Activity ManagerAM包通过 ProcessRecord 来管理系统中进程的生命周期* * However, it is important for the Window Manager (WM) package to be aware* of the processes and their state since it affects how WM manages windows and activities. * 但是对于 Window ManagerWM包来说了解进程以及其状态是十分重要的因为它会影响 Window Manager 管* 理 windows 和 activities 的方式 * * This class that allows the ProcessRecord object in the AM package to communicate important* changes to its state to the WM package in a structured way. * 这个类允许 ProcessRecord 对象以结构化的方式将其状态的重要改变传到给 WM 包* * WM package also uses {link WindowProcessListener} to request changes to the process state * on the AM side.* WM 包也使用 WindowProcessListener 来请求更改 AM 端的进程状态* * Note that public calls into this class are assumed to be originating from outside the* window manager so the window manager lock is held and appropriate permissions are checked * before calls are allowed to proceed.* 请注意假定对该类的公共调用来自窗口管理器的外部因此将该持有窗口管理器锁并在允许调用继续进行之前检查适当* 的权限。*/
public class WindowProcessController extends ConfigurationContainerConfigurationContainerimplements ConfigurationContainerListener {private IApplicationThread mThread;IApplicationThread getThread() {return mThread;}boolean hasThread() {return mThread ! null;}}在 ActivityTaskSupervisor.realStartActivityLocked 方法中会调用 mService.getLifecycleManager().scheduleTransaction(clientTransaction);这里的 mService 是 ATMS。
**在 ActivityTaskManagerService 中初始化了 ClientLifecycleManager客户端事务管理类的唯一实例因此所有的有关事务的操作都必须通过 ATMS 实例来发起。**以下是 ATMS 中的 ClientLifecycleManager 的相关初始化与获取操作
public class ActivityTaskManagerService extends IActivityTaskManager.Stub {private final ClientLifecycleManager mLifecycleManager;public ActivityTaskManagerService(Context context) {...mLifecycleManager new ClientLifecycleManager();...}ClientLifecycleManager getLifecycleManager() {return mLifecycleManager;}
}public class ActivityTaskSupervisor implements RecentTasks.Callbacks {final ActivityTaskManagerService mService;boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,boolean andResume, boolean checkConfig) throws RemoteException {...mService.getLifecycleManager().scheduleTransaction(clientTransaction); // 2}
}ClientLifecycleManager客户端事务管理类能够组合多个客户端生命周期转换事务的请求和/或回调并把它们作为单个事务执行。
/*** Class that is able to combine multiple client lifecycle transition requests * and/or callbacks, and execute them as a single transaction.* * 客户端事务管理类能够组合多个客户端生命周期转换事务的请求和/或回调并把它们作为单个事务执行* * see ClientTransaction*/
class ClientLifecycleManager {/*** Schedule a transaction, which may consist of multiple callbacks and a lifecycle * request. * 调度一个事务它可能由多个回调和一个生命周期请求组成** see ClientTransaction*/void scheduleTransaction(ClientTransaction transaction) throws RemoteException { // 1final IApplicationThread client transaction.getClient();transaction.schedule(); // 2if (!(client instanceof Binder)) {transaction.recycle();}}/*** Schedule a single lifecycle request or callback to client activity.* * param client Target client.* param activityToken Target activity token.* param stateRequest A request to move target activity to a desired lifecycle state.* throws RemoteException** see ClientTransactionItem*/void scheduleTransaction(NonNull IApplicationThread client, NonNull IBinder activityToken,NonNull ActivityLifecycleItem stateRequest) throws RemoteException { // 3final ClientTransaction clientTransaction transactionWithState(client, activityToken, stateRequest);scheduleTransaction(clientTransaction);}/*** Schedule a single callback delivery to client activity.* param client Target client.* param activityToken Target activity token.* param callback A request to deliver a callback.* throws RemoteException** see ClientTransactionItem*/void scheduleTransaction(NonNull IApplicationThread client,NonNull IBinder activityToken,NonNull ClientTransactionItem callback) throws RemoteException { // 4final ClientTransaction clientTransaction transactionWithCallback(client, activityToken, callback);scheduleTransaction(clientTransaction);}/*** Schedule a single callback delivery to client application.* param client Target client.* param callback A request to deliver a callback.* throws RemoteException** see ClientTransactionItem*/void scheduleTransaction(NonNull IApplicationThread client,NonNull ClientTransactionItem callback) throws RemoteException { // 5final ClientTransaction clientTransaction transactionWithCallback(client,null /* activityToken */, callback);scheduleTransaction(clientTransaction);}/*** return A new instance of {link ClientTransaction} with a single lifecycle state * request.** see ClientTransaction* see ClientTransactionItem*/private static ClientTransaction transactionWithState(NonNull IApplicationThread client,NonNull IBinder activityToken, NonNull ActivityLifecycleItem stateRequest) { // 6final ClientTransaction clientTransaction ClientTransaction.obtain(client, activityToken);clientTransaction.setLifecycleStateRequest(stateRequest);return clientTransaction;}/*** return A new instance of {link ClientTransaction} with a single callback invocation.** see ClientTransaction* see ClientTransactionItem*/private static ClientTransaction transactionWithCallback(NonNull IApplicationThread client,IBinder activityToken, NonNull ClientTransactionItem callback) { // 7final ClientTransaction clientTransaction ClientTransaction.obtain(client, activityToken);clientTransaction.addCallback(callback);return clientTransaction;}
}从上面的代码中可以看出ClientLifecycleManager 对外暴露了 3 种事务调度的方法一是直接调度客户端事务集 ClientTransaction注释 1二是调度生命周期事务 ActivityLifecycleItem注释 3三是调度客户端事务 ClientTransactionItem注释 4实际上无论是生命周期事务 ActivityLifecycleItem 还是客户端事务 ClientTransactionItem 都被封装成 ClientTransaction 客户端事务集的形式因此这个类中的核心方法就是 scheduleTransaction(ClientTransaction) 在这个方法中传入 ClientTransation 类型的参数并调用它的 schedule() 方法做进一步处理注释 2。
ClientTransaction 事务类集一个事务集可以存放一系列的事务ClientTransactionItem以及一个生命周期事务ActivityLifecycleItem。
public class ClientTransaction implements Parcelable, ObjectPoolItem {/** A list of individual callbacks to a client. */UnsupportedAppUsageprivate ListClientTransactionItem mActivityCallbacks; // 1/*** Final lifecycle state in which the client activity should be after the transaction is* executed.*/private ActivityLifecycleItem mLifecycleStateRequest; // 2/** Target client. */private IApplicationThread mClient;/** Get the target client of the transaction. */public IApplicationThread getClient() {return mClient;}/*** Add a message to the end of the sequence of callbacks.* param activityCallback A single message that can contain a lifecycle * request/callback.*/public void addCallback(ClientTransactionItem activityCallback) {if (mActivityCallbacks null) {mActivityCallbacks new ArrayList();}mActivityCallbacks.add(activityCallback);}public void schedule() throws RemoteException {mClient.scheduleTransaction(this);}...
}ClientTransactionItem 客户端事务是一个抽象类ActivityLifecycleItem 是它的一个子类
public abstract class ClientTransactionItem implements BaseClientRequest, Parcelable {/** Get the state that must follow this callback. */LifecycleStatepublic int getPostExecutionState() {return UNDEFINED;}// ParcelableOverridepublic int describeContents() {return 0;}
}/*** Request to launch an activity.* hide*/
public class LaunchActivityItem extends ClientTransactionItem { }public abstract class ActivityTransactionItem extends ClientTransactionItem { }
public abstract class ActivityLifecycleItem extends ActivityTransactionItem { }public class ResumeActivityItem extends ActivityLifecycleItem { }
public class PauseActivityItem extends ActivityLifecycleItem { }
public class StopActivityItem extends ActivityLifecycleItem { }
public class DestroyActivityItem extends ActivityLifecycleItem { }
public class ActivityRelaunchItem extends ActivityTransactionItem { }ActivityLifecycleItem 是 Activity 生命周期事务类其子类有 ResumeActivityItem、PauseActivityItem、StopActivityItem、DestroyActivityItem表示具体的 Activity 的生命周期转换事务。
LaunchActivityItem 请求启动一个 ActivityActivityRelaunchItem 重启 Activity 的回调。
对于 ClientTransaction.schedule() 方法
public class ClientTransaction implements Parcelable, ObjectPoolItem {/** Target client. */private IApplicationThread mClient; // 1public void schedule() throws RemoteException {mClient.scheduleTransaction(this); // 2}}注释 1 处的 mClient 指的是 IApplicationThread它的实现类是 ActivityThread 的内部类 ApplicationThread。ApplicationThread 继承了 IApplicationThread.Stub。当前代码运行在 ATMS 所在的进程system_server中通过 IApplicationThread 与应用程序进程来进行 Binder 通信换句话说 IApplicationThread 是 ATMS 所在的进程system_server和应用程序进程的通信桥梁。
1.3 ActivityThread 启动 Activity 的过程 目前的代码已经是运行在应用程序进程中了。
public final class ActivityThread extends ClientTransactionHandler // 3implements ActivityThreadInternal {private class ApplicationThread extends IApplicationThread.Stub { // 1Overridepublic void scheduleTransaction(ClientTransaction transaction) throws RemoteException {ActivityThread.this.scheduleTransaction(transaction); // 2}}
}从注释 1 处可知ApplicationThread 是 ActivityThread 的内部类也是 IApplicationThread 的实现类。注释 2 处 调用了 ActivityThread.this.scheduleTransaction 方法。从注释 3 处可以知道 ActivityThread 是 ClientTransactionHandler 的实现类ClientTransactionHandler.scheduleTransaction 方法如下所示
/*** Defines operations that a {link android.app.servertransaction.ClientTransaction} or its * items can perform on client.* 定义了 ClientTransaction 或其 items 可以在客户端执行的操作* hide*/
public abstract class ClientTransactionHandler {// Schedule phase related logic and handlers./** Prepare and schedule transaction for execution. */void scheduleTransaction(ClientTransaction transaction) {transaction.preExecute(this);sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);}abstract void sendMessage(int what, Object obj);
}对于抽象方法 sendMessage在 ActivityThread 中有实现
public final class ActivityThread extends ClientTransactionHandlerimplements ActivityThreadInternal {final H mH new H();void sendMessage(int what, Object obj) {sendMessage(what, obj, 0, 0, false); }private void sendMessage(int what, Object obj, int arg1, int arg2, boolean async) {Message msg Message.obtain();msg.what what;msg.obj obj;msg.arg1 arg1;msg.arg2 arg2;if (async) {msg.setAsynchronous(true);}mH.sendMessage(msg);}}最终调用的是 mH.sendMessage 方法mH 是 H 类型的对象H 是 ActivityThread 的内部类也是 Handler 的子类
public final class ActivityThread extends ClientTransactionHandlerimplements ActivityThreadInternal {class H extends Handler { }
}对于 ActivityThread.H.EXECUTE_TRANSACTION 消息的处理
public final class ActivityThread extends ClientTransactionHandlerimplements ActivityThreadInternal {class H extends Handler {public void handleMessage(Message msg) {case EXECUTE_TRANSACTION:final ClientTransaction transaction (ClientTransaction) msg.obj;mTransactionExecutor.execute(transaction); // 1if (isSystem()) {// Client transactions inside system process are recycled on the client side// instead of ClientLifecycleManager to avoid being cleared before this// message is handled.transaction.recycle();}// TODO(lifecycler): Recycle locally scheduled transactions.break;}}
}注释 1 处调用了 TransactionExecutor.execute 方法。
ClientTransactionHandler定义了客户端事务或其 Item 可以在客户端执行的操作封装了 handleXXXActivity 方法其实现类 ActivityThread 也会继承这些方法。
/*** Defines operations that a {link android.app.servertransaction.ClientTransaction} or its * items can perform on client.* 定义了 ClientTransaction 或其 items 可以在客户端执行的操作* hide*/
public abstract class ClientTransactionHandler {public abstract Activity handleLaunchActivity(NonNull ActivityClientRecord r,PendingTransactionActions pendingActions, Intent customIntent);/** Perform activity launch. */public abstract Activity handleLaunchActivity(NonNull ActivityClientRecord r,PendingTransactionActions pendingActions, Intent customIntent);/** Perform activity start. */public abstract void handleStartActivity(NonNull ActivityClientRecord r,PendingTransactionActions pendingActions, ActivityOptions activityOptions);/** Resume the activity. */public abstract void handleResumeActivity(NonNull ActivityClientRecord r,boolean finalStateRequest, boolean isForward, String reason);/** Pause the activity. */public abstract void handlePauseActivity(NonNull ActivityClientRecord r, boolean finished, boolean userLeaving, int configChanges, PendingTransactionActions pendingActions, String reason);/** Stop the activity. */public abstract void handleStopActivity(NonNull ActivityClientRecord r, int configChanges, PendingTransactionActions pendingActions, boolean finalStateRequest, String reason);public abstract void handleDestroyActivity(NonNull ActivityClientRecord r, boolean finishing, int configChanges, boolean getNonConfigInstance, String reason);public abstract void handleRelaunchActivity(NonNull ActivityClientRecord r,PendingTransactionActions pendingActions);
}TransactionExecutor事务执行器让事务按正确顺序执行的类。TransactionExecutor 持有 ClientTransactionHandler 对象在其构造函数中作为参数传入ClientTransactionHandler 才是任务的真正执行者。
/*** Class that manages transaction execution in the correct order.* hide*/
public class TransactionExecutor {private ClientTransactionHandler mTransactionHandler;/** Initialize an instance with transaction handler, that will execute all requested actions. */public TransactionExecutor(ClientTransactionHandler clientTransactionHandler) {mTransactionHandler clientTransactionHandler;}}回到 TransactionExecutor.execute 方法中
public class TransactionExecutor {public void execute(ClientTransaction transaction) {...executeCallbacks(transaction); // 1executeLifecycleState(transaction);...}VisibleForTestingpublic void executeCallbacks(ClientTransaction transaction) {final ListClientTransactionItem callbacks transaction.getCallbacks();if (callbacks null || callbacks.isEmpty()) {// No callbacks to execute, return early.return;}...final int size callbacks.size();for (int i 0; i size; i) {final ClientTransactionItem item callbacks.get(i); // 2...final int postExecutionState item.getPostExecutionState();final int closestPreExecutionState mHelper.getClosestPreExecutionState(r,item.getPostExecutionState());if (closestPreExecutionState ! UNDEFINED) {cycleToPath(r, closestPreExecutionState, transaction);}item.execute(mTransactionHandler, token, mPendingActions); // 3item.postExecute(mTransactionHandler, token, mPendingActions);...}}
} 注释 3 处调用了 ClientTransactionItem.execute 方法对于启动一个 Activity此处的 ClientTransactionItem 是其子类 LaunchActivityItem请求启动一个 Activity。
/*** Request to launch an activity.* hide*/
public class LaunchActivityItem extends ClientTransactionItem {}public abstract class ClientTransactionItem implements BaseClientRequest, Parcelable {}BaseClientRequest事务的抽象类定义了 preExecute、execute、postExecute 三个接口分别代表事务执行前、执行中、执行后三个阶段的回调方法。
public interface BaseClientRequest extends ObjectPoolItem {/*** Prepare the client request before scheduling.* An example of this might be informing about pending updates for some values.** param client Target client handler.* param token Target activity token.*/default void preExecute(ClientTransactionHandler client, IBinder token) {}/*** Execute the request.* param client Target client handler.* param token Target activity token.* param pendingActions Container that may have data pending to be used.*/void execute(ClientTransactionHandler client, IBinder token,PendingTransactionActions pendingActions);/*** Perform all actions that need to happen after execution, e.g. report the result to server.* param client Target client handler.* param token Target activity token.* param pendingActions Container that may have data pending to be used.*/default void postExecute(ClientTransactionHandler client, IBinder token,PendingTransactionActions pendingActions) {}
}LaunchActivityItem 重写了 execute 方法
public class LaunchActivityItem extends ClientTransactionItem {Overridepublic void execute(ClientTransactionHandler client, IBinder token,PendingTransactionActions pendingActions) {Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, activityStart);ActivityClientRecord r new ActivityClientRecord(token, mIntent, mIdent, mInfo,mOverrideConfig, mCompatInfo, mReferrer, mVoiceInteractor, mState, mPersistentState, mPendingResults, mPendingNewIntents, mActivityOptions, mIsForward, mProfilerInfo, client, mAssistToken, mShareableActivityToken, mLaunchedFromBubble, mTaskFragmentToken);client.handleLaunchActivity(r, pendingActions, null /* customIntent */); // 1Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);}}注释 1 处的 client 的类型是 ClientTransactionHandlerActivityThread 继承了 ClientTransactionHandler是事务的真正执行者。
public final class ActivityThread extends ClientTransactionHandlerimplements ActivityThreadInternal {Overridepublic Activity handleLaunchActivity(ActivityClientRecord r,PendingTransactionActions pendingActions, Intent customIntent) {...final Activity a performLaunchActivity(r, customIntent);...return a;}}2 根 Activity 的启动过程
根 Activity 的启动流程可以分为以下 3 部分
Launcher 请求 ActivityTaskManagerService(ATMS) 的过程ATMS 到 ApplicationThread 的调用过程ActivityThread 启动 Activity
2.1 Launcher 请求 ATMS 过程
Launcher 启动后会将已安装的应用程序的快捷图标显示到桌面上这些应用程序的快捷图标就是启动根 Activity 的入口。当我们点击某个应用题程序的快捷图标时就会通过 Launcher 请求 ATMS 来启动应用程序。
以下是 Launcher 请求 ATMS 的时序图 点击应用程序的快捷图标时就会调用 Launcher.startActivitySafely 方法
// /packages/apps/Launcher3/src/com/android/launcher3/Launcher.java
public class Launcher extends StatefulActivityLauncherStateimplements LauncherExterns, Callbacks, InvariantDeviceProfile.OnIDPChangeListener,PluginListenerLauncherOverlayPlugin {public boolean startActivitySafely(View v, Intent intent, ItemInfo item,Nullable String sourceContainer) {...boolean success super.startActivitySafely(v, intent, item, sourceContainer); // 1...}
}public abstract class StatefulActivitySTATE_TYPE extends BaseStateSTATE_TYPEextends BaseDraggingActivity {}public abstract class BaseDraggingActivity extends BaseActivityimplements OnColorsChangedListener, DisplayInfoChangeListener {}public abstract class BaseActivity extends Activity implements ActivityContext {}注释 1 处调用的是 super.startActivitySafely 方法这里的 super由继承关系可以知道调用的是 ActivityContext.startActivitySafely 方法
// packages/apps/Launcher3/src/com/android/launcher3/views/ActivityContext.java
public interface ActivityContext {default boolean startActivitySafely(View v, Intent intent, Nullable ItemInfo item) {...// Prepare intentintent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); // 1if (v ! null) {intent.setSourceBounds(Utilities.getViewBounds(v));}try {boolean isShortcut (item instanceof WorkspaceItemInfo) (item.itemType LauncherSettings.Favorites.ITEM_TYPE_SHORTCUT|| item.itemType LauncherSettings.Favorites.ITEM_TYPE_DEEP_SHORTCUT) !((WorkspaceItemInfo) item).isPromise();if (isShortcut) {// Shortcuts need some special checks due to legacy reasons.startShortcutIntentSafely(intent, optsBundle, item);} else if (user null || user.equals(Process.myUserHandle())) {// Could be launching some bookkeeping activitycontext.startActivity(intent, optsBundle); // 2} else {context.getSystemService(LauncherApps.class).startMainActivity(intent.getComponent(), user, intent.getSourceBounds(), optsBundle);}...return true;} catch (NullPointerException | ActivityNotFoundException | SecurityException e) {...}return false;}
}注释 1 处将 Flag 设置为 Intent.FLAG_ACTIVITY_NEW_TASK这样根 Activity 会在新的任务栈中启动在注释 2 处调用了 Context.startActivity 方法Context 是抽象类其中定义了抽象方法 startActivity在其子类 Activity 中实现
// frameworks/base/core/java/android/content/Context.java
public abstract class Context {public abstract void startActivity(RequiresPermission Intent intent,Nullable Bundle options);
}// frameworks/base/core/java/android/content/ContextWrapper.java
public class ContextWrapper extends Context {}// frameworks/base/core/java/android/content/ContextWrapper.java
public class ContextThemeWrapper extends ContextWrapper {}// frameworks/base/core/java/android/app/Activity.java
public class Activity extends ContextThemeWrapperimplements LayoutInflater.Factory2,Window.Callback, KeyEvent.Callback,OnCreateContextMenuListener, ComponentCallbacks2,Window.OnWindowDismissedCallback,ContentCaptureManager.ContentCaptureClient {Overridepublic void startActivity(Intent intent, Nullable Bundle options) {getAutofillClientController().onStartActivity(intent, mIntent);if (options ! null) {startActivityForResult(intent, -1, options);} else {// Note we want to go through this call for compatibility with// applications that may have overridden the method.startActivityForResult(intent, -1);}}}2.2 ATMS 到 ApplicationThread 的调用过程
Launcher 请求 ATMS 后代码逻辑已经进入到 ATMS 中接着是 ATMS 到 ApplicationThread 的调用流程 ActivityStackSupervisor.startSpecificActivityLocked 方法代码如下所示
// /frameworks/base/services/core/java/com/android/server/wm/ActivityStackSupervisor.java
// TODO: This class has become a dumping ground. Lets
// 这个类已经变成了垃圾请倒场
// - Move things relating to the hierarchy to RootWindowContainer
// - 把与层级相关的代码移动到 RootWindowContainer 中
// - Move things relating to activity life cycles to maybe a new class called ActivityLifeCycler
// - 与 Activity 生命周期相关的代码移动到 ActivityLifeCycler 中
// - Move interface things to ActivityTaskManagerService.
// - 接口相关的移动到 ActivityTaskManagerService 中
// - All other little things to other files.
public class ActivityTaskSupervisor implements RecentTasks.Callbacks {final ActivityTaskManagerService mService;void startSpecificActivity(ActivityRecord r, boolean andResume, boolean checkConfig) {// Is this activitys application already running?final WindowProcessController wpc mService.getProcessController(r.processName, r.info.applicationInfo.uid);boolean knownToBeDead false;if (wpc ! null wpc.hasThread()) {try {realStartActivityLocked(r, wpc, andResume, checkConfig); return;} catch (RemoteException e) {Slog.w(TAG, Exception when starting activity r.intent.getComponent().flattenToShortString(), e);}...}r.notifyUnknownVisibilityLaunchedForKeyguardTransition();final boolean isTop andResume r.isTopRunningActivity();mService.startProcessAsync(r, knownToBeDead, isTop,isTop ? HostingRecord.HOSTING_TYPE_TOP_ACTIVITY: HostingRecord.HOSTING_TYPE_ACTIVITY); // 1}
}注释 1 处调用 ATMS.startProcessAsync 方法用来创建新的进程。Zygote 进程收到请求后fork 出新的进程并调用 ActivityThread.main 方法。 以下是 ActivityTaskManagerService.startProcessAsync 方法的相关源码
// frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
public class ActivityTaskManagerService extends IActivityTaskManager.Stub {void startProcessAsync(ActivityRecord activity, boolean knownToBeDead, boolean isTop,String hostingType) {try {if (Trace.isTagEnabled(TRACE_TAG_WINDOW_MANAGER)) {Trace.traceBegin(TRACE_TAG_WINDOW_MANAGER, dispatchingStartProcess: activity.processName);}// Post message to start process to avoid possible deadlock of calling into AMS // with the ATMS lock held.final Message m PooledLambda.obtainMessage(ActivityManagerInternal::startProcess,mAmInternal, activity.processName, activity.info.applicationInfo, knownToBeDead, isTop, hostingType, activity.intent.getComponent()); // 1mH.sendMessage(m);} finally {Trace.traceEnd(TRACE_TAG_WINDOW_MANAGER);}}}ActivityManagerInternal.startProcess 方法是请求启动应用进程的起点。 注释 1 处的 PooledLambda.obtainMessage 获取一个 Message并为其指定 Callback。
// frameworks/base/core/java/com/android/internal/util/function/pooled/PooledLambda.java
public interface PooledLambda {static A, B, C, D, E, F, G Message obtainMessage(HeptConsumer? super A, ? super B, ? super C, ? super D, ? super E, ? super F,? super G function, A arg1, B arg2, C arg3, D arg4, E arg5, F arg6, G arg7) {synchronized (Message.sPoolSync) {PooledRunnable callback acquire(PooledLambdaImpl.sMessageCallbacksPool,function, 7, 0, ReturnType.VOID, arg1, arg2, arg3, arg4, arg5, arg6, arg7, null, null, null, null, null);return Message.obtain().setCallback(callback.recycleOnUse());}} ActivityManagerInternal 是抽象类其实现类是 ActivityManagerService 的内部类 LocalService
// frameworks/base/core/java/android/app/ActivityManagerInternal.java
public abstract class ActivityManagerInternal {public abstract void startProcess(String processName, ApplicationInfo info,boolean knownToBeDead, boolean isTop, String hostingType, ComponentName hostingName);
}// frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
public class ActivityManagerService extends IActivityManager.Stubimplements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback, ActivityManagerGlobalLock {public final class LocalService extends ActivityManagerInternalimplements ActivityManagerLocal {Overridepublic void startProcess(String processName, ApplicationInfo info, boolean knownToBeDead, boolean isTop, String hostingType, ComponentName hostingName) {try {if (Trace.isTagEnabled(Trace.TRACE_TAG_ACTIVITY_MANAGER)) {Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, startProcess: processName);}synchronized (ActivityManagerService.this) {// If the process is known as top app, set a hint so when the process is// started, the top priority can be applied immediately to avoid cpu // being// preempted by other processes before attaching the process of top app.startProcessLocked(processName, info, knownToBeDead, 0 /* intentFlags */,new HostingRecord(hostingType, hostingName, isTop),ZYGOTE_POLICY_FLAG_LATENCY_SENSITIVE, false /* allowWhileBooting */, false /* isolated */);}} finally {Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);}}}final ProcessRecord startProcessLocked(String processName,ApplicationInfo info, boolean knownToBeDead, int intentFlags,HostingRecord hostingRecord, int zygotePolicyFlags, boolean allowWhileBooting,boolean isolated) {return mProcessList.startProcessLocked(processName, info, knownToBeDead, intentFlags,hostingRecord, zygotePolicyFlags, allowWhileBooting, isolated, 0 /* isolatedUid */, false /* isSdkSandbox */, 0 /* sdkSandboxClientAppUid */, null /* sdkSandboxClientAppPackage */,null /* ABI override */, null /* entryPoint */,null /* entryPointArgs */, null /* crashHandler */);}}以下是 ZygoteProcess.startViaZygote 方法的相关源码
// frameworks/base/core/java/android/os/ZygoteProcess.java
public class ZygoteProcess {private Process.ProcessStartResult startViaZygote(NonNull final String processClass,Nullable final String niceName,final int uid, final int gid,Nullable final int[] gids,int runtimeFlags, int mountExternal,int targetSdkVersion,Nullable String seInfo,NonNull String abi,Nullable String instructionSet,Nullable String appDataDir,Nullable String invokeWith,boolean startChildZygote,Nullable String packageName,int zygotePolicyFlags,boolean isTopApp,Nullable long[] disabledCompatChanges,Nullable MapString, PairString, LongpkgDataInfoMap,Nullable MapString, PairString, LongallowlistedDataInfoList,boolean bindMountAppsData,boolean bindMountAppStorageDirs,Nullable String[] extraArgs)throws ZygoteStartFailedEx {...synchronized(mLock) {// The USAP pool can not be used if the application will not use the systems // graphics driver. // If that driver is requested use the Zygote application start path.return zygoteSendArgsAndGetResult(openZygoteSocketIfNeeded(abi),zygotePolicyFlags,argsForZygote); // 1}}
}注释 1 处调用 openZygoteSocketIfNeeded 方法建立与 Zygote 进程的 Socket 连接并返回一个 ZygoteState 对象
// frameworks/base/core/java/android/os/ZygoteProcess.java
public class ZygoteProcess {private ZygoteState openZygoteSocketIfNeeded(String abi) throws ZygoteStartFailedEx {try {attemptConnectionToPrimaryZygote();if (primaryZygoteState.matches(abi)) {return primaryZygoteState;}if (mZygoteSecondarySocketAddress ! null) {// The primary zygote didnt match. Try the secondary.attemptConnectionToSecondaryZygote();if (secondaryZygoteState.matches(abi)) {return secondaryZygoteState;}}} catch (IOException ioe) {throw new ZygoteStartFailedEx(Error connecting to zygote, ioe);}throw new ZygoteStartFailedEx(Unsupported zygote ABI: abi);}private void attemptConnectionToPrimaryZygote() throws IOException {if (primaryZygoteState null || primaryZygoteState.isClosed()) {primaryZygoteState ZygoteState.connect(mZygoteSocketAddress, mUsapPoolSocketAddress);maybeSetApiDenylistExemptions(primaryZygoteState, false);maybeSetHiddenApiAccessLogSampleRate(primaryZygoteState);}}}ZygoteState 是 ZygoteProcess 的内部类
// frameworks/base/core/java/android/os/ZygoteProcess.java
public class ZygoteProcess {private static class ZygoteState implements AutoCloseable {static ZygoteState connect(NonNull LocalSocketAddress zygoteSocketAddress,Nullable LocalSocketAddress usapSocketAddress)throws IOException {DataInputStream zygoteInputStream;BufferedWriter zygoteOutputWriter;final LocalSocket zygoteSessionSocket new LocalSocket();if (zygoteSocketAddress null) {throw new IllegalArgumentException(zygoteSocketAddress cant be null);}try {zygoteSessionSocket.connect(zygoteSocketAddress); // 1zygoteInputStream new DataInputStream(zygoteSessionSocket.getInputStream());zygoteOutputWriter new BufferedWriter(new OutputStreamWriter(zygoteSessionSocket.getOutputStream()),Zygote.SOCKET_BUFFER_SIZE);} catch (IOException ex) {try {zygoteSessionSocket.close();} catch (IOException ignore) { }throw ex;}return new ZygoteState(zygoteSocketAddress, usapSocketAddress,zygoteSessionSocket, zygoteInputStream, zygoteOutputWriter,getAbiList(zygoteOutputWriter, zygoteInputStream));}}}注释 1 处调用的是 LocalSocket.connect 方法。LocalSocket 是客户端system_server 进程与服务端Zygote 进程建立 Socket 连接实现跨进程通讯。zygoteSocketAddress 指向服务端 Socket 地址。
// frameworks/base/core/java/android/os/ZygoteProcess.java
public class ZygoteProcess {private Process.ProcessStartResult zygoteSendArgsAndGetResult(ZygoteState zygoteState, int zygotePolicyFlags, NonNull ArrayListString args)throws ZygoteStartFailedEx {for (String arg : args) {if (arg.indexOf(\n) 0) {throw new ZygoteStartFailedEx(Embedded newlines not allowed);} else if (arg.indexOf(\r) 0) {throw new ZygoteStartFailedEx(Embedded carriage returns not allowed);}}String msgStr args.size() \n String.join(\n, args) \n;if (shouldAttemptUsapLaunch(zygotePolicyFlags, args)) {try {return attemptUsapSendArgsAndGetResult(zygoteState, msgStr);} catch (IOException ex) {Log.e(LOG_TAG, IO Exception while communicating with USAP pool - ex.getMessage());}}// 1 准备向服务端Zygote 进程发送启动应用程序进程的参数return attemptZygoteSendArgsAndGetResult(zygoteState, msgStr);}private Process.ProcessStartResult attemptZygoteSendArgsAndGetResult(ZygoteState zygoteState, String msgStr) throws ZygoteStartFailedEx {try {final BufferedWriter zygoteWriter zygoteState.mZygoteOutputWriter;final DataInputStream zygoteInputStream zygoteState.mZygoteInputStream;zygoteWriter.write(msgStr);zygoteWriter.flush();Process.ProcessStartResult result new Process.ProcessStartResult();result.pid zygoteInputStream.readInt();result.usingWrapper zygoteInputStream.readBoolean();if (result.pid 0) {throw new ZygoteStartFailedEx(fork() failed);}return result;} catch (IOException ex) {zygoteState.close();Log.e(LOG_TAG, IO Exception while communicating with Zygote - ex.toString());throw new ZygoteStartFailedEx(ex);}}
}注释 1 处准备向服务端Zygote 进程发送启动应用程序进程的参数。 以下是 ZygoteInit 的构造方法和 main 方法的相关源码
// frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
public static void main(String[] argv) {ZygoteServer zygoteServer null;...Runnable caller;try {...zygoteServer new ZygoteServer(isPrimaryZygote);if (startSystemServer) {Runnable r forkSystemServer(abiList, zygoteSocketName, zygoteServer);// {code r null} in the parent (zygote) process, and {code r ! null} in the// child (system_server) process.if (r ! null) {r.run();return;}}Log.i(TAG, Accepting command socket connections);// The select loop returns early in the child process after a fork and// loops forever in the zygote.caller zygoteServer.runSelectLoop(abiList); // 1} catch (Throwable ex) {Log.e(TAG, System zygote died with fatal exception, ex);throw ex;} finally {if (zygoteServer ! null) {zygoteServer.closeServerSocket();}}// Were in the child process and have exited the select loop. Proceed to execute the// command.if (caller ! null) {caller.run(); // 2}
}LocalServerSocket 是 socket 通讯分服务端。注释 1 处调用了 ZygoteServer.runSelectLoop 方法
// frameworks/base/core/java/com/android/internal/os/ZygoteServer.java
private LocalServerSocket mZygoteSocket;
private final LocalServerSocket mUsapPoolSocket;ZygoteServer(boolean isPrimaryZygote) {mUsapPoolEventFD Zygote.getUsapPoolEventFD();if (isPrimaryZygote) {mZygoteSocket Zygote.createManagedSocketFromInitSocket(Zygote.PRIMARY_SOCKET_NAME);mUsapPoolSocket Zygote.createManagedSocketFromInitSocket(Zygote.USAP_POOL_PRIMARY_SOCKET_NAME);} else {mZygoteSocket Zygote.createManagedSocketFromInitSocket(Zygote.SECONDARY_SOCKET_NAME);mUsapPoolSocket Zygote.createManagedSocketFromInitSocket(Zygote.USAP_POOL_SECONDARY_SOCKET_NAME);}mUsapPoolSupported true;fetchUsapPoolPolicyProps();
}Runnable runSelectLoop(String abiList) {...ArrayListZygoteConnection peers new ArrayList();...while (true) {...if (pollReturnValue 0) {...} else {boolean usapPoolFDRead false;while (--pollIndex 0) {if ((pollFDs[pollIndex].revents POLLIN) 0) {continue;}if (pollIndex 0) {// Zygote server socketZygoteConnection newPeer acceptCommandPeer(abiList); // 1peers.add(newPeer);socketFDs.add(newPeer.getFileDescriptor());} else if (pollIndex usapPoolEventFDIndex) {// Session socket accepted from the Zygote server sockettry {ZygoteConnection connection peers.get(pollIndex);boolean multipleForksOK !isUsapPoolEnabled() ZygoteHooks.isIndefiniteThreadSuspensionSafe();final Runnable command connection.processCommand(this, multipleForksOK); // 2...} catch (Exception e) {...} finally {...}} else {...}}...}...}
}private LocalServerSocket mZygoteSocket;private ZygoteConnection acceptCommandPeer(String abiList) {try {return createNewConnection(mZygoteSocket.accept(), abiList); // 3} catch (IOException ex) {throw new RuntimeException(IOException during accept(), ex);}
}protected ZygoteConnection createNewConnection(LocalSocket socket, String abiList)throws IOException {return new ZygoteConnection(socket, abiList); // 4
}注释 1 处的 acceptCommandPeer 方法中会 new ZygoteConnection(LocalServerSocket.accept, abiList)其中 LocalServerSocket.accept() 方法用来监听来自客户端system_server 进程的 connect 请求并返回一个 LocalSocket 对象通过该对象可以实现与客户端跨进程通讯。
// frameworks/base/core/java/com/android/internal/os/ZygoteConnection.java
Runnable processCommand(ZygoteServer zygoteServer, boolean multipleOK) {ZygoteArguments parsedArgs;try (ZygoteCommandBuffer argBuffer new ZygoteCommandBuffer(mSocket)) {while (true) {try {parsedArgs ZygoteArguments.getInstance(argBuffer);// Keep argBuffer around, since we need it to fork.} catch (IOException ex) {throw new IllegalStateException(IOException on command socket, ex);}...if (parsedArgs.mInvokeWith ! null || parsedArgs.mStartChildZygote|| !multipleOK || peer.getUid() ! Process.SYSTEM_UID) {// Continue using old code for now. TODO: Handle these cases in the other path.pid Zygote.forkAndSpecialize(parsedArgs.mUid, parsedArgs.mGid,parsedArgs.mGids, parsedArgs.mRuntimeFlags, rlimits,parsedArgs.mMountExternal, parsedArgs.mSeInfo, parsedArgs.mNiceName,fdsToClose, fdsToIgnore, parsedArgs.mStartChildZygote,parsedArgs.mInstructionSet, parsedArgs.mAppDataDir,parsedArgs.mIsTopApp, parsedArgs.mPkgDataInfoList,parsedArgs.mAllowlistedDataInfoList, parsedArgs.mBindMountAppDataDirs,parsedArgs.mBindMountAppStorageDirs); // 1try {if (pid 0) {// in childzygoteServer.setForkChild();zygoteServer.closeServerSocket();IoUtils.closeQuietly(serverPipeFd);serverPipeFd null;return handleChildProc(parsedArgs, childPipeFd,parsedArgs.mStartChildZygote); // 2} else {...}} finally {...}} else {...}}}...throw new AssertionError(Shouldnt get here);
}private Runnable handleChildProc(ZygoteArguments parsedArgs,FileDescriptor pipeFd, boolean isZygote) {...if (parsedArgs.mInvokeWith ! null) {...} else {if (!isZygote) { // 3 isZygote 一般是 falsereturn ZygoteInit.zygoteInit(parsedArgs.mTargetSdkVersion,parsedArgs.mDisabledCompatChanges,parsedArgs.mRemainingArgs, null /* classLoader */); // 4} else {return ZygoteInit.childZygoteInit(parsedArgs.mRemainingArgs /* classLoader */); // }}
}注释 3 处的 isZygote 一般是 false注释 4 处调用的是 ZygoteInit.zygoteInit 方法
// frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
public static Runnable zygoteInit(int targetSdkVersion, long[] disabledCompatChanges,String[] argv, ClassLoader classLoader) {if (RuntimeInit.DEBUG) {Slog.d(RuntimeInit.TAG, RuntimeInit: Starting application from zygote);}Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, ZygoteInit);RuntimeInit.redirectLogStreams();RuntimeInit.commonInit();ZygoteInit.nativeZygoteInit();return RuntimeInit.applicationInit(targetSdkVersion, disabledCompatChanges, argv,classLoader); // 1
}注释 1 处调用 RuntimeInit.applicationInit 方法
// frameworks/base/core/java/com/android/internal/os/RuntimeInit.java
protected static Runnable applicationInit(int targetSdkVersion, long[] disabledCompatChanges,String[] argv, ClassLoader classLoader) {nativeSetExitWithoutCleanup(true);VMRuntime.getRuntime().setTargetSdkVersion(targetSdkVersion);VMRuntime.getRuntime().setDisabledCompatChanges(disabledCompatChanges);final Arguments args new Arguments(argv);// The end of of the RuntimeInit event (see #zygoteInit).Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);// Remaining arguments are passed to the start classs static mainreturn findStaticMain(args.startClass, args.startArgs, classLoader);
}protected static Runnable findStaticMain(String className, String[] argv,ClassLoader classLoader) {Class? cl;try {cl Class.forName(className, true, classLoader);} catch (ClassNotFoundException ex) {throw new RuntimeException(Missing class when invoking static main className,ex);}Method m;try {m cl.getMethod(main, new Class[] { String[].class }); // 1} catch (NoSuchMethodException ex) {throw new RuntimeException(Missing static main on className, ex);} catch (SecurityException ex) {throw new RuntimeException(Problem getting static main on className, ex);}int modifiers m.getModifiers();if (! (Modifier.isStatic(modifiers) Modifier.isPublic(modifiers))) {throw new RuntimeException(Main method is not public and static on className);}/** This throw gets caught in ZygoteInit.main(), which responds* by invoking the exceptions run() method. This arrangement* clears up all the stack frames that were required in setting* up the process.*/return new MethodAndArgsCaller(m, argv); // 2
}static class MethodAndArgsCaller implements Runnable {/** method to call */private final Method mMethod;/** argument array */private final String[] mArgs;public MethodAndArgsCaller(Method method, String[] args) {mMethod method;mArgs args;}public void run() {try {mMethod.invoke(null, new Object[] { mArgs }); // 3} catch (IllegalAccessException ex) {throw new RuntimeException(ex);} catch (InvocationTargetException ex) {Throwable cause ex.getCause();if (cause instanceof RuntimeException) {throw (RuntimeException) cause;} else if (cause instanceof Error) {throw (Error) cause;}throw new RuntimeException(ex);}}
}MethodAndArgsCaller.run 方法最终会进入到 ActivityThread.main 方法中。 // frameworks/base/core/java/android/app/ActivityThread.java
public static void main(String[] args) {...Looper.prepareMainLooper();...ActivityThread thread new ActivityThread();thread.attach(false, startSeq);if (sMainThreadHandler null) {sMainThreadHandler thread.getHandler();}if (false) {Looper.myLooper().setMessageLogging(newLogPrinter(Log.DEBUG, ActivityThread));}// End of event ActivityThreadMain.Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);Looper.loop();throw new RuntimeException(Main thread loop unexpectedly exited);
}private void attach(boolean system, long startSeq) {...if (!system) {...final IActivityManager mgr ActivityManager.getService();try {mgr.attachApplication(mAppThread, startSeq);} catch (RemoteException ex) {throw ex.rethrowFromSystemServer();}...} else {...
}// frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
public ActivityTaskManagerInternal mAtmInternal;Override
public final void attachApplication(IApplicationThread thread, long startSeq) {if (thread null) {throw new SecurityException(Invalid application interface);}synchronized (this) {int callingPid Binder.getCallingPid();final int callingUid Binder.getCallingUid();final long origId Binder.clearCallingIdentity();attachApplicationLocked(thread, callingPid, callingUid, startSeq);Binder.restoreCallingIdentity(origId);}
}private boolean attachApplicationLocked(NonNull IApplicationThread thread,int pid, int callingUid, long startSeq) {...try {...if (app.getIsolatedEntryPoint() ! null) {...} else if (instr2 ! null) {thread.bindApplication(processName, appInfo,app.sdkSandboxClientAppVolumeUuid, app.sdkSandboxClientAppPackage,providerList,instr2.mClass,profilerInfo, instr2.mArguments,instr2.mWatcher,instr2.mUiAutomationConnection, testMode,mBinderTransactionTrackingEnabled, enableTrackAllocation,isRestrictedBackupMode || !normalMode, app.isPersistent(),new Configuration(app.getWindowProcessController().getConfiguration()),app.getCompat(), getCommonServicesLocked(app.isolated),mCoreSettingsObserver.getCoreSettingsLocked(),buildSerial, autofillOptions, contentCaptureOptions,app.getDisabledCompatChanges(), serializedSystemFontMap,app.getStartElapsedTime(), app.getStartUptime());} else {thread.bindApplication(processName, appInfo,app.sdkSandboxClientAppVolumeUuid, app.sdkSandboxClientAppPackage,providerList, null, profilerInfo, null, null, null, testMode,mBinderTransactionTrackingEnabled, enableTrackAllocation,isRestrictedBackupMode || !normalMode, app.isPersistent(),new Configuration(app.getWindowProcessController().getConfiguration()),app.getCompat(), getCommonServicesLocked(app.isolated),mCoreSettingsObserver.getCoreSettingsLocked(),buildSerial, autofillOptions, contentCaptureOptions,app.getDisabledCompatChanges(), serializedSystemFontMap,app.getStartElapsedTime(), app.getStartUptime());}...} catch (Exception e) {...}// See if the top visible activity is waiting to run in this process...if (normalMode) {try {didSomething mAtmInternal.attachApplication(app.getWindowProcessController()); // 2} catch (Exception e) {Slog.wtf(TAG, Exception thrown launching activities in app, e);badApp true;}}...
}// frameworks/base/core/java/android/app/ActivityThread.java
private class ApplicationThread extends IApplicationThread.Stub {Overridepublic final void bindApplication(String processName, ApplicationInfo appInfo,String sdkSandboxClientAppVolumeUuid, String sdkSandboxClientAppPackage,ProviderInfoList providerList, ComponentName instrumentationName,ProfilerInfo profilerInfo, Bundle instrumentationArgs,IInstrumentationWatcher instrumentationWatcher,IUiAutomationConnection instrumentationUiConnection, int debugMode,boolean enableBinderTracking, boolean trackAllocation,boolean isRestrictedBackupMode, boolean persistent, Configuration config,CompatibilityInfo compatInfo, Map services, Bundle coreSettings,String buildSerial, AutofillOptions autofillOptions,ContentCaptureOptions contentCaptureOptions, long[] disabledCompatChanges,SharedMemory serializedSystemFontMap,long startRequestedElapsedTime, long startRequestedUptime) {...AppBindData data new AppBindData();data.processName processName;data.appInfo appInfo;data.sdkSandboxClientAppVolumeUuid sdkSandboxClientAppVolumeUuid;data.sdkSandboxClientAppPackage sdkSandboxClientAppPackage;data.providers providerList.getList();data.instrumentationName instrumentationName;data.instrumentationArgs instrumentationArgs;data.instrumentationWatcher instrumentationWatcher;data.instrumentationUiAutomationConnection instrumentationUiConnection;data.debugMode debugMode;data.enableBinderTracking enableBinderTracking;data.trackAllocation trackAllocation;data.restrictedBackupMode isRestrictedBackupMode;data.persistent persistent;data.config config;data.compatInfo compatInfo;data.initProfilerInfo profilerInfo;data.buildSerial buildSerial;data.autofillOptions autofillOptions;data.contentCaptureOptions contentCaptureOptions;data.disabledCompatChanges disabledCompatChanges;data.mSerializedSystemFontMap serializedSystemFontMap;data.startRequestedElapsedTime startRequestedElapsedTime;data.startRequestedUptime startRequestedUptime;sendMessage(H.BIND_APPLICATION, data);}
}void sendMessage(int what, Object obj) {sendMessage(what, obj, 0, 0, false);
}private void sendMessage(int what, Object obj, int arg1, int arg2, boolean async) {if (DEBUG_MESSAGES) {Slog.v(TAG,SCHEDULE what mH.codeToString(what) : arg1 / obj);}Message msg Message.obtain();msg.what what;msg.obj obj;msg.arg1 arg1;msg.arg2 arg2;if (async) {msg.setAsynchronous(true);}mH.sendMessage(msg);
}class H extends Handler {public void handleMessage(Message msg) {if (DEBUG_MESSAGES) Slog.v(TAG, handling: codeToString(msg.what));switch (msg.what) {case BIND_APPLICATION:Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, bindApplication);AppBindData data (AppBindData)msg.obj;handleBindApplication(data);Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);break;...}...}}// frameworks/base/core/java/android/app/ActivityThread.java
private void handleBindApplication(AppBindData data) {...// send up app name; do this *before* waiting for debuggerProcess.setArgV0(data.processName);android.ddm.DdmHandleAppName.setAppName(data.processName,data.appInfo.packageName,UserHandle.myUserId());VMRuntime.setProcessPackageName(data.appInfo.packageName);// Pass data directory path to ART. This is used for caching information and// should be set before any application code is loaded.VMRuntime.setProcessDataDirectory(data.appInfo.dataDir);if (mProfiler.profileFd ! null) {mProfiler.startProfiling();}...// Instrumentation info affects the class loader, so load it before// setting up the app context.final InstrumentationInfo ii;if (data.instrumentationName ! null) {ii prepareInstrumentation(data);} else {ii null;}final ContextImpl appContext ContextImpl.createAppContext(this, data.info);mConfigurationController.updateLocaleListFromAppContext(appContext);...// Continue loading instrumentation.if (ii ! null) {initInstrumentation(ii, data, appContext);} else {mInstrumentation new Instrumentation();mInstrumentation.basicInit(this);}...// Allow disk access during application and provider setup. This could// block processing ordered broadcasts, but later processing would// probably end up doing the same disk access.Application app;final StrictMode.ThreadPolicy savedPolicy StrictMode.allowThreadDiskWrites();final StrictMode.ThreadPolicy writesAllowedPolicy StrictMode.getThreadPolicy();try {// If the app is being launched for full backup or restore, bring it up in// a restricted environment with the base application class.app data.info.makeApplicationInner(data.restrictedBackupMode, null); // 1...// Do this after providers, since instrumentation tests generally start their// test thread at this point, and we dont want that racing.try {mInstrumentation.onCreate(data.instrumentationArgs);}catch (Exception e) {throw new RuntimeException(Exception thrown in onCreate() of data.instrumentationName : e.toString(), e);}try {mInstrumentation.callApplicationOnCreate(app); // 2} catch (Exception e) {if (!mInstrumentation.onException(app, e)) {throw new RuntimeException(Unable to create application app.getClass().getName() : e.toString(), e);}}} finally {// If the app targets O-MR1, or doesnt change the thread policy// during startup, clobber the policy to maintain behavior of b/36951662if (data.appInfo.targetSdkVersion Build.VERSION_CODES.O_MR1|| StrictMode.getThreadPolicy().equals(writesAllowedPolicy)) {StrictMode.setThreadPolicy(savedPolicy);}}}// frameworks/base/core/java/android/app/LoadedApk.java
public Application makeApplicationInner(boolean forceDefaultAppClass,Instrumentation instrumentation) {return makeApplicationInner(forceDefaultAppClass, instrumentation,/* allowDuplicateInstances */ false);
}private Application makeApplicationInner(boolean forceDefaultAppClass,Instrumentation instrumentation, boolean allowDuplicateInstances) {...Application app null;final String myProcessName Process.myProcessName();String appClass mApplicationInfo.getCustomApplicationClassNameForProcess(myProcessName);if (forceDefaultAppClass || (appClass null)) {appClass android.app.Application;}try {final java.lang.ClassLoader cl getClassLoader();if (!mPackageName.equals(android)) {Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER,initializeJavaContextClassLoader);initializeJavaContextClassLoader();Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);}...ContextImpl appContext ContextImpl.createAppContext(mActivityThread, this);// The network security config needs to be aware of multiple// applications in the same process to handle discrepanciesNetworkSecurityConfigProvider.handleNewApplication(appContext);app mActivityThread.mInstrumentation.newApplication(cl, appClass, appContext); // 1appContext.setOuterContext(app);} catch (Exception e) {...}mActivityThread.mAllApplications.add(app);mApplication app;if (!allowDuplicateInstances) {synchronized (sApplications) {sApplications.put(mPackageName, app);}}if (instrumentation ! null) {try {instrumentation.callApplicationOnCreate(app); // 2} catch (Exception e) {if (!instrumentation.onException(app, e)) {Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);throw new RuntimeException(Unable to create application app.getClass().getName() : e.toString(), e);}}}Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);return app;
}// frameworks/base/core/java/android/app/Instrumentation.java
public Application newApplication(ClassLoader cl, String className, Context context)throws InstantiationException, IllegalAccessException, ClassNotFoundException {Application app getFactory(context.getPackageName()).instantiateApplication(cl, className);app.attach(context);return app;
}// frameworks/base/core/java/android/app/Application.java
/* package */ final void attach(Context context) {attachBaseContext(context);mLoadedApk ContextImpl.getImpl(context).mPackageInfo;}// frameworks/base/core/java/android/app/Instrumentation.java
public void callApplicationOnCreate(Application app) {app.onCreate();
}// frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerInternal.java
public abstract class ActivityTaskManagerInternal {/** Called by AM when an application process attaches. */public abstract boolean attachApplication(WindowProcessController wpc) throws RemoteException;
}// frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
RootWindowContainer mRootWindowContainer;
final class LocalService extends ActivityTaskManagerInternal {HotPath(caller HotPath.PROCESS_CHANGE)Overridepublic boolean attachApplication(WindowProcessController wpc) throws RemoteException {synchronized (mGlobalLockWithoutBoost) {if (Trace.isTagEnabled(TRACE_TAG_WINDOW_MANAGER)) {Trace.traceBegin(TRACE_TAG_WINDOW_MANAGER, attachApplication: wpc.mName);}try {return mRootWindowContainer.attachApplication(wpc);} finally {Trace.traceEnd(TRACE_TAG_WINDOW_MANAGER);}}}
}// frameworks/base/services/core/java/com/android/server/wm/RootWindowContainer.java
private final AttachApplicationHelper mAttachApplicationHelper new AttachApplicationHelper();
boolean attachApplication(WindowProcessController app) throws RemoteException {try {return mAttachApplicationHelper.process(app);} finally {mAttachApplicationHelper.reset();}
}private class AttachApplicationHelper implements ConsumerTask, PredicateActivityRecord {boolean process(WindowProcessController app) throws RemoteException {mApp app;for (int displayNdx getChildCount() - 1; displayNdx 0; --displayNdx) {getChildAt(displayNdx).forAllRootTasks(this);if (mRemoteException ! null) {throw mRemoteException;}}if (!mHasActivityStarted) {ensureActivitiesVisible(null /* starting */, 0 /* configChanges */,false /* preserveWindows */);}return mHasActivityStarted;}
}// frameworks/base/services/core/java/com/android/server/wm/WindowContainer.java
boolean forAllRootTasks(PredicateTask callback) {return forAllRootTasks(callback, true /* traverseTopToBottom */);
}boolean forAllRootTasks(PredicateTask callback, boolean traverseTopToBottom) {int count mChildren.size();if (traverseTopToBottom) {for (int i count - 1; i 0; --i) {if (mChildren.get(i).forAllRootTasks(callback, traverseTopToBottom)) {return true;}}} else {for (int i 0; i count; i) {if (mChildren.get(i).forAllRootTasks(callback, traverseTopToBottom)) {return true;}// Root tasks may be removed from this display. Ensure each task will be processed// and the loop will end.int newCount mChildren.size();i - count - newCount;count newCount;}}return false;
}// frameworks/base/services/core/java/com/android/server/wm/Task.java
Override
void forAllRootTasks(ConsumerTask callback, boolean traverseTopToBottom) {if (isRootTask()) {callback.accept(this);}
}// frameworks/base/services/core/java/com/android/server/wm/RootWindowContainer.java
private class AttachApplicationHelper implements ConsumerTask, PredicateActivityRecord {Overridepublic void accept(Task rootTask) {if (mRemoteException ! null) {return;}if (rootTask.getVisibility(null /* starting */) TASK_FRAGMENT_VISIBILITY_INVISIBLE) {return;}mTop rootTask.topRunningActivity();rootTask.forAllActivities(this);}
}// frameworks/base/services/core/java/com/android/server/wm/WindowContainer.java
boolean forAllActivities(PredicateActivityRecord callback) {return forAllActivities(callback, true /*traverseTopToBottom*/);
}boolean forAllActivities(PredicateActivityRecord callback, boolean traverseTopToBottom) {if (traverseTopToBottom) {for (int i mChildren.size() - 1; i 0; --i) {if (mChildren.get(i).forAllActivities(callback, traverseTopToBottom)) return true;}} else {final int count mChildren.size();for (int i 0; i count; i) {if (mChildren.get(i).forAllActivities(callback, traverseTopToBottom)) return true;}}return false;
}// frameworks/base/services/core/java/com/android/server/wm/ActivityRecord.java
Override
boolean forAllActivities(PredicateActivityRecord callback, boolean traverseTopToBottom) {return callback.test(this);
}// frameworks/base/services/core/java/com/android/server/wm/RootWindowContainer.java
private class AttachApplicationHelper implements ConsumerTask, PredicateActivityRecord {Overridepublic boolean test(ActivityRecord r) {if (r.finishing || !r.showToCurrentUser() || !r.visibleIgnoringKeyguard|| r.app ! null || mApp.mUid ! r.info.applicationInfo.uid|| !mApp.mName.equals(r.processName)) {return false;}try {if (mTaskSupervisor.realStartActivityLocked(r, mApp,mTop r r.getTask().canBeResumed(r) /* andResume */,true /* checkConfig */)) {mHasActivityStarted true;}} catch (RemoteException e) {Slog.w(TAG, Exception in new application when starting activity mTop, e);mRemoteException e;return true;}return false;}
}参考
Android13 Activity启动流程
Android10 客户端事务管理ClientLifecycleManager源码解析
Android Task详解
Android的Task管理
【framework】应用进程启动流程
