Android的Activity启动流程分析

最新推荐文章于 2024-08-20 16:30:17 发布
最新推荐文章于 2024-08-20 16:30:17 发布
阅读量4.8w 收藏 387
点赞数 82
分类专栏： Android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012267215/article/details/91406211
版权

 

 

 

 

 

 

 

 


---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------


--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 

  • app进程通过ActivityManager.getService （高版本）或者 ActivityManagerNative.getDefault（低版本）返回的IActivityManager来调用系统进程AMS中的方法。该IActivityManager是AMS在app进程的binder代理对象
  • 同样，系统进程通过ProcessRecord.IApplicationThread调用app进程相关方法。IApplicationThread是系统进程持有的app进程中ApplicationThread的Binder代理对象。
  • AMS通过binder代理调用到ApplicationThread（ActivityThread的内部类）中的方法后，通过主线程（ActivityThread中的main方法）中开启的handler消息轮询来通知主线程调用相关方法。主线程的相关声明周期方法的具体实现会委托给Instrumentation类实现，在Instrumentation类中，会调用具体组件的相关生命周期方法。

Activity启动之前的一些事情

  • init进程：init是所有linux程序的起点，是Zygote的父进程。解析init.rc孵化出Zygote进程。

  • Zygote进程：Zygote是所有Java进程的父进程，所有的App进程都是由Zygote进程fork生成的。

  • SystemServer进程：System Server是Zygote孵化的第一个进程。SystemServer负责启动和管理整个Java framework，包含AMS，PMS等服务。

  • Launcher：Zygote进程孵化的第一个App进程是Launcher。

    1.init进程是什么？

    Android是基于linux系统的，手机开机之后，linux内核进行加载。加载完成之后会启动init进程。
    init进程会启动ServiceManager，孵化一些守护进程，并解析init.rc孵化Zygote进程。

    2.Zygote进程是什么？

    所有的App进程都是由Zygote进程fork生成的，包括SystemServer进程。Zygote初始化后，会注册一个等待接受消息的socket，OS层会采用socket进行IPC通信。

    3.为什么是Zygote来孵化进程，而不是新建进程呢？

    每个应用程序都是运行在各自的Dalvik虚拟机中，应用程序每次运行都要重新初始化和启动虚拟机，这个过程会耗费很长时间。Zygote会把已经运行的虚拟机的代码和内存信息共享，起到一个预加载资源和类的作用，从而缩短启动时间。

Activity启动阶段

涉及到的概念

  • 进程：Android系统为每个APP分配至少一个进程
  • IPC：跨进程通信，Android中采用Binder机制。

涉及到的类

  • ActivityStack：Activity在AMS的栈管理，用来记录已经启动的Activity的先后关系，状态信息等。通过ActivityStack决定是否需要启动新的进程。
  • ActivitySupervisor：管理 activity 任务栈
  • ActivityThread：ActivityThread 运行在UI线程（主线程），App的真正入口。
  • ApplicationThread：用来实现AMS和ActivityThread之间的交互。
  • ApplicationThreadProxy：ApplicationThread 在服务端的代理。AMS就是通过该代理与ActivityThread进行通信的。
  • IActivityManager：继承与IInterface接口，抽象出跨进程通信需要实现的功能
  • AMN：运行在server端（SystemServer进程）。实现了Binder类，具体功能由子类AMS实现。
  • AMS：AMN的子类，负责管理四大组件和进程，包括生命周期和状态切换。AMS因为要和ui交互，所以极其复杂，涉及window。
  • AMP：AMS的client端代理（app进程）。了解Binder知识可以比较容易理解server端的stub和client端的proxy。AMP和AMS通过Binder通信。
  • Instrumentation：仪表盘，负责调用Activity和Application生命周期。测试用到这个类比较多。
  • ActivityStackSupervisor
    负责所有Activity栈的管理。内部管理了mHomeStack、mFocusedStack和mLastFocusedStack三个Activity栈。其中，mHomeStack管理的是Launcher相关的Activity栈；mFocusedStack管理的是当前显示在前台Activity的Activity栈；mLastFocusedStack管理的是上一次显示在前台Activity的Activity栈。
     



 

ActivityThread.java    路径位于：\frameworks\base\core\java\android\app\ActivityThread.java

         说明： 该类为应用程序(即APK包)所对应进程(一个进程里可能有多个应用程序)的主线程类，即我们通常所说的UI线程。

           一个ActivityThread类对应于一个进程。最重要的是，每个应用程序的入口是该类中的static main()函数 。

 Instrumentation.java  路径位于 ：\frameworks\base\core\java\android\app\ActivityThread.java

         说明： 该类用于具体操作某个Activity的功能----单向(oneway)调用AMS以及统计、测量该应用程序的所有开销。

            一个Instrumentation类对应于一个进程。每个Activity内部都有一个该Instrumentation对象的引用。

 

      举个例子吧。

           我们将我们应用程序比作一个四合院，那么Activity对应于四合院的人，ActivithThread对应于院子的主人----管理所有人，

    Instrumentation对应于管家------受气的命，接受来自人(Activity/ActivithThread)的命令 ，去单向(oneway)调用AMS 。
 

ApplicationThread类是ActivityThread的内部类：

       说明：该类是一个Binder类，即可实现跨进程通信。主要用于接受从AMS传递过来的消息，继而做相应处理。

具体流程

  • Launcher：Launcher通知AMS要启动activity。
    • startActivitySafely->startActivity->Instrumentation.execStartActivity()(AMP.startActivity)->AMS.startActivity
  • AMS:PMS的resoveIntent验证要启动activity是否匹配。
    • 如果匹配，通过ApplicationThread发消息给Launcher所在的主线程，暂停当前Activity(Launcher);
  • 暂停完，在该activity还不可见时，通知AMS，根据要启动的Activity配置ActivityStack。然后判断要启动的Activity进程是否存在?
    • 存在：发送消息LAUNCH_ACTIVITY给需要启动的Activity主线程，执行handleLaunchActivity
    • 不存在：通过socket向zygote请求创建进程。进程启动后，ActivityThread.attach
  • 判断Application是否存在，若不存在，通过LoadApk.makeApplication创建一个。在主线程中通过thread.attach方法来关联ApplicationThread。
  • 在通过ActivityStackSupervisor来获取当前需要显示的ActivityStack。
  • 继续通过ApplicationThread来发送消息给主线程的Handler来启动Activity（handleLaunchActivity）。
  • handleLauchActivity：调用了performLauchActivity，里边Instrumentation生成了新的activity对象，继续调用activity生命周期。

IPC过程：

双方都是通过对方的代理对象来进行通信。
1.app和AMS通信：app通过本进程的AMP和AMS进行Binder通信
2.AMS和新app通信：通过ApplicationThreadProxy来通信，并不直接和ActivityThread通信

参考函数流程

Activity启动流程（从Launcher开始）：

第一阶段： Launcher通知AMS要启动新的Activity（在Launcher所在的进程执行）

  • Launcher.startActivitySafely //首先Launcher发起启动Activity的请求
  • Activity.startActivity
  • Activity.startActivityForResult
  • Instrumentation.execStartActivity //交由Instrumentation代为发起请求
  • ActivityManager.getService().startActivity //通过IActivityManagerSingleton.get()得到一个AMP代理对象
  • ActivityManagerProxy.startActivity //通过AMP代理通知AMS启动activity

第二阶段：AMS先校验一下Activity的正确性，如果正确的话，会暂存一下Activity的信息。然后，AMS会通知Launcher程序pause Activity（在AMS所在进程执行）

  • ActivityManagerService.startActivity
  • ActivityManagerService.startActivityAsUser
  • ActivityStackSupervisor.startActivityMayWait
  • ActivityStackSupervisor.startActivityLocked ：检查有没有在AndroidManifest中注册
  • ActivityStackSupervisor.startActivityUncheckedLocked
  • ActivityStack.startActivityLocked ：判断是否需要创建一个新的任务来启动Activity。
  • ActivityStack.resumeTopActivityLocked ：获取栈顶的activity，并通知Launcher应该pause掉这个Activity以便启动新的activity。
  • ActivityStack.startPausingLocked
  • ApplicationThreadProxy.schedulePauseActivity

第三阶段： pause Launcher的Activity，并通知AMS已经paused（在Launcher所在进程执行）

  • ApplicationThread.schedulePauseActivity
  • ActivityThread.queueOrSendMessage
  • H.handleMessage
  • ActivityThread.handlePauseActivity
  • ActivityManagerProxy.activityPaused

第四阶段：检查activity所在进程是否存在，如果存在，就直接通知这个进程，在该进程中启动Activity；不存在的话，会调用Process.start创建一个新进程（执行在AMS进程）

  • ActivityManagerService.activityPaused
  • ActivityStack.activityPaused
  • ActivityStack.completePauseLocked
  • ActivityStack.resumeTopActivityLocked
  • ActivityStack.startSpecificActivityLocked
  • ActivityManagerService.startProcessLocked
  • Process.start //在这里创建了新进程，新的进程会导入ActivityThread类，并执行它的main函数

第五阶段： 创建ActivityThread实例，执行一些初始化操作，并绑定Application。如果Application不存在，会调用LoadedApk.makeApplication创建一个新的Application对象。之后进入Loop循环。（执行在新创建的app进程）

  • ActivityThread.main
  • ActivityThread.attach(false) //声明不是系统进程
  • ActivityManagerProxy.attachApplication

第六阶段：处理新的应用进程发出的创建进程完成的通信请求，并通知新应用程序进程启动目标Activity组件（执行在AMS进程）

  • ActivityManagerService.attachApplication //AMS绑定本地ApplicationThread对象，后续通过ApplicationThreadProxy来通信。
  • ActivityManagerService.attachApplicationLocked
  • ActivityStack.realStartActivityLocked //真正要启动Activity了！
  • ApplicationThreadProxy.scheduleLaunchActivity //AMS通过ATP通知app进程启动Activity

第七阶段： 加载MainActivity类，调用onCreate声明周期方法（执行在新启动的app进程）

  • ApplicationThread.scheduleLaunchActivity //ApplicationThread发消息给AT
  • ActivityThread.queueOrSendMessage
  • H.handleMessage //AT的Handler来处理接收到的LAUNCH_ACTIVITY的消息
  • ActivityThread.handleLaunchActivity
  • ActivityThread.performLaunchActivity
  • Instrumentation.newActivity //调用Instrumentation类来新建一个Activity对象
  • Instrumentation.callActivityOnCreate
  • MainActivity.onCreate
  • ActivityThread.handleResumeActivity
  • AMP.activityResumed
  • AMS.activityResumed(AMS进程)


  • ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------​​​​​​​


     

    一:开始请求执行启动Activity


    MyActivity.startActivity() 
    Activity.startActivity() 
    Activity.startActivityForResult 
    Instrumentation.execStartActivty 
    ActivityManagerNative.getDefault().startActivityAsUser() 

    二：ActivityManagerService接收启动Activity的请求


    ActivityManagerService.startActivity() 
    ActvityiManagerService.startActivityAsUser() 
    ActivityStackSupervisor.startActivityMayWait() 
    ActivityStackSupervisor.startActivityLocked() 
    ActivityStackSupervisor.startActivityUncheckedLocked() 
    ActivityStackSupervisor.startActivityLocked() 
    ActivityStackSupervisor.resumeTopActivitiesLocked() 
    ActivityStackSupervisor.resumeTopActivityInnerLocked() 
     

  • 三：执行栈顶Activity的onPause方法


    ActivityStack.startPausingLocked() 
    IApplicationThread.schudulePauseActivity() 
    ActivityThread.sendMessage() 
    ActivityThread.H.sendMessage(); 
    ActivityThread.H.handleMessage() 
    ActivityThread.handlePauseActivity() 
    ActivityThread.performPauseActivity() 
    Activity.performPause() 
    Activity.onPause() 
    ActivityManagerNative.getDefault().activityPaused(token) 
    ActivityManagerService.activityPaused() 
    ActivityStack.activityPausedLocked() 
    ActivityStack.completePauseLocked() 
    ActivityStack.resumeTopActivitiesLocked() 
    ActivityStack.resumeTopActivityLocked() 
    ActivityStack.resumeTopActivityInnerLocked() 
    ActivityStack.startSpecificActivityLocked 

    四：启动Activity所属的应用进程

    关于如何启动应用进程，前面的一篇文章已经做了介绍，可参考： android源码解析之（十一）–>应用进程启动流程 这里在简单的介绍一下


    ActivityManagerService.startProcessLocked() 
    Process.start() 
    ActivityThread.main() 
    ActivityThread.attach() 
    ActivityManagerNative.getDefault().attachApplication() 
    ActivityManagerService.attachApplication() 

    五：执行启动Acitivity


    ActivityStackSupervisor.attachApplicationLocked() 
    ActivityStackSupervisor.realStartActivityLocked() 
    IApplicationThread.scheduleLauncherActivity() 
    ActivityThread.sendMessage() 
    ActivityThread.H.sendMessage() 
    ActivityThread.H.handleMessage() 
    ActivityThread.handleLauncherActivity() 
    ActivityThread.performLauncherActivity() 
    Instrumentation.callActivityOnCreate() 
    Activity.onCreate() 
    ActivityThread.handleResumeActivity() 
    ActivityThread.performResumeActivity() 
    Activity.performResume() 
    Instrumentation.callActivityOnResume() 
    Activity.onResume() 
    ActivityManagerNative.getDefault().activityResumed(token) 

    六：栈顶Activity执行onStop方法


    Looper.myQueue().addIdleHandler(new Idler()) 
    Idler.queueIdle() 
    ActivityManagerNative.getDefault().activityIdle() 
    ActivityManagerService.activityIdle() 
    ActivityStackSupervisor.activityIdleInternalLocked() 
    ActivityStack.stopActivityLocked() 
    IApplicationThread.scheduleStopActivity() 
    ActivityThread.scheduleStopActivity() 
    ActivityThread.sendMessage() 
    ActivityThread.H.sendMessage() 
    ActivityThread.H.handleMessage() 
    ActivityThread.handleStopActivity() 
    ActivityThread.performStopActivityInner() 
    ActivityThread.callCallActivityOnSaveInstanceState() 
    Instrumentation.callActivityOnSaveInstanceState() 
    Activity.performSaveInstanceState() 
    Activity.onSaveInstanceState() 
    Activity.performStop() 
    Instrumentation.callActivityOnStop() 
    Activity.onStop() 

     

    总结：

  • Activity的启动流程一般是通过调用startActivity或者是startActivityForResult来开始的

  • startActivity内部也是通过调用startActivityForResult来启动Activity，只不过传递的requestCode小于0

  • Activity的启动流程涉及到多个进程之间的通讯这里主要是ActivityThread与ActivityManagerService之间的通讯

  • ActivityThread向ActivityManagerService传递进程间消息通过ActivityManagerNative，ActivityManagerService向ActivityThread进程间传递消息通过IApplicationThread。

  • ActivityManagerService接收到应用进程创建Activity的请求之后会执行初始化操作，解析启动模式，保存请求信息等一系列操作。

  • ActivityManagerService保存完请求信息之后会将当前系统栈顶的Activity执行onPause操作，并且IApplication进程间通讯告诉应用程序继承执行当前栈顶的Activity的onPause方法；

  • ActivityThread接收到SystemServer的消息之后会统一交个自身定义的Handler对象处理分发；

  • ActivityThread执行完栈顶的Activity的onPause方法之后会通过ActivityManagerNative执行进程间通讯告诉ActivityManagerService，栈顶Actiity已经执行完成onPause方法，继续执行后续操作；

  • ActivityManagerService会继续执行启动Activity的逻辑，这时候会判断需要启动的Activity所属的应用进程是否已经启动，若没有启动则首先会启动这个Activity的应用程序进程；

  • ActivityManagerService会通过socket与Zygote继承通讯，并告知Zygote进程fork出一个新的应用程序进程，然后执行ActivityThread的mani方法；

  • 在ActivityThead.main方法中执行初始化操作，初始化主线程异步消息，然后通知ActivityManagerService执行进程初始化操作；

  • ActivityManagerService会在执行初始化操作的同时检测当前进程是否有需要创建的Activity对象，若有的话，则执行创建操作；

  • ActivityManagerService将执行创建Activity的通知告知ActivityThread，然后通过反射机制创建出Activity对象，并执行Activity的onCreate方法，onStart方法，onResume方法；

  • ActivityThread执行完成onResume方法之后告知ActivityManagerService onResume执行完成，开始执行栈顶Activity的onStop方法；

  • ActivityManagerService开始执行栈顶的onStop方法并告知ActivityThread；

  • ActivityThread执行真正的onStop方法；


    ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
     

  • 启动流程进程间简单分析：

    Zygote进程 –> SystemServer进程 –> 各种系统服务 –> 应用进程 
    在Actvity启动过程中，其实是应用进程与SystemServer进程相互配合启动Activity的过程，其中应用进程主要用于执行具体的Activity的启动过程，回调生命周期方法等操作，而SystemServer进程则主要是调用其中的各种服务，将Activity保存在栈中，协调各种系统资源等操作。
    通过ActivityManagerNative –> ActivityManagerService实现了应用进程与SystemServer进程的通讯 
    通过AppicationThread <– IApplicationThread实现了SystemServer进程与应用进程的通讯
  1. ActivityManagerProxy相当于Proxy
  2. ActivityManagerNative就相当于Stub
  3. ActivityManagerService是ActivityManagerNative的具体实现，换句话说，就是AMS才是服务端的具体实现！
  4. ApplicationThreadProxy相当于Proxy
  5. ApplicationThreadNative相当于Stub
  6. ApplicationThread相当于服务器端，代码真正的实现者！
  • 点击桌面App图标，Launcher进程采用Binder IPC向system_server进程发起startActivity请求；
  • system_server进程接收到请求后，向zygote进程发送创建进程的请求；
  • Zygote进程fork出新的子进程，即App进程；
  • App进程，通过Binder IPC向sytem_server进程发起attachApplication请求；
  • system_server进程在收到请求后，进行一系列准备工作后，再通过binder IPC向App进程发送scheduleLaunchActivity请求；
  • App进程的binder线程（ApplicationThread）在收到请求后，通过handler向主线程发送LAUNCH_ACTIVITY消息；
  • 主线程在收到Message后，通过发射机制创建目标Activity，并回调Activity.onCreate()等方法。

  • 到此，App便正式启动，开始进入Activity生命周期，执行完onCreate/onStart/onResume方法，UI渲染结束后便可以看到App的主界面。
    ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------​​​​​​​ 

Launch Mode

先来说说在ActivityInfo.java中定义了4类Launch Mode：

  • LAUNCH_MULTIPLE(standard)：最常见的情形，每次启动Activity都是创建新的Activity;
  • LAUNCH_SINGLE_TOP: 当Task顶部存在同一个Activity则不再重新创建；其余情况同上；
  • LAUNCH_SINGLE_TASK：当Task栈存在同一个Activity(不在task顶部)，则不重新创建，而移除该Activity上面其他的Activity；其余情况同上；
  • LAUNCH_SINGLE_INSTANCE：每个Task只有一个Activity.

再来说说几个常见的flag含义：

  • FLAG_ACTIVITY_NEW_TASK：将Activity放入一个新启动的Task；
  • FLAG_ACTIVITY_CLEAR_TASK：启动Activity时，将目标Activity关联的Task清除，再启动新Task，将该Activity放入该Task。该flags跟FLAG_ACTIVITY_NEW_TASK配合使用。
  • FLAG_ACTIVITY_CLEAR_TOP：启动非栈顶Activity时，先清除该Activity之上的Activity。例如Task已有A、B、C3个Activity，启动A，则清除B，C。类似于SingleTop。

最后再说说：设置FLAG_ACTIVITY_NEW_TASK的几个情况：

 

  • 调用者并不是Activity context；
  • 调用者activity带有single instance；
  • 目标activity带有single instance或者single task；
  • 调用者处于finishing状态；

    ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------​​​​​​​

1、新的Activity类是通过类加载器方式即通过反射的方式生成的，我们可以看一下mInstrumentation.newActivity()方法：

public Activity newActivity(ClassLoader cl, String className, Intent intent)
            throws InstantiationException, IllegalAccessException, ClassNotFoundException {
    return (Activity)cl.loadClass(className).newInstance();
}

最后调用mInstrumentation.callActivityOnCreate()
 

2、在mInstrumentation.callActivityOnStart(this)方法里面就会显式调用Activtiy的onStart()方法！

到这里我们也可以基本解决第二个问题：Activity的生命周期方法是通过Instrumentation类调用callActivityOnXXX方法最终调用Activity的onCreate等方法，调用时机为ActivityThread#performLaunchActivitiy()方法中。

3、ActivityThread#performResumeActivity()
  --> Activity#performResume()
    --> Instrumentation#callActivityOnResume()
      --> Activity#onResume()
另外，观察执行handleResumeActivity()之后的代码，会发现程序会开始获取DecorView，执行addView()方法，里面最终会调用到ViewRootImpl#performTraversals()，即开始绘制view界面！
这里我们就解决了第三个问题：界面的绘制是在执行Activity#onResume()之后！

4、ActivityThread的main方法是在生成一个新的app进程过程中调用的，具体是通过与Zygote通信，之后通过RuntimeInit类采用反射的方式调用ActivityThread#main()方法，即生成app中的主线程（UI线程）！

 

内容引自如下：

https://blog.csdn.net/qinjuning/article/details/7262769

https://www.jianshu.com/p/dc6b0ead30aa

https://www.jianshu.com/p/274ccb315a7a

https://www.cnblogs.com/zl1991/p/6883517.html

https://www.cnblogs.com/ldq2016/p/6891009.html

https://blog.csdn.net/lj19851227/article/details/82562115​​​​​​​

https://www.jianshu.com/p/86ad1026cef3

 

Android：Context完全解析，你所不知道的Context的各种细节
微不足道的博客
12-17 2018
Context的各种细节
Android Activity启动过程分析
sd_zhuzhipeng的专栏
08-06 3093
当我们在一个Activity中（或通过Context对象），调用startActivity()方法来启动另一个Activity的工程中发发生了什么呢？这就是本文想跟大家分享的内容，我们一起通过源码的方式来看下Activity的启动过程（本文是基于Android Q源码）。  启动Activity的流程大体分为两步：找到要启动的Activity；然后启动它。（虽说有点像如何把大象装进冰箱，但也确实是那么回事，只不过每个步骤有更多细节） 找到Activity  要想启动一个Activity，系统先要找到这个.
Android Activity启动流程(Android 13)
最新发布
xiangxiongfly
08-20 1308
文章目录Android Activity启动流程(Android 13)概述执行流程前提流程分析Activity#startActivity()Activity#startActivityForResult()Instrumentation#execStartActivity()ActivityTaskManager#getService()ActivityTaskManagerService#startActivity()ActivityTaskManagerService#startActivityAs
Activity启动流程
diaoxiao8834的博客
03-05 148
Activity启动过程中做了哪些事情？下面的时序图展示里启动过程中函数的调用过程, 从图中可以知道大概流程。 在介绍细节的时候是从上往下函数调用过程介绍的，如果不知道某个函数是在哪里被谁调用的，可以回过头来看下时序图。下面是对一些细节进行介绍。 1.在Android中有两种操作会引发Activity的启动，一种用户点击Launcher的应用程序图标时，Launch...
activity启动流程
测试
04-02 228
所有进程都是由init进程直接或间接fork出来的 android系统启动时，init进程会fork出zygote，意为“受精卵”，后面的所有进程都是zygote分裂出来的 在zygote进程初始化时会启动SystemServer进程，平时所用到的AMS、PMS、WMS、网络等服务都是在SystemServer启动时开启的，SystemServer中启动服务的代码 private void r...
分析Android Activity的启动过程
01-04
 对于Android Activity 的启动过程，我在Android源码中读了好久的源码，以下是我整理出来的Activity启动过程和大家分享下： Activity作为Android的四大组件之一，也是最基本的组件，负责与用户交互的所有功能。...
Android Activity启动流程○
zenmela2011的专栏
05-11 4469
从点击屏幕上的应用icon，到该应用展示第一个可视界面，这个过程中，Android系统究竟做了什么操作？又涉及到哪些进程？ 1.根Activity启动过程 ①从Launcher到AMS 当点击屏幕上的应用icon时，Laucher发送启动应用的请求给AMS，因为Launcher是在Launcher进程，而AMS是在SystemServer进程。因此，实现这个请求，本质上是在实现一个跨进程通信的功能。在安卓领域实现跨进程通信的技术有多种，像是Broadcast、ContentProvinder等。在系.
android Activity启动流程
01-03
Activity的启动过程，我们可以从Context的startActivity说起，其实现是ContextImpl的startActivity，然后内部会通过Instrumentation来尝试启动Activity，这是一个跨进程过程，它会调用ams的startActivity方法，当AMS...
Android | Activity 启动流程分析
Android_XG的博客
02-17 1487
Activity类是 android 应用的关键组件，在日常开发中，绝对少不了组件。既然用了这么久，你知道他的启动流程🐴？作为一个应用层开发者，大多数人可能觉得学习这些对日常开发可能没有太大帮助。但是多了解一下 framework 的代码还是很有必要的，了解系统组件机制，对于一些问题我们也能快速的定位找到问题的所在点，并且在面试的时候也是一个加分项。本文基于 Android 12 版本源码，从作为切入点，对整个启动流程进行分析。
评论 25
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值