0
0

Android应用启动流程：从启动到可交互的过程解析

关于作者：CSDN内容合伙人、技术专家， 从零开始做日活千万级APP。
专注于分享各领域原创系列文章 ，擅长java后端、移动开发、人工智能等，希望大家多多支持。

目录

在这里插入图片描述

一、导读

我们继续总结学习Android 基础知识，温故知新。

还是在多年前做系统应用开发的时候，通过编译源码学习了一遍APP的启动过程，
最近在整理应用启动优化相关的文档，打算重新梳理一遍，并整理成一个通俗易懂的文档，以备后面查看。
在学习过程中，大家最好是把源码下载下来。

1.1 启动知识储备

启动过程比较复杂，涉及到的知识点非常多，建议通过其他文章进行学习。

1.2 Zygote进程

Zygote进程是Android设备启动时由init进程创建和启动，之后不断接收来自应用程序的请求。
Zygote进程预先创建一个虚拟机和一些共享资源，以提高应用程序的启动速度和系统资源的利用效率。
同时，Zygote进程也负责处理应用程序进程的环境初始化和加载核心类库等操作。
每当有新的应用程序启动请求到达时，Zygote进程会fork出一个子进程（应用程序进程）来运行该应用程序。

1.3 SystemServer进程

SystemServer进程是Android操作系统的一个关键进程，它在设备启动时由init进程创建的。

SystemServer进程是一个守护进程，在系统运行期间一直存在，负责启动和管理各个核心系统服务，如AMS、Window Manager、Package Manager等。

1.4 AMS（Activity Manager Service）

AMS（Activity Manager Service）是SystemServer进程中的一个关键组件，负责管理所有应用程序的生命周期和交互。它监控应用程序的启动、暂停、恢复和销毁，
并协调应用程序之间的切换和交互。除此之外，AMS还处理任务栈管理、权限管理、用户通知等相关任务。

1.5 APP进程（ActivityThread）

APP进程是指在Android系统中运行的应用程序进程。每个运行的应用程序都会分配一个或多个独立的APP进程来承载应用的执行环境。
每个APP进程都是Zygote进程通过fork系统调用创建的子进程。

ActivityThread 是Android应用程序的主线程，负责管理和调度应用程序中的所有Activity的生命周期以及处理一些系统事件。

ActivityThread的主要职责包括：

  1. 创建和启动应用程序的主Activity。
  2. 处理应用程序的消息循环，接收和分发来自系统和应用程序的消息。
  3. 管理应用程序的所有Activity的生命周期，包括创建、启动、暂停、恢复、停止和销毁等。
  4. 处理应用程序的资源加载和更新，包括布局文件、图片、字符串等资源的加载。
  5. 处理应用程序的窗口管理，包括窗口的创建、显示、隐藏和更新等操作。
  6. 与AMS (Activity Manager Service)通信，处理Activity的启动、停止、切换等请求，并接收来自AMS的指令和请求。
  7. 处理应用程序的异常错误，包括崩溃、ANR (Application Not Responding)等情况的处理。

二、启动流程概览

涉及到多个进程之间的通信：
1、用户点击图标后，Laucher（手机桌面）会通过binder的方式通知SystemServer进程。
2、SystemServer收到信息，内部的AMS（Activity Manager Service）通知Zygote去创建APP进程，通过反射调用ActivityThread.main方法，即创建主线程。
3、APP进程创建后（Zygote进行fork），通过回调通知AMS。
4、AMS收到信息后经过一些列调用，通知APP进程（ActivityThread）创建Application
5、Application 之后，继续执行调用到ClientLifecycleManager，进行Activity创建等过程

我们画个简单的图
图片
在这里插入图片描述

下面贴一下代码：

2.1 用户点击桌面图标

Launcher获取到AMS的binder，之后进入到SystemServer进程。

然后调用的zygote进程，fork出一个新的app进程。

2.2 创建app进程

ActivityThread


应用进程启动的入口函数main()方法中，会调用Looper相关的初始化和循环方法，从而让主线程的Looper进入循环状态，保证app进程的一直运行状态

    publicstaticvoidmain(String[] args){...//looper绑定主线程Looper.prepareMainLooper();
        
        创建ActivityThreadActivityThread thread =newActivityThread();
        thread.attach(false, startSeq);//looper开启无限循环读取消息Looper.loop();...}privatevoidattach(boolean system,long startSeq){if(!system){...finalIActivityManager mgr =ActivityManager.getService();try{// 通知 AMS， 并将当前进程的binder句柄传给AMS绑定管理起来
                mgr.attachApplication(mAppThread, startSeq);}catch(RemoteException ex){}...}...}

attachApplication 这个流程会分两步:
1、创建应用的application对象
2、activity启动显示

2.3 创建 application

IActivityManager.aidl

voidattachApplication(in IApplicationThread app,long startSeq);

ActivityManagerService

// 这里接受APP传递过来的消息@OverridepublicfinalvoidattachApplication(IApplicationThread thread,long startSeq){synchronized(this){// 通过 Binder 获取 PID ，PID和UID都是进程创建应用的时候系统指定的int callingPid =Binder.getCallingPid();finalint callingUid =Binder.getCallingUid();finallong origId =Binder.clearCallingIdentity();attachApplicationLocked(thread, callingPid, callingUid, startSeq);}}@GuardedBy("this")privatefinalbooleanattachApplicationLocked(IApplicationThread thread,int pid,int callingUid,long startSeq){// *** 1、通知APP进程进行初始化操作，初始化application，创建应用进程的application对象if(app.isolatedEntryPoint !=null){}elseif(app.instr !=null){
            thread.bindApplication(processName, appInfo, providers,...);}else{
            thread.bindApplication(processName, appInfo, providers,...);}// *** 2、 通知APP拉起指定的MainActivity，调用ATMS的启动页面的方法，后面继续介绍// See if the top visible activity is waiting to run in this process...if(normalMode){try{if(mStackSupervisor.attachApplicationLocked(app)){
                    didSomething =true;}}catch(Exception e){}}}

IApplicationThread.aidl

voidbindApplication(in String packageName, in ApplicationInfo info,...);

我们来看看 Application 是如何创建的
ActivityThread


由AMS调用过来，具体看上面的代码
publicfinalvoidbindApplication(String processName,ApplicationInfo appInfo,...){sendMessage(H.BIND_APPLICATION, data);}publicvoidhandleMessage(Message msg){switch(msg.what){caseBIND_APPLICATION:AppBindData data =(AppBindData)msg.obj;handleBindApplication(data);break;...}}privatevoidhandleBindApplication(AppBindData data){Application app;try{
        classLoader加载APK中的dex，并且加载APK的资源
        finalLoadedApk pi =getPackageInfo(instrApp, data.compatInfo,
                appContext.getClassLoader(),false,true,false);finalContextImpl instrContext =ContextImpl.createAppContext(this, pi);

        通过 calssLoader 来创建 application 对象
        app=data.info.makeApplication(data.restrictedBackupMode,null);try{
            调用Application的onCreate
        
            mInstrumentation.onCreate(data.instrumentationArgs);}catch(Exception e){}try{
            mInstrumentation.callApplicationOnCreate(app);}catch(Exception e){}}...}publicApplicationnewApplication(ClassLoader cl,String className,Context context) 。。{Application app =getFactory(context.getPackageName()).instantiateApplication(cl, className);
    app.attach(context);return app;}(Application) cl.loadClass(className).newInstance();

在这里插入图片描述

2.4 activity启动显示

接着上面的代码 mStackSupervisor.attachApplicationLocked(app)；

ActivityStackSupervisor
方法realStartActivityLocked();

booleanattachApplicationLocked(ProcessRecord app)throwsRemoteException{finalString processName = app.processName;boolean didSomething =false;Activity启动的入口
        try{if(realStartActivityLocked(activity, app, top == activity,true)){}}catch(RemoteException e){}return didSomething;}

    真的开始启动 activity
    finalbooleanrealStartActivityLocked(ActivityRecord r,ProcessRecord app,boolean andResume,boolean checkConfig)throwsRemoteException{// Create activity launch transaction.finalClientTransaction clientTransaction =ClientTransaction.obtain(app.thread,
                    r.appToken);
                    clientTransaction.addCallback(LaunchActivityItem.obtain(newIntent(r.intent),System.identityHashCode(r), r.info,// TODO: Have this take the merged configuration instead of separate global// and override configs.
                    mergedConfiguration.getGlobalConfiguration(),
                    mergedConfiguration.getOverrideConfiguration(), r.compat,
                    r.launchedFromPackage, task.voiceInteractor, app.repProcState, r.icicle,
                    r.persistentState, results, newIntents, mService.isNextTransitionForward(),
                    profilerInfo));// Schedule transaction.
            mService.getLifecycleManager().scheduleTransaction(clientTransaction);}

ActivityManagerService

ClientLifecycleManagergetLifecycleManager(){return mLifecycleManager;}

ClientLifecycleManager

    通过代码，我们可以看到，获取的client就是 ActivityThread，IApplicationThread是一个AIDL文件
    voidscheduleTransaction(ClientTransaction transaction)throwsRemoteException{finalIApplicationThread client = transaction.getClient();
        transaction.schedule();}

ClientTransaction

/** Target client. */privateIApplicationThread mClient;publicvoidschedule()throwsRemoteException{
        mClient.scheduleTransaction(this);}

ClientTransactionHandler

//ActivityThread中没有复写scheduleTransaction，会执行到父类的方法//public final class ActivityThread extends ClientTransactionHandler//ClientTransactionHandler.javapublicabstractclassClientTransactionHandler{voidscheduleTransaction(ClientTransaction transaction){
            transaction.preExecute(this);//发送消息sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);}}

ActivityThread.java

caseEXECUTE_TRANSACTION:finalClientTransaction transaction =(ClientTransaction) msg.obj;
        mTransactionExecutor.execute(transaction);break;

继续一系列调用
在这里插入图片描述

最后调用到ActivityThread，创建并启动Activity，由于篇幅原因，Activity资源加载相关的内容我们在另一篇文章介绍。

/**
     * Extended implementation of activity launch. Used when server requests a launch or relaunch.
     */@OverridepublicActivityhandleLaunchActivity(ActivityClientRecord r,PendingTransactionActions pendingActions,Intent customIntent){finalActivity a =performLaunchActivity(r, customIntent);return a;}Activity实例化过程
    
    /**  Core implementation of activity launch. */privateActivityperformLaunchActivity(ActivityClientRecord r,Intent customIntent){Activity activity =null;try{// 通过反射实例化Activity对象java.lang.ClassLoader cl = appContext.getClassLoader();
            activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent);}catch(Exception e){}
        
        window
            
        theme
        
        //当实例化Activity对象后，继续执行callActivityOnCreateif(r.isPersistable()){
            mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);}else{
            mInstrumentation.callActivityOnCreate(activity, r.state);}}

接下来就是执行 Activity 生命周期函数

所用的源码不同，代码可能会有些许差别。

三、 推荐阅读

Java 专栏

SQL 专栏

数据结构与算法

Android学习专栏

标签： android 面试 启动流程
本文转载自: https://blog.csdn.net/fumeidonga/article/details/132146863
版权归原作者 Android西红柿 所有， 如有侵权，请联系我们删除。
登录后发布评论

“Android应用启动流程：从启动到可交互的过程解析”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

Linux 再入门整理：详解 /etc/fstab 文件

HBase Java API编程-学习记录

【大数据技术基础 | 实验十二】Hive实验：Hive分区

【前端】CSS

python 爬虫 入门 五、抓取图片、视频

Docker 中使用环境变量的安全实践

[Linux]——常见指令（中）

文章导航