Android--应用启动流程

Zygote进程和系统服务

开机启动Lunix的init进程，这个进程应该算是所有进程的祖先进程了，然后fock出Zygote进程

Zygote是Android所有进程的父进程，其他所有进程都是由这个进程fork而来，Zygote进程启动会后调用ZygoteInit.main()方法fork出SystemServer进程并执行run（）方法，这个进程是非常重要的系统进程，所有通过SystemManagerService创建的系统服务都运行在这个进程中

private void run() {
   //创建系统服务AMS,WMS,PMS,DMS,
   startBootstrapServices();
   //创建核心服务LightsService，BatteryService
   startCoreServices();
   startOtherServices();
  
}

然后会创建Launcher应用进程，这是控制桌面显示的一个进程，当点击图标启动应用的时候，会调用Launcher.startActivity()，因为Launcher也是一个activity，所以启动activity请求最终交给AMS，AMS发现应用进程还没创建，就会通知Zygote进程fork出一个新的进程，等进程创建完成后会在该进程中调用ActivityThread.main()，所以ActivityThread.main()是应用进程的入口

应用启动涉及到的类

服务端

IActicityManager是管理activiy的接口，AMS是服务端activity的管理类，运行在SystemServer进程。ActivityManagerProxy是ASM在应用程序中的一个代理类，应用程序就是通过它调用AMS实现的方法，但是客户端不会直接创建ActivityManagerProxy而是通过工具类ActivityManagerNative的getDefault()方法得到ActivityManagerProxy。

例如应用程序启动activity的时候通常会使用下面的方式

ActivityManagerNative.getDeafalt().startActivity()

应用程序端

AMS是服务端的管理类，但是activity毕竟是运行在应用程序进程的，ApplicationThread就是程序进程中的调度类，AMS的管理操作都是和ApplicationThread配合完成的。

IApplicatonThread是调度的接口，ApplicationThread是具体的实现类，运行在应用进程，ApplicationThreadProxy是ApplicationThread在AMS进程的一个代理类，AMS就是通过它调用ApplicationThread的方法，ApplicationThreadNative是一个中间件，AMS通过它得到ApplicationThreadProxy对象。

应用启动流程

1.ActivityThread.main（）

Zygote进程fork出新进程后，会调用ActivityThread的main（）方法，这个方法是整个应用程序的入口

在这个方法中做了两件非常重要的事情

通过Looper.prepare()和Looper.loop()开启主线程消息循环
调用attach()方法，把ApplicationThread绑定到AMS

public static void main(String[] args) {
  //准备主线程Looper
  Looper.prepareMainLooper();
  //创建ActivityThread
  ActivityThread thread = new ActivityThread();
  //调用attach
  thread.attach(false);
  //创建handler,后续包括四大组件的管理都是通过该handler接受消息后处理的
  if (sMainThreadHandler == null) {
       sMainThreadHandler = thread.getHandler();
    }
  //初始化Asynctash
  AsyncTask.init();
  //开启消息轮询
  Looper.loop();
}

2.ActivityThread.attach（boolean）

这个方法中，通过ActivityManagerNative.getDefault()得到AMS在应用进程的代理对象ActivityManagerProxy，并调用它的attachApplication（），并把ApplicationThread绑定到AMS，后续AMS对Activity的控制就是通过ApplicationThread来完成的

private void attach(boolean system) {
//得到AMS在客户端的代理对象
amsp = ActivityManagerNative.getDefault()
//通过代理对象把appThread绑定到AMS
amsp.attachApplication(mAppThread);
}

3.ActivityManagerProxy.ttachApplication(appThread)

这个方法就是一个binder实现，通过代理对象调用真正对象方法的过程

4.ActivityManagerService.attachApplication(IApplicationThread)

在这个方法中，通过代理对象ApplicationTheadNative，最终调用到ApplicationThead的方法初始化应用的Application并启动第一个Activity

thread.bindApplication（...），创建应用Application并初始化
thread.schduleLaunchActivity（...），创建并启动应用第一个activity

private void attachApplication(appThreadProxy) {
    //创建应用程序的Application和初始化
    appThreadProxy.bindApplication(...)
 
    //该方法最终调用到             appThreadProxy.scheduleLaunchActivity创建应用启动Activity
   mStackSupervisor.attachApplicationLocked(app)
}

5.ApplicationThread.bindApplication（）

发送消息,ActivityThread中的mH得到这个消息后，通过反射创建出Application，交给Instrumantation调用Application.onCreate()完成Application的创建


public final void bindApplication(...) {
    //封装消息
    AppBindData data = new AppBindData();
    data.processName = processName;
    data.appInfo = appInfo;
    data.providers = providers;
    data.instrumentationName =                   
    //...

    //发送启动application的消息
    sendMessage(H.BIND_APPLICATION, data);
}

6.ApplicationThread.scheduleLaunchActivity（）

把创建Activity需要的信息封装到消息里面，ActivityThread中的mH得到这个消息后，通过反射创建出Activity，交给Instrumantation调用 Activity.attach()和Activity.onCreate（），完成activity的启动

 public final void scheduleLaunchActivity(...) {
  //发送启动activity的消息
  sendMessage(H.LAUNCH_ACTIVITY, r);
}

  //handler得到消息后，调用对应的handleXXX（）方法
  private void handleLaunchActivity(...) {
  Activity a = performLaunchActivity(r,                        customIntent);
  
  }


private Activity performLaunchActivity(...) {
//反射创建出activity
ClassLoader cl = getClassLoader();
activity = mInstrumentation.newActivity(..);
//attach（）给activity设置window，application等变量
activity.attach(...);
//回调onCreate()完成activity的创建
mInstrumentation.callActivityOnCreate();
}