在Android桌面Launcher源码浅析中介绍了Android的桌面程序Launcher是如何响应用户点击事件并启动App的,这篇文章继续介绍App在Android系统层的启动流程。
一、启动流程
二、Launcher通知AndroidOS(用户点击图标)
2.1 Activity.java
frameworks/base/core/java/android/app/Activity.java 源码地址
- 在Android桌面Launcher源码浅析中提到
Launcher
最终通过frameworks/base/core/java/android/app/Activity.java
中的startActivity方法启动了对应的应用程序。
startActivity
方法是通过调用startActivityForResult方法来实现的。
startActivityForResult
方法最终调用了/frameworks/base/core/java/android/app/Instrumentation.java
的execStartActivity方法
| public class Activity { |
| |
| @Override |
| public void startActivity(Intent intent) { |
| this.startActivity(intent, null); |
| } |
| |
| @Override |
| public void startActivity(Intent intent, @Nullable Bundle options) { |
| if (options != null) { |
| startActivityForResult(intent, -1, options); |
| } else { |
| startActivityForResult(intent, -1); |
| } |
| } |
| |
| @Override |
| public void startActivityForResult(...) { |
| if (mParent == null) { |
| options = transferSpringboardActivityOptions(options); |
| |
| Instrumentation.ActivityResult ar = |
| mInstrumentation.execStartActivity(...); |
| } |
| } |
| |
| } |
2.2 Instrumentation.java
frameworks/base/core/java/android/app/Instrumentation.java 源码地址
Instrumentation.java
中的execStartActivity方法是Activity启动流程的关键。
- execStartActivity方法通过ActivityTaskManager.getService().startActivity方法与系统服务进行通信.
| |
| public ActivityResult execStartActivity( |
| Context who, IBinder contextThread, IBinder token, Activity target, |
| Intent intent, int requestCode, Bundle options) { |
| |
| |
| |
| int result = ActivityTaskManager.getService() |
| .startActivity(...); |
| } |
| |
2.3 ActivityTaskManagerService.java
/frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java 源码地址
ActivityTaskManagerService
是一个系统服务,负责管理Activity的启动。
- startActivity方法调用了startActivityAsUser方法
- startActivityAsUser方法通过
ActivityStartController
的obtainStarter方法获取了ActivityStarter
对象实例,并调用ActivityStarter
的execute
方法
| public final int startActivity(...) { |
| |
| return startActivityAsUser(...); |
| } |
| |
| public final int startActivityAsUser(...) { |
| |
| |
| return getActivityStartController().obtainStarter(intent, "startActivityAsUser") |
| ... |
| .execute(); |
| } |
| |
2.4 ActivityStarter.java
/frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java 源码地址
- 在
ActivityStarter
中最终会调用RootWindowContainer
的resumeFocusedTasksTopActivities方法
| int execute() { |
| |
| res = executeRequest(mRequest); |
| } |
| |
| private int executeRequest(Request request) { |
| |
| final ActivityRecord r = new ActivityRecord.Builder(mService) |
| .setCaller(callerApp) |
| ... |
| .build(); |
| |
| mLastStartActivityResult = startActivityUnchecked(...); |
| } |
| |
| private int startActivityUnchecked(...) { |
| |
| result = startActivityInner(...); |
| } |
| |
| int startActivityInner(...) { |
| |
| mRootWindowContainer.resumeFocusedTasksTopActivities(...); |
| } |
2.5 RootWindowContainer.java
/frameworks/base/services/core/java/com/android/server/wm/RootWindowContainer.java 源码地址
RootWindowContainer
是WindowManagerService的主要组成部分之一,是一个管理窗口的容器。
- 调用
Task
和TaskFragment
将前台程序Pause,为新的应用程序启动做准备。
- 在resumeFocusedTasksTopActivities中调用
Task
的resumeTopActivityUncheckedLocked方法。
| |
| private boolean resumeFocusedTasksTopActivities(...) { |
| |
| result = targetRootTask.resumeTopActivityUncheckedLocked(...); |
| } |
| |
2.5.1 Task.java
/frameworks/base/services/core/java/com/android/server/wm/Task.java 源码地址
- 在
Task
最终调用TaskFragment
的resumeTopActivity方法
| @GuardedBy("mService") |
| boolean resumeTopActivityUncheckedLocked(...) { |
| |
| someActivityResumed = resumeTopActivityInnerLocked(...); |
| } |
| |
| @GuardedBy("mService") |
| private boolean resumeTopActivityInnerLocked(...) { |
| final TaskFragment topFragment = topActivity.getTaskFragment(); |
| |
| resumed[0] = topFragment.resumeTopActivity(...);); |
| return resumed[0]; |
| } |
| |
2.5.2 TaskFragment.java
/frameworks/base/services/core/java/com/android/server/wm/TaskFragment.java 源码地址
- 在
TaskFragment
最终调用ActivityTaskManagerService
的startProcessAsync方法
| final boolean resumeTopActivity(...) { |
| |
| ... |
| |
| ActivityTaskManagerService的startProcessAsync方法 |
| mAtmService.startProcessAsync(...); |
| } |
2.6 再次回到ActivityTaskManagerService.java
/frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java 源码地址
- 处理完窗口容器数据以后(核心工作是将前台程序Pause),再次回到了
ActivityTaskManagerService
- 在startProcessAsync方法发送异步消息,调用
ActivityManagerInternal
的startProcess方法
ActivityManagerInternal
的实现类是ActivityManagerService
| |
| mAmInternal = LocalServices.getService(ActivityManagerInternal.class); |
| |
| void startProcessAsync(...) { |
| |
| |
| final Message m = PooledLambda.obtainMessage(ActivityManagerInternal::startProcess, mAmInternal, ...); |
| mH.sendMessage(m); |
| } |
- ActivityManagerInternal是一个抽象类,具体实现在
ActivityManagerService.java
中实现
2.7 ActivityManagerService.java
/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java 源码地址
- 在
ActivityManagerService
最终调用ProcessList
的startProcessLocked方法
| public class ActivityManagerService extends IActivityManager.Stub { |
| |
| |
| private final ActivityManagerInternal mInternal = new LocalService(); |
| |
| public void init() { |
| |
| LocalServices.addService(ActivityManagerInternal.class, mInternal); |
| } |
| private class LocalService extends ActivityManagerInternal { |
| |
| @Override |
| public void startProcess(...) { |
| synchronized (ActivityManagerService.this) { |
| |
| startProcessLocked(...) |
| } |
| } |
| } |
| @GuardedBy("this") |
| final ProcessRecord startProcessLocked(...) { |
| |
| return mProcessList.startProcessLocked(...); |
| } |
| } |
| |
2.7.1 ProcessList.java
/frameworks/base/services/core/java/com/android/server/am/ProcessList.java 源码地址
- 在
ProcessList
最终调用到ZygoteProcess
的start方法
| @GuardedBy("mService") |
| boolean startProcessLocked(ProcessRecord app, ...) { |
| |
| final String entryPoint = "android.app.ActivityThread"; |
| return startProcessLocked(hostingRecord, ...); |
| } |
| |
| @GuardedBy("mService") |
| boolean startProcessLocked(HostingRecord hostingRecord, ...) { |
| |
| final Process.ProcessStartResult startResult = startProcess(...); |
| } |
| |
| private Process.ProcessStartResult startProcess(...) { |
| |
| final AppZygote appZygote = createAppZygoteForProcessIfNeeded(app); |
| |
| |
| startResult = appZygote.getProcess().start(entryPoint,...); |
| } |
2.8 ZygoteProcess.java
/frameworks/base/core/java/android/os/ZygoteProcess.java 源码地址
- 在
ZygoteProcess
发送消息给Zygote进程
,通过Zygote进程
创建新的activity进程
| public final Process.ProcessStartResult start(...) { |
| |
| return startViaZygote(...) |
| } |
| |
| private Process.ProcessStartResult startViaZygote(...) { |
| |
| |
| return zygoteSendArgsAndGetResult(openZygoteSocketIfNeeded(abi),zygotePolicyFlags,argsForZygote); |
| } |
| |
| @GuardedBy("mLock") |
| private Process.ProcessStartResult zygoteSendArgsAndGetResult(...) { |
| |
| return attemptZygoteSendArgsAndGetResult(...); |
| } |
| |
| private Process.ProcessStartResult attemptZygoteSendArgsAndGetResult(...) { |
| 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); |
| } |
| } |
三、Activity进程创建(Zygote进程fork)
在Android启动过程-万字长文(Android14)介绍了Zygote进程(孵化器进程)
3.1 Zygote简介
- Zygote进程是一个用户进程,由init进程(1号进程)fork而来。
- Zygote进程通过fork的方式创建新的应用程序进程。
- Zygote进程的入口点是
ZygoteInit
类中的main方法。
下面将简单介绍在Zygote进程的代码流转。
3.2 ZygoteInit.java
Android14的ZygoteInit源码地址
Zygote
进程是在Android系统启动过程中创建的,创建完成后会通过ZygoteServer
来监听消息
| public static void main(String argv[]) { |
| ZygoteServer zygoteServer = new ZygoteServer(); |
| ... |
| |
| |
| caller = zygoteServer.runSelectLoop(abiList); |
| if (caller != null) { |
| |
| caller.run(); |
| } |
| ... |
| } |
| |
3.3 ZygoteServer.java
Android14的ZygoteServer源码地址
- 在
ZygoteServer
获取到消息后会调用ZygoteConnection
的processCommand方法
| Runnable runSelectLoop(String abiList) { |
| |
| while (true) { |
| |
| StructPollfd[] pollFDs = new StructPollfd[socketFDs.size()]; |
| |
| if (pollIndex == 0) { |
| |
| ZygoteConnection newPeer = acceptCommandPeer(abiList); |
| peers.add(newPeer); |
| socketFDs.add(newPeer.getFileDescriptor()); |
| } else { |
| |
| ZygoteConnection connection = peers.get(pollIndex); |
| final Runnable command = connection.processCommand(this, multipleForksOK); |
| } |
| } |
| } |
| |
3.4 ZygoteConnection.java
Android14的ZygoteConnection源码地址
ZygoteConnection
的processCommand方法最终调用ZygoteInit
的zygoteInit方法
| |
| Runnable processCommand(ZygoteServer zygoteServer, boolean multipleOK) { |
| ... |
| |
| pid = Zygote.forkAndSpecialize(...); |
| |
| if (pid == 0) { |
| |
| return handleChildProc(parsedArgs, childPipeFd, |
| parsedArgs.mStartChildZygote); |
| } else { |
| |
| handleParentProc(pid, serverPipeFd); |
| return null; |
| } |
| } |
| |
| private void handleParentProc(int pid, FileDescriptor serverPipeFd) { |
| |
| os.writeInt(pid); |
| } |
| |
| |
| private Runnable handleChildProc(...) { |
| |
| |
| ZygoteInit.zygoteInit(...) |
| } |
| |
- fork系统调用会创建一个新的进程(子进程)。在调用fork后,父进程和子进程(新创建出来的进程)会各自执行后续的代码。
- 在父进程中,fork返回子进程的PID。这是一个正整数,表示新创建的子进程的进程ID。
- 在子进程中(新进程),fork 返回 0。这表示当前进程是新创建的子进程。
- 应用程序(App)的进程就是新创建的子进程
3.5 再次回到ZygoteInit.java
Android14的ZygoteInit源码地址
- 调用
RuntimeInit.applicationInit
方法,进行应用程序的初始化过程
| public static Runnable zygoteInit(...) { |
| |
| RuntimeInit.commonInit(); |
| |
| ZygoteInit.nativeZygoteInit(); |
| |
| return RuntimeInit.applicationInit(targetSdkVersion, disabledCompatChanges, argv, classLoader); |
| } |
| |
3.6 RuntimeInit.java
Android14的RuntimeInit源码地址
- 在
RuntimeInit
的applicationInit方法完成初始化工作后,通过反射的方式,调用android.app.ActivityThread
的main方法
- 参数列表中的startClass即
2.9 ProcessList.java
源码中的entryPoint(android.app.ActivityThread
)
| protected static Runnable applicationInit(...) { |
| |
| return findStaticMain(args.startClass, args.startArgs, classLoader); |
| } |
| |
| private static Runnable findStaticMain(...) { |
| |
| cl = Class.forName(className, true, classLoader); |
| |
| m = cl.getMethod("main", new Class[] { String[].class }); |
| |
| return new MethodAndArgsCaller(m, argv); |
| } |
四、初始化Application实例
通过Zygote进程
fork出应用程序的进程后,下一步就是创建整个应用程序的Application实例
4.1 ActivityThread.java
Android14的ActivityThread源码地址
- 创建应用程序的ActivityThread实例
- 创建应用程序的Application实例
- 创建应用程序的Looper循环
| public static void main(String[] args) { |
| |
| |
| initializeMainlineModules(); |
| |
| Looper.prepareMainLooper(); |
| |
| ActivityThread thread = new ActivityThread(); |
| |
| thread.attach(false, startSeq); |
| |
| if (sMainThreadHandler == null) { |
| sMainThreadHandler = thread.getHandler(); |
| } |
| |
| Looper.loop(); |
| } |
| |
| @UnsupportedAppUsage |
| private void attach(boolean system, long startSeq) { |
| |
| final IActivityManager mgr = ActivityManager.getService(); |
| |
| mgr.attachApplication(mAppThread, startSeq); |
| } |
4.2 ActivityManagerService.java
Android14的ActivityManagerService源码地址
- 在
ActivityManagerService
完成Application创建和第一个Activity的创建
| @Override |
| public final void attachApplication(IApplicationThread thread, long startSeq) { |
| |
| attachApplicationLocked(thread, callingPid, callingUid, startSeq); |
| } |
| |
| private void attachApplicationLocked(...) { |
| |
| thread.bindApplication(...) |
| |
| finishAttachApplicationInner(startSeq, callingUid, pid); |
| } |
4.3 再次回到ActivityThread.java
Android14的ActivityThread源码地址
- 通过Handler机制完成消息的传递,正式加载apk文件
| public final void bindApplication(...) { |
| AppBindData data = new AppBindData(); |
| ... |
| |
| |
| sendMessage(H.BIND_APPLICATION, data); |
| } |
| |
| |
| class H extends Handler { |
| public void handleMessage(Message msg) { |
| switch (msg.what) { |
| case BIND_APPLICATION: |
| AppBindData data = (AppBindData)msg.obj; |
| handleBindApplication(data); |
| break; |
| } |
| } |
| } |
| |
| @UnsupportedAppUsage |
| private void handleBindApplication(AppBindData data) { |
| Application app; |
| |
| app = data.info.makeApplicationInner(data.restrictedBackupMode, null); |
| |
| mInstrumentation.callApplicationOnCreate(app); |
| } |
4.4 LoadedApk.java
Android14的LoadedApk源码地址
| private Application makeApplicationInner(...) { |
| |
| String appClass = mApplicationInfo.getCustomApplicationClassNameForProcess( |
| myProcessName); |
| if (forceDefaultAppClass || (appClass == null)) { |
| appClass = "android.app.Application"; |
| } |
| |
| app = mActivityThread.mInstrumentation.newApplication( |
| cl, appClass, appContext); |
| } |
4.5 Instrumentation.java
Android14的Instrumentation源码地址
- 在
Instrumentation
完成Application实例的初始化,并调用onCreate方法
| |
| static public Application newApplication(Class<?> clazz, Context context) { |
| |
| Application app = (Application)clazz.newInstance(); |
| app.attach(context); |
| return app; |
| } |
| |
| |
| public void callApplicationOnCreate(Application app) { |
| app.onCreate(); |
| } |
| |
五、启动第一个Activity
5.1 ActivityManagerService.java
Android14的ActivityManagerService源码地址
- 在执行完Application的onCreate方法后,我们再回到
ActivityManagerService.java
的attachApplicationLocked方法中
- 在attachApplicationLocked方法最终会调用
LocalService
的attachApplication方法来加载我们的第一个Acitivity页面
ActivityTaskManagerInternal
是定义在ActivityTaskManagerService.java
的LocalService
类
| private void attachApplicationLocked(...) { |
| |
| thread.bindApplication(...) |
| |
| finishAttachApplicationInner(startSeq, callingUid, pid); |
| } |
| |
| private void finishAttachApplicationInner(long startSeq, int uid, int pid) { |
| if (normalMode) { |
| try { |
| |
| didSomething = mAtmInternal.attachApplication(app.getWindowProcessController()); |
| } |
| } |
| } |
5.2 ActivityTaskManagerService.java
Android14的ActivityTaskManagerService源码地址
- 在LocalService中调用
RootWindowContainer.attachApplication
方法
| final class LocalService extends ActivityTaskManagerInternal { |
| @Override |
| public boolean attachApplication(WindowProcessController wpc){ |
| |
| return mRootWindowContainer.attachApplication(wpc); |
| } |
| } |
5.3 RootWindowContainer.java
Android14的RootWindowContainer源码地址
- 最终调用
ActivityTaskSupervisor
的realStartActivityLocked方法
| boolean attachApplication(WindowProcessController app) throws RemoteException { |
| |
| return mAttachApplicationHelper.process(app); |
| } |
| 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); |
| } |
| } |
| |
| public boolean test(ActivityRecord r) { |
| |
| mTaskSupervisor.realStartActivityLocked(...) |
| } |
| } |
5.3.1 Task.java
/frameworks/base/services/core/java/com/android/server/wm/Task.java源码地址
| boolean forAllRootTasks(Predicate<Task> callback, boolean traverseTopToBottom) { |
| |
| return isRootTask() ? callback.test(this) : false; |
| } |
5.4 ActivityTaskSupervisor.java
Android14的ActivityTaskSupervisor源码地址
| boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc, |
| boolean andResume, boolean checkConfig) throws RemoteException { |
| ... |
| |
| final ClientTransaction clientTransaction = ClientTransaction.obtain( |
| proc.getThread(), r.token); |
| ... |
| |
| clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent...)); |
| ... |
| |
| mService.getLifecycleManager().scheduleTransaction(clientTransaction); |
| ... |
| |
| } |
| |
- ClientTransaction事务对象,用于描述一系列客户端(即应用进程)需要执行的操作。
- LaunchActivityItem回调参数中包括如何启动Activity,启动所需的Intent、配置、状态等信息。
5.4.1 ClientLifecycleManager.java
Android14的ClientLifecycleManager源码地址
| void scheduleTransaction(ClientTransaction transaction) throws RemoteException { |
| final IApplicationThread client = transaction.getClient(); |
| |
| transaction.schedule(); |
| } |
5.4.2 ClientTransaction.java
Android14的ClientTransaction源码地址
| public void schedule() throws RemoteException { |
| |
| mClient.scheduleTransaction(this); |
| } |
- mClient是
IApplicationThread
接口,实际是ActivityThread的内部类ApplicationThread
对象。
- mClient在
ActivityTaskSupervisor的realStartActivityLocked方法
中通过ClientTransaction.obtain(proc.getThread(), r.token),具体可参考ActivityTaskSupervisor源码
5.5 回到ActivityThread.java
Android14的ActivityThread源码地址
| private class ApplicationThread extends IApplicationThread.Stub { |
| @Override |
| public void scheduleTransaction(ClientTransaction transaction) throws RemoteException { |
| |
| ActivityThread.this.scheduleTransaction(transaction); |
| } |
| } |
- scheduleTransaction方法实际调用的是
ActivityThread父类ClientTransactionHandler
的scheduleTransaction方法
5.5.1 ClientTransactionHandler.java
Android14的ClientTransactionHandler源码地址
| void scheduleTransaction(ClientTransaction transaction) { |
| transaction.preExecute(this); |
| |
| sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction); |
| } |
5.5.2 ActivityThread的内部Handler类H处理消息
Android14的ActivityThread源码地址
| public void handleMessage(Message msg) { |
| switch (msg.what) { |
| case EXECUTE_TRANSACTION: |
| final ClientTransaction transaction = (ClientTransaction) msg.obj; |
| mTransactionExecutor.execute(transaction); |
| break; |
| } |
| } |
5.5.3 TransactionExecutor.java
Android14的TransactionExecutor源码地址
| public void execute(ClientTransaction transaction) { |
| |
| executeCallbacks(transaction); |
| executeLifecycleState(transaction); |
| } |
| |
| public void executeCallbacks(ClientTransaction transaction) { |
| final List<ClientTransactionItem> callbacks = transaction.getCallbacks(); |
| |
| for (int i = 0, size = callbacks.size(); i < size; ++i) { |
| final ClientTransactionItem item = callbacks.get(i); |
| item.execute(mClient, mTransactionHandler, transaction.getLifecycleStateRequest()); |
| } |
| } |
- 每个回调项的execute方法实际就是调用
LaunchActivityItem
的execute方法
5.5.4 LaunchActivityItem.java
Android14的LaunchActivityItem源码地址
| @Override |
| public void execute(ClientTransactionHandler client, IBinder token, PendingTransactionActions pendingActions) { |
| client.handleLaunchActivity(new LaunchActivityItem.ActivityClientRecord(this), pendingActions, null); |
| } |
- 调用ClientTransactionHandler即
ActivityThread
的handleLaunchActivity方法
5.6 回到ActivityThread
Android14的ActivityThread源码地址
| public Activity handleLaunchActivity(ActivityClientRecord r, PendingTransactionActions pendingActions, Intent customIntent) { |
| |
| final Activity a = performLaunchActivity(r, customIntent); |
| } |
| |
| private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) { |
| |
| activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent); |
| } |
| |
5.6.1 Instrumentation.java
Android14的Instrumentation源码地址
| public Activity newActivity(...) { |
| |
| Activity activity = (Activity)clazz.newInstance(); |
| ... |
| return activity; |
| } |
| private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) { |
| |
| activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent); |
| |
| activity.attach(appContext, this, getInstrumentation(), r.token,...); |
| |
| mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState); |
| } |
5.6.3 Instrumentation的callActivityOnCreate方法
| public void callActivityOnCreate(Activity activity, Bundle icicle) { |
| |
| activity.performCreate(icicle); |
| } |
5.7 Activity.java
Android14的Activity源码地址
5.7.1 onCreate方法
| final void performCreate(...) { |
| |
| if (persistentState != null) { |
| onCreate(icicle, persistentState); |
| } else { |
| onCreate(icicle); |
| } |
| } |
- 绕了一大圈,最终又回到了Activity.java
- 在performCreate中调用onCreate生命周期方法
5.7.2 onStart方法
5.7.2.1 TransactionExecutor.java
| public void execute(ClientTransaction transaction) { |
| |
| executeCallbacks(transaction); |
| |
| executeLifecycleState(transaction); |
| } |
| |
| public void executeLifecycleState(ClientTransaction transaction) { |
| final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest(); |
| if (lifecycleItem != null) { |
| |
| lifecycleItem.execute(transaction.getClientTransactionHandler(), token, pendingActions); |
| } |
| } |
| |
ActivityResultItem
是一个抽象类
- 这里实际调用的是
ActivityResultItem
的execute方法
5.7.2.2 ActivityResultItem.java
Android14的ActivityResultItem源码地址
| public void execute(ClientTransactionHandler client, IBinder token, |
| PendingTransactionActions pendingActions) { |
| client.handleResumeActivity(token, true , "RESUME_ACTIVITY"); |
| } |
- 这里实际调用的是
ActivityThread
的handleResumeActivity方法
5.7.2.3 ActivityThread的handleResumeActivity方法
Android14的ActivityThread源码地址
| public void handleResumeActivity(IBinder token, boolean finalStateRequest, String reason) { |
| |
| performRestartActivity(r); |
| |
| r.activity.performResume(); |
| } |
| |
| public void performRestartActivity(ActivityClientRecord r) { |
| |
| r.activity.performStart(); |
| } |
| |
| |
Android14的Activity源码地址
| final void performStart() { |
| |
| mInstrumentation.callActivityOnStart(this); |
| } |
5.7.2.5 Instrumentation的callActivityOnStart方法
Android14的Instrumentation源码地址
| public void callActivityOnStart(Activity activity) { |
| activity.onStart(); |
| } |
5.7.3 onResume方法
在5.7.2.3 ActivityThread的handleResumeActivity方法
中提到在onStart方法执行后会调用r.activity.performResume();
即Activity的performResume方法
Android14的Activity源码地址
| final void performResume(boolean followedByPause, String reason) { |
| mInstrumentation.callActivityOnResume(this); |
| } |
5.7.3.2 Instrumentation的callActivityOnResume方法
Android14的Instrumentation源码地址
| public void callActivityOnResume(Activity activity) { |
| activity.onResume(); |
| } |
- 至此Activity创建完成,并完成了核心生命周期方法的创建
- 在onResume方法后,Activity进入前台,准备显示给用户
六、 后续工作
在生命周期完成后,应用程序就会被展示在屏幕上,后续的工作主要是渲染,这里做一个简单的流程说明
- Activity实例化时创建一个Window对象,默认情况下是PhoneWindow。在PhoneWindow中,有一个 DecorView,它是整个视图层次的根视图。
- 在Activity的onCreate方法中,Activity会调用setContentView方法,将布局资源加载到DecorView中
- WindowManager负责管理应用程序窗口,将DecorView添加到窗口中
- 当DecorView被添加到窗口中后。ViewRootImpl类负责视图层次结构的测量(measure)、布局(layout)和绘制(draw)
- 最终由SurfaceFlinger合成并显示在屏幕上
以上就是应用程序启动的全过程,如有错漏,欢迎留言讨论。
【推荐】编程新体验,更懂你的AI,立即体验豆包MarsCode编程助手
【推荐】凌霞软件回馈社区,博客园 & 1Panel & Halo 联合会员上线
【推荐】抖音旗下AI助手豆包,你的智能百科全书,全免费不限次数
【推荐】博客园社区专享云产品让利特惠,阿里云新客6.5折上折
【推荐】轻量又高性能的 SSH 工具 IShell:AI 加持,快人一步
· 一个费力不讨好的项目,让我损失了近一半的绩效!
· 实操Deepseek接入个人知识库
· CSnakes vs Python.NET:高效嵌入与灵活互通的跨语言方案对比
· 【.NET】调用本地 Deepseek 模型
· Plotly.NET 一个为 .NET 打造的强大开源交互式图表库