Activity 的启动流程(Android 13)
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 Singleton<IActivityTaskManager> IActivityTaskManagerSingleton =new Singleton<IActivityTaskManager>() {@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 类型的对象,这段代码采用的 AIDL,IActivityManager.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,也可以来自不同的 APP,Activity 之间不一定非要有关联。
当按 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 WindowContainer<WindowContainer> {}
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 WindowContainer<DisplayContent>implements 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, let's 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. Let's
// 这个类已经变成了垃圾请倒场
// - 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 activity's 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 Manager(AM)包通过 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 Manager(WM)包来说,了解进程以及其状态是十分重要的,因为它会影响 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 ConfigurationContainer<ConfigurationContainer>implements 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 List<ClientTransactionItem> 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;}// Parcelable@Overridepublic 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 请求启动一个 Activity,ActivityRelaunchItem 重启 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 { // 1@Overridepublic 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 List<ClientTransactionItem> 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 的类型是 ClientTransactionHandler,ActivityThread 继承了 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 StatefulActivity<LauncherState>implements LauncherExterns, Callbacks, InvariantDeviceProfile.OnIDPChangeListener,PluginListener<LauncherOverlayPlugin> {public boolean startActivitySafely(View v, Intent intent, ItemInfo item,@Nullable String sourceContainer) {...boolean success = super.startActivitySafely(v, intent, item, sourceContainer); // 1...}
}public abstract class StatefulActivity<STATE_TYPE extends BaseState<STATE_TYPE>>extends 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. Let's
// 这个类已经变成了垃圾请倒场
// - 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 activity's 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 Map<String, Pair<String, Long>>pkgDataInfoMap,@Nullable Map<String, Pair<String, Long>>allowlistedDataInfoList,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 didn't 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 can't 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 ArrayList<String> 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();}}// We're 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) {...ArrayList<ZygoteConnection> 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("Shouldn't 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 class's 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 exception's 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 don't 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 doesn't 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 Consumer<Task>, Predicate<ActivityRecord> {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(Predicate<Task> callback) {return forAllRootTasks(callback, true /* traverseTopToBottom */);
}boolean forAllRootTasks(Predicate<Task> 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(Consumer<Task> callback, boolean traverseTopToBottom) {if (isRootTask()) {callback.accept(this);}
}
// frameworks/base/services/core/java/com/android/server/wm/RootWindowContainer.java
private class AttachApplicationHelper implements Consumer<Task>, Predicate<ActivityRecord> {@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(Predicate<ActivityRecord> callback) {return forAllActivities(callback, true /*traverseTopToBottom*/);
}boolean forAllActivities(Predicate<ActivityRecord> 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(Predicate<ActivityRecord> callback, boolean traverseTopToBottom) {return callback.test(this);
}
// frameworks/base/services/core/java/com/android/server/wm/RootWindowContainer.java
private class AttachApplicationHelper implements Consumer<Task>, Predicate<ActivityRecord> {@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】应用进程启动流程
相关文章:

Activity 的启动流程(Android 13)
Activity 的启动过程分为两种:一种是普通 Activity 的启动过程,另一种是根 Activity 的启动过程。普通 Activity 指的是除应用程序启动的第一个 Activity 之外的其他 Activity。根 Activity 指的是应用程序启动的第一个 Activity,因此&#x…...
deepspeed学习资料
记录一些deepspeed学习过程中的好文章 【进行中】1、DeepSpeed使用指南(简略版)_Reza.的博客-CSDN博客 - 含deepspeed的安装方法 - 含 zero config的不同配置,stage1、stage2、stage3的配置和解释...

数据分享|R语言PCA主成分、lasso、岭回归降维分析近年来各国土地面积变化影响...
全文链接:http://tecdat.cn/?p31445 机器学习在环境监测领域的应用,着眼于探索全球范围内的环境演化规律,人类与自然生态之间的关系以及环境变化对人类生存的影响(点击文末“阅读原文”获取完整代码数据)。 课题着眼于…...

Docker-Consul
Docker-Consul 一、介绍1.什么是服务注册与发现2.什么是consul3.consul提供的一些关键特性: 二、consul 部署1.环境准备2.consul服务器3.查看集群信息4.通过 http api 获取集群信息 三、registrator服务器1.安装 Gliderlabs/Registrator2.测试服务发现功能是否正常3…...
Pygame编程(2)display模块
pygame编程2-display设备显示 pygame.display.init() 初始化 display 模块init() -> None pygame.display.get_init() 获取display初始化 状态,如果已经初始化,返回 True,否则返回Falseget_init() -> bool pygame.display.quit() 退出…...
第十五天|104.二叉树的最大深度、111.二叉树的最小深度、 222.完全二叉树的节点个数
104.二叉树的最大深度 题目链接:104. 二叉树的最大深度 - 力扣(LeetCode) /*** Definition for a binary tree node.* struct TreeNode {* int val;* TreeNode *left;* TreeNode *right;* TreeNode() : val(0), left(nullp…...
图像识别技术在医疗领域的革命:探索医学影像诊断的未来
导言: 随着人工智能和计算机视觉的快速发展,图像识别技术在医疗领域正掀起一场革命。医学影像诊断是医疗工作中的重要环节,而图像识别技术的引入为医生提供了更准确、高效的辅助手段。本文将深入探讨图像识别技术在医疗领域的应用,…...

计网第四章(网络层)(二)
目录 IPV4地址编址 第一历史阶段(分类编址): A类地址: B类地址: C类地址: D类地址(多播地址): E类地址(保留地址): 第二历史阶…...

原生微信小程序使用 wxs;微信小程序使用 vant-weapp组件
1.原生微信小程序使用 wxs 1.内嵌 WXS 脚本 2. 定义外链 wxs 3. 使用外连wxs 在这里插入图片描述 2. 微信小程序使用 vant weapp 1.安装步骤 2. 安装包管理(package.json)文件的方法 操作顺序 :文档地址 如果使用 typescript 需要操作步骤3,否则不…...

qml相关知识1
qml相关知识1 QtQuick.Controls 哪个版本支持TreeModel 和 TreeItemqt5.12开始,TreeItem 类被删除,无法使用delegate 什么时候可以用Qt5.15中没有 import QtQuick.Controls 1吗,哪个版本有control1qml如何两种版本的controls混用(…...

linux+c+qt杂记
虚拟机网络选择; 桥接模式:设置window宿主机的IP/dns,把虚拟机设置为桥接即可。 切换到终端:我的是 ctrlaltFnF1? 问题解决: Ubuntu系统下载(清华大学开源软件镜像站)(ubuntu-20.…...
shouldComponentUpdate有什么作用?
触发时机 当props或state发生变化时,shouldComponentUpdate() 会在渲染执行之前被调用。 作用 根据shouldComponentUpdate()的返回值,判断react组件的输出是否受当前state或props更改影响。默认行为是state每次发生变化组件都会重新渲染。 shouldCompo…...
华为OD-滑动窗口最大值
题目描述 给你一个整数数组 nums,有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。 返回 滑动窗口中的最大值 。 示例一 输入:nums [1,3,-1,-3,5,3,6,7], k 3 输出…...

Linux:ansible自动化运维工具
环境介绍 当前所有执行权限我是在root下执行的,如果提示权限之类的,可以在每句命令前 加上 sudo ansible主服务器 192.168.0.194 另外两个客户端分别为 192.168.0.193 192.168.0.192 软件只需要在主服务器上安装,客户端不需…...
前端如何使用WebSocket发送消息
系列文章目录 文章目录 系列文章目录前言一、WebSocket的基本原理二、在前端使用WebSocket1.创建WebSocket实例2.监听事件3.发送消息三、实际应用场景总结前言 WebSocket是一种在Web应用程序中实现双向通信的技术,它允许服务器和客户端之间实时交换数据。在本篇博客中,我们将…...

纸贵科技连续三年蝉联IDC中国 FinTech 50榜单
近日,国际权威市场研究机构IDC公布了“2023 IDC中国FinTech 50榜单”。作为领先的区块链技术和解决方案服务商,纸贵科技凭借过硬的区块链技术和丰富的金融科技创新成果,连续第三年荣登IDC中国FinTech 50榜单。 IDC中国FinTech 50榜单是金融科…...

台积电美国厂施工现场混乱,真令人头痛 | 百能云芯
近日,英伟达公司的财报表现异常亮眼,摩根士丹利不仅点名了台积电成为最大的受益者,还预测每售出一颗H100英伟达芯片,台积电就能获得900美元的利润。然而,美国媒体却曝出了一则不利的消息,称美国亚利桑那州的…...

React绑定antd输入框,点击清空或者确定按钮实现清空输入框内容
其实实现原理和vue的双向绑定是一样的,就是监听输入框的onChange事件,绑定value值,当输入框内容发生变化后,就重新设置这个value值。 示例代码:我这里是统一在handleCancel这个函数里面处理清空逻辑了,你们…...
Springboot整合liquIbase组件
liquIbase方式 1、添加依赖 <!-- Liquibase 依赖 --> <dependency><groupId>org.liquibase</groupId><artifactId>liquibase-core</artifactId> </dependency>2、添加配置项 spring:# datasource 数据源配置内容,对应…...

Apache Paimon 实时数据湖 Streaming Lakehouse 的存储底座
摘要:本文整理自阿里云开源大数据表存储团队负责人,阿里巴巴高级技术专家李劲松(之信),在 Streaming Lakehouse Meetup 的分享。内容主要分为四个部分: 流计算邂逅数据湖 Paimon CDC 实时入湖 Paimon 不止…...

React第五十七节 Router中RouterProvider使用详解及注意事项
前言 在 React Router v6.4 中,RouterProvider 是一个核心组件,用于提供基于数据路由(data routers)的新型路由方案。 它替代了传统的 <BrowserRouter>,支持更强大的数据加载和操作功能(如 loader 和…...
多模态商品数据接口:融合图像、语音与文字的下一代商品详情体验
一、多模态商品数据接口的技术架构 (一)多模态数据融合引擎 跨模态语义对齐 通过Transformer架构实现图像、语音、文字的语义关联。例如,当用户上传一张“蓝色连衣裙”的图片时,接口可自动提取图像中的颜色(RGB值&…...
数据链路层的主要功能是什么
数据链路层(OSI模型第2层)的核心功能是在相邻网络节点(如交换机、主机)间提供可靠的数据帧传输服务,主要职责包括: 🔑 核心功能详解: 帧封装与解封装 封装: 将网络层下发…...
【服务器压力测试】本地PC电脑作为服务器运行时出现卡顿和资源紧张(Windows/Linux)
要让本地PC电脑作为服务器运行时出现卡顿和资源紧张的情况,可以通过以下几种方式模拟或触发: 1. 增加CPU负载 运行大量计算密集型任务,例如: 使用多线程循环执行复杂计算(如数学运算、加密解密等)。运行图…...

微信小程序云开发平台MySQL的连接方式
注:微信小程序云开发平台指的是腾讯云开发 先给结论:微信小程序云开发平台的MySQL,无法通过获取数据库连接信息的方式进行连接,连接只能通过云开发的SDK连接,具体要参考官方文档: 为什么? 因为…...
JVM暂停(Stop-The-World,STW)的原因分类及对应排查方案
JVM暂停(Stop-The-World,STW)的完整原因分类及对应排查方案,结合JVM运行机制和常见故障场景整理而成: 一、GC相关暂停 1. 安全点(Safepoint)阻塞 现象:JVM暂停但无GC日志,日志显示No GCs detected。原因:JVM等待所有线程进入安全点(如…...
CMake控制VS2022项目文件分组
我们可以通过 CMake 控制源文件的组织结构,使它们在 VS 解决方案资源管理器中以“组”(Filter)的形式进行分类展示。 🎯 目标 通过 CMake 脚本将 .cpp、.h 等源文件分组显示在 Visual Studio 2022 的解决方案资源管理器中。 ✅ 支持的方法汇总(共4种) 方法描述是否推荐…...

RSS 2025|从说明书学习复杂机器人操作任务:NUS邵林团队提出全新机器人装配技能学习框架Manual2Skill
视觉语言模型(Vision-Language Models, VLMs),为真实环境中的机器人操作任务提供了极具潜力的解决方案。 尽管 VLMs 取得了显著进展,机器人仍难以胜任复杂的长时程任务(如家具装配),主要受限于人…...
Webpack性能优化:构建速度与体积优化策略
一、构建速度优化 1、升级Webpack和Node.js 优化效果:Webpack 4比Webpack 3构建时间降低60%-98%。原因: V8引擎优化(for of替代forEach、Map/Set替代Object)。默认使用更快的md4哈希算法。AST直接从Loa…...
LangChain 中的文档加载器(Loader)与文本切分器(Splitter)详解《二》
🧠 LangChain 中 TextSplitter 的使用详解:从基础到进阶(附代码) 一、前言 在处理大规模文本数据时,特别是在构建知识库或进行大模型训练与推理时,文本切分(Text Splitting) 是一个…...