Framework APP和Activity启动流程

启动前：

1，init进程是所有Linux程序的起点，会启动ServiceManager，fork一些守护进程，也是Zygote的父进程，通过解析init.rc孵化出Zygote进程。

2，Zygote是所有Java进程的父进程，所有的APP进程都是由Zygote进程fork出的（因为每个APP都是运行在各自的虚拟机中，APP每次运行都要重新初始化和启动虚拟机，很耗费时间，Zygote会把已经运行的虚拟机代码和内存信息共享，这样可以预加载资源和类，从而缩短启动时间，所以是fork进程，而不是新建进程），Zygote初始化后，会注册一个等待接受消息的socket，OS层会采用socket进行IPC通信。

3，SystemSever进程是Zygote孵化出的第一个进程，负责启动和管理整个Framework，如AMS，PMS等服务。

4，launcher进程是Zygote进程孵化的第一个APP进程。Launcher继承Activity，也是一个界面。

先从Launcher启动一个APP说起：

咱们的手机桌面也是一个APP，这个APP就叫Launcher，可以说是其他APP的入口和管理者，当我们点击APP图标后，会发生以下几件事儿：

1，Launcher捕获点击事件（在Launcher所在线程进行）。

Launcher.onClick->Launcher.onClickAppShortcut->Launcher.startAppShortcutOrInfoActivity（获取APP安装时PMS解析AndroidManifest.xml文件的信息）->Launcher.startActivitySafely

2，Launcher通知AMS要启动一个新Activity（也就是目标APP的入口Activity）。

Activity.startActivity->Activity.startActivityForResult->Instrumentation.exeStartActivity()->AMP.startActivity

简单说这是个跨进程通信过程就是AMP利用Binder进行通信，通过Binder对象的transact方法传输到AMS.

重要实现是Instrumentation.exeStartActivity()方法，其中传入的contextThread是一个IBinder对象，即ApplicationThread的本地对象，是通过ActivityThread.getApplicationThread()获取到的。ActivityManagerNative.getDefault()返回的是AMS的代理对象AMP。这儿我们就是把自己的Binder对象（contextThread）传递给了AMS，用来完成ActivityThread与AMS的通信。

public ActivityResult execStartActivity(
            Context who, IBinder contextThread, IBinder token, Activity target,
            Intent intent, int requestCode, Bundle options) {
        IApplicationThread whoThread = (IApplicationThread) contextThread;
        //省略部分代码
        try {
            //...
            int result = ActivityManagerNative.getDefault()
                .startActivity(whoThread, who.getBasePackageName(), intent,
                        intent.resolveTypeIfNeeded(who.getContentResolver()),
                        token, target != null ? target.mEmbeddedID : null,
                        requestCode, 0, null, options);

            //检查启动Activity的结果（抛出异常，例如清单文件未注册Activity）
            checkStartActivityResult(result, intent);
        } catch (RemoteException e) {
            throw new RuntimeException("Failure from system", e);
        }
        return null;
    }
}

3，AMS先校验Activity的正确性,如是否注册，如果正确会暂存当前activity的信息，然后AMS通知Launcher程序pause Activity（在AMS所在进程执行，即SystemSever进程）

AMS.startActivity->AMS.startActivityAsUser->ActicityStackSupervisor.startActivityMayWait->ActicityStackSupervisor.startActivityLocked(校验参数，创建ActivityRecord，每启动一个activity就会创建一个对于的ActivityRecord对象，等)->ActicityStackSupervisor.startActivityUnchecked->ActivityStack.startActivityLocked(判断是否需要创建一个新的任务来启动Activity)->ActivityStack.resumeTopActivityLocked(获取栈顶activity，通知Launcher应pause掉该activity)->ActivityStack.startPausingLocked->ApplicationThreadProxy.schedulePauseActivity

4，Launcher会pause掉栈顶Activity，在该Activity不可见时，并通知AMS已经paused（在Launcher所在进程执行）

ApplicationThread.schedulePauseActivity->ActivityThread.queueOrSendMessage->Handler.handleMessage->ActivityThread.handlePauseActivity->ActivityManagerProxy.activityPaused

5，AMS检查activity所在进程是否存在，如果存在，则直接通知这个进程启动Activity，不存在就调用Process.start创建一个进程（在AMS进程执行）

AMS.activityPaused->ActivityStack.activityPaused->ActivityStack.completePausedLocked->ActivityStack.resumeTopActivityLocked->ActivityStack.startSpecificActivityLocked(检查进程是否已存在)->AMS.startProcessLocked ->Process.start（是Zygote进程fork出的新的APP进程，通过反射执行ActivityThread的main方法）

在startSpecificActivityLocked方法中检查进程是否存在，若存在则直接调用第7步的realStartActivityLocked方法启动activity。

6，创建ActivityThread实例，进行初始化操作。将该进程绑定到AMS，并保存当前进程对应的主线程。绑定Application，如果Application不存在，则调用LoadedApk.makeApplication创建一个新的Application对象。之后进入Loop循环。（在APP进程执行）

ActivityThread.main->ActivityThread.attach(false)(false声明不是系统进程,该方法将当前进程绑定到了AMS)->AMP.attchApplication

public final class ActivityThread {
   final ApplicationThread mAppThread = new ApplicationThread();
   public static void main(String[] args) {
	   // 初始化主线程的消息队列
	   Looper.prepareMainLooper();
       //创建当前进程的主线程
       ActivityThread thread = new ActivityThread();
       //将主线程绑定到AMS
       thread.attach(false);
	   //保存主线程的handler
	   if (sMainThreadHandler == null) {
            sMainThreadHandler = thread.getHandler();
       }
       // 开启消息循环
       Looper.loop();
   }
   
   private void attach(boolean system) {
        sCurrentActivityThread = this;
        mSystemThread = system;
        if (!system) { // 是否为系统进程
            android.ddm.DdmHandleAppName.setAppName("",
                                                    UserHandle.myUserId());
            RuntimeInit.setApplicationObject(mAppThread.asBinder());
            // 获得 AMS 的代理对象
            final IActivityManager mgr = ActivityManagerNative.getDefault();
            mgr.attachApplication(mAppThread);
        } 
    }
}


// ActivityManagerProxy 的 attachApplication 方法
public void attachApplication(IApplicationThread app) throws RemoteException {
    Parcel data = Parcel.obtain();
    Parcel reply = Parcel.obtain();
    data.writeInterfaceToken(IActivityManager.descriptor);
    data.writeStrongBinder(app.asBinder());
    mRemote.transact(ATTACH_APPLICATION_TRANSACTION, data, reply, 0);
    reply.readException();
    data.recycle();
    reply.recycle();
}

现在APP的新进程创建完毕了，也有了自己的主线程，接下来就要启动activity了。

7，AMS处理APP进程发出的创建进程完成的通信请求，通知APP启动目标Activity（在AMS进程执行）

AMS.attchApplication(通过Binder.getCallingPid获取了APP进程ID，AMS绑定本地ApplicationThread对象，后续通过ApplicationThreadProxy进行通信)->AMS.attachApplicationLocked(在该方法AMS通过thread.bindApplication绑定Application)->ActivityStackSupervisor.attachApplicationLocked->ActivityStackSupervisor.realStartActivityLocked(真正要启动activity了）->ApplicationThreadProxy.scheduleLaunchActivity (AMS通过ATP通知APP进程启动Activity)

8，加载目标Activity类,如MainActivity，调用该类的onCreate方法（在APP进程执行）

ApplicationThread.scheduleLaunchActivity（ApplicationThread发消息给AT）->ActivityThread.queueOrSendMessage->H.handleMessage (AT的Handler来处理接收到的LAUNCH_ACTIVITY的消息)->ActivityThread.handleLaunchActivity->ActivityThread.performLaunchActivity->Instrumentation.newActivity->Instrumentation.callActivityOnCreate->MainActivity.onCreate

备注：

AMS(ActivityManagerService)：服务端对象，负责系统中所以Activity的生命周期。在SystemServer进程开启时，会初始化AMS。

Instrumentation：负责调用Activity和Application的生命周期，每个activy内部都有该对象的引用。

AMN(ActivityManagerNative)：运行在server端（SystemServer进程）。实现了Binder类，具体功能由子类AMS实现。

AMP(ActivityManagerProxy):AMS的client端代理，AMP和AMS通过Binder通信。

ActivityThread：运行在UI线程（主线程），APP的真正入口，因为提供了static main()函数，是我们常说的主线程。

ApplicationThread：是Activity的内部类，是一个Binder类，用来实现AMS和ActivityThread之间的交互，实现跨进程通信。

ApplicationThreadProxy：ApplicationThread 在服务端的代理。AMS就是通过该代理与ActivityThread进行通信的。

ActivityStackSupervisor：负责所有Activity栈的管理。

其他：

1、新的Activity类是通过类加载器方式即通过反射的方式生成的，在mInstrumentation.newActivity()方法中：

       (Activity)cl.loadClass(className).newInstance();

最后调用mInstrumentation.callActivityOnCreate()，该方法会显示调用Activtiy的onStart()方法。

2，之后调用方法是：

ActivityThread.performResumeActivity()-> Activity.performResume()-> Instrumentation.callActivityOnResume()-> Activity.onResume()

在onResume之后开始绘制界面。

3，说个闲话，如果想让自己的APP做Launcher,就在注册配置文件添加

参考：

https://blog.csdn.net/u012267215/article/details/91406211