android高级程序开发-app启动流程

Android系统启动流程分析：

之所以分析它，是为了更好的理解整个系统，也有助于我们后面的学习，更深入理解我们Android App的启动流程

一、开机流程：

开机后会加载引导程序BootLoader，它是Android系统运行的第一个程序，在操作系统运行之前运行。
BootLoader主要功能：1.检查RAM，初始化硬件参数等功能；2.拉起操作系统

二、初始化内核Kernel：

完成了内核的大部分初始化工作，启动用户空间的init进程
init进程：所有的进程都是由init进程直接或者间接fork出来的

三、init进程初始化：

加载ServiceManager服务进程：这个是一个守护进程，用于管理各种服务Server,主要用于ipc跨进程通信，提供Clinet访问Server服务的接口
fork一个Zygote进程：该进程是Android系统开启新的进程的方式，是通过fork zygote进程实现的，之所以这么做是为了实现资源共用和更快的启动速度。

四、Zygote进程初始化：

1.创建Android运行时环境AppRuntime：调用app_main.cpp的main函数中的AppRuntime的start来启动zygote进程

app_main.cpp：main()

AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));
if (zygote) {
runtime.start("com.android.internal.os.ZygoteInit", args, zygote);
}

2.创建Android运行时环境AppRuntime，AppRuntime继承了系统的AndroidRuntime类，start方法实际上调用的是AndroidRuntime的start方法

AndroidRuntime：start()
startVm(&mJavaVM, &env, zygote)
startReg(env)
//找到ZygoteInit的main函数
jmethodID startMeth = env->GetStaticMethodID(startClass, "main", "([Ljava/lang/String;)V");
//通过JNI调用ZygoteInit的main函数
env->CallStaticVoidMethod(startClass, startMeth, strArray);2.1、创建虚拟机：调用startVm
2.2、初始化虚拟机：调用startReg函数用来为JavaVm注册JNI

2.3、找到ZygoteInit的main

2.4、通过JNI调用ZygoteInit的main函数(main函数是java编写的)

3.执行ZygoteInit的main函数：开始进入java层，主要是启动SystemServer进程

ZygoteInit：main()
//注册Zygote用的Socket
registerZygoteSocket(socketName);
//预加载类和资源
preload();
//启动SystemServer进程
if (startSystemServer) {
startSystemServer(abiList, socketName);
}
//等待客户端请求
runSelectLoop(abiList);

3.1、通过registerZygoteSocket函数来创建一个Server端的Socket，这个Socket用来等待ActivityManagerService来请求Zygote来创建新的应用程序进程

3.2、预加载类和资源

3.3、启动SystemServer进程，这样系统的关键服务也会由SystemServer进程启动起来，fork出SystemServer进程：系统里面的重要的服务都是在这个进程里面开启的，比如：ActivityManagerService、PackageManagerService、WindowManagerService等等

3.4、等待客户端AMS Socket通讯请求

五、SystemServer进程初始化：

至此，Android Framework里面两大非常重要的进程：Zygote和SystemServer进程就已经开启了public static void main(String[] args) {
new SystemServer().run();
}
private void run() {
// 准备SystemServer运行环境:设置线程优先级，创建主线层Looper，ActivityThread和SystemContext
android.os.Process.setThreadPriority();
Looper.prepareMainLooper();

// 创建systemserver上进程的ActivityThread和SystemContext
createSystemContext();

// 增加SystemServiceManager：统一管理system services的创建，启动和生命周期，多用户切换
mSystemServiceManager = new SystemServiceManager(mSystemContext);

// Start services.

// 1.创建AMS
mActivityManagerService = mSystemServiceManager.startService(
ActivityManagerService.Lifecycle.class).getService();

// Start the Power Manager service
mPowerManagerService = mSystemServiceManager.startService(PowerManagerService.class);

// Start the package manager service
mPackageManagerService = PackageManagerService.main();

// 2.将SystemServer进程添加到AMS中调度管理
mActivityManagerService.setSystemProcess();

// 3.将相关provider运行在systemserver进程中：SettingsProvider
mActivityManagerService.installSystemProviders();

//
final Watchdog watchdog = Watchdog.getInstance();
watchdog.init(context, mActivityManagerService);

// Start Window Manager
wm = WindowManagerService.main();

// 4.直接保存wms对象，与WMS交互
mActivityManagerService.setWindowManager(wm);

// 5.通过WMS 弹出“正在启动应用”框
// R.string.android_upgrading_starting_apps
ActivityManagerNative.getDefault().showBootMessage();

// 6. AMS作为Framework核心，做好准备就绪后就开始启动应用层，和对AMS有依赖的服务
mActivityManagerService.systemReady(new Runnable(){
//启动SystemUI
startSystemUi(context);

//启动WatchDog监控核心服务状态
Watchdog.getInstance().start();

//
mmsServiceF.systemRunning();
});

// Loop forever.
Looper.loop();
}
系统里面的重要的服务都是在这个进程里面开启的，比如：ActivityManagerService、PackageManagerService、WindowManagerService等等

完成后，系统服务都已经启动好了，那么下面就可以通过系统服务，启动一些应用层程序了，比如Launcher程序就是在ActivityManagerService(简称AMS)的systemReady方法里启动的，那么我们下面就来看看AMS。

六、ActivityManagerService：

简称AMS，服务端对象，负责四大组件的初始化，负责系统中所有Activity的生命周期。
通知zygote进程来fork一个新进程，来开启我们的目标App

所有的Activity的开启、暂停、关闭都需要AMS来控制，所以我们说，AMS负责系统中所有Activity的生命周期
public static final class Lifecycle extends SystemService {
private final ActivityManagerService mService;
public Lifecycle(Context context) {
super(context);
mService = new ActivityManagerService(context);
}

@Override
public void onStart() {
mService.start();
}

public ActivityManagerService getService() {
return mService;
}
}

public ActivityManagerService(Context systemContext) {

　　     // 1.系统Context 和 ActivityThread （将systemserver进程作为应用进程管理）
mContext = systemContext;
mFactoryTest = FactoryTest.getMode();
mSystemThread = ActivityThread.currentActivityThread();

// 2.AMS工作的线程和Handler，处理显示相关的UiHandler  ---》知识点HandlerThread和Handler
mHandlerThread = new ServiceThread(TAG,
android.os.Process.THREAD_PRIORITY_FOREGROUND, false /*allowIo*/);
mHandlerThread.start();
mHandler = new MainHandler(mHandlerThread.getLooper());
mUiHandler = new UiHandler();

// 3. 广播队列BroadcastQueue初始化：前台广播队列和后台广播队列
mFgBroadcastQueue = new BroadcastQueue(this, mHandler,"foreground", BROADCAST_FG_TIMEOUT, false);
mBgBroadcastQueue = new BroadcastQueue(this, mHandler,"background", BROADCAST_BG_TIMEOUT, true);
mBroadcastQueues[0] = mFgBroadcastQueue;
mBroadcastQueues[1] = mBgBroadcastQueue;

// 4. Service 和 Provider 管理
mServices = new ActiveServices(this);
mProviderMap = new ProviderMap(this);

// 5.系统数据存放目录：/data/system/
File dataDir = Environment.getDataDirectory();
File systemDir = new File(dataDir, "system");
systemDir.mkdirs();

// 电池状态信息，进程状态 和 应用权限管理
mBatteryStatsService = new BatteryStatsService(systemDir, mHandler);
mProcessStats = new ProcessStatsService(this, new File(systemDir, "procstats"));
mAppOpsService = new AppOpsService(new File(systemDir, "appops.xml"), mHandler);

// 6.多用户管理
mStartedUsers.put(UserHandle.USER_OWNER, new UserState(UserHandle.OWNER, true));
mUserLru.add(UserHandle.USER_OWNER);
updateStartedUserArrayLocked();

// 7.最近任务，Activity，Task管理
mRecentTasks = new RecentTasks(this);
mStackSupervisor = new ActivityStackSupervisor(this, mRecentTasks);
mTaskPersister = new TaskPersister(systemDir, mStackSupervisor, mRecentTasks);

// 创建一个新线程，用于监控和定时更新系统CPU信息，30分钟更新一次CPU和电池信息
mProcessCpuTracker.init();
mProcessCpuThread = new Thread("CpuTracker") {}

// 加入Watchdog监控起来
Watchdog.getInstance().addMonitor(this);
Watchdog.getInstance().addThread(mHandler);
}

public void setSystemProcess() {
// 将服务加入到ServiceManager中
ServiceManager.addService(Context.ACTIVITY_SERVICE, this, true);//ActivityManagerService是以activity名称存放到ServiceManager守护进程中的。
ServiceManager.addService(ProcessStats.SERVICE_NAME, mProcessStats);
ServiceManager.addService("meminfo", new MemBinder(this));
ServiceManager.addService("gfxinfo", new GraphicsBinder(this));
ServiceManager.addService("dbinfo", new DbBinder(this));

// 设置application info LoadedApkinfo 有关 framework-res.apk
ApplicationInfo info = mContext.getPackageManager().getApplicationInfo(
"android", STOCK_PM_FLAGS);
mSystemThread.installSystemApplicationInfo(info, getClass().getClassLoader());

//给SystemServer进程创建ProcessRecord，adj值，就是将SystemServer进程加入到AMS进程管理机制中，跟应用进程一致
synchronized (this) {
ProcessRecord app = newProcessRecordLocked(info, info.processName, false, 0);
app.persistent = true;
app.pid = MY_PID;
app.maxAdj = ProcessList.SYSTEM_ADJ;
app.makeActive(mSystemThread.getApplicationThread(), mProcessStats);
synchronized (mPidsSelfLocked) {
mPidsSelfLocked.put(app.pid, app);
}
updateLruProcessLocked(app, false, null);
updateOomAdjLocked();
}
}

启动Home应用程序：Launcher进程public void systemReady(final Runnable goingCallback) {
...
// Start up initial activity.
mBooting = true;
startHomeActivityLocked(mCurrentUserId, "systemReady");
...
}本节主要介绍了Android系统从开机到启动Launcher应用程序的流程分析，对于应用程序开发人员来说，只需要了解下整个流程的主要方法，特别是上面一些重要的系统进程和服务，因为它可以让我们加深对Android系统的理解。大家可以重点关注下：ServiceManager服务进程以及SystemServer进程，还有就是AMS。
总结：
1、开机后加载引导程序bootloader：将操作系统拉起来
2、初始化内核，在系统文件中寻找init.rc文件，启动init进程：加载ServiceManager服务进程；fork出一个Zygote进程
3、Zygote进程初始化：创建Android运行时环境AppRuntime(创建虚拟机，初始化虚拟机:注册JNI，通过JNI调用Zygote的main函数)；执行Main函数，开始进入Java层(注册Zygote用的Socket:用于监听SystemServer进程中的AMS的Socket连接，以便fork出新的进程；启动SystemServer进程；通过runSelectLoop函数等待ActivityanagerService的请求)

4、SystemServer进程初始化：用于启动各种系统服务
5、Launcher启动：被SystemServer启动的AMS会执行systemReady方法，从来启动Home程序

接下来我们将重点介绍应用程序的启动流程，当然由于启动应用程序涉及到IPC进程间通信，所以我们需要先了解下Binder跨进程通信机制，然后再分析应用程序的启动流程。欢迎订阅！