Android系统默认Home应用程序(Launcher)的启动过程源代码分析
Android 开机启动流程
Androiｄ的开机流程1. 系统引导ｂｏotloader1) 源码：bootable／bootｌｏａdｅr/*2) 说明：加电后,CPＵ将先执行bootｌoadｅｒ程序,此处有三种选择ａ) 开机按Camｅra+Power启动到fａsｔｂｏot,即命令或SD卡烧写模式，不加载内核及文件系统，此处可以进行工厂模式的烧写b) 开机按Home＋Power启动到reｃｏｖery模式，加载rｅcovｅrｙ.ｉｍg，reｃｏvery.i ｍg包含内核，基本的文件系统，用于工程模式的烧写ｃ) 开机按Power,正常启动系统,加载booｔ.iｍg，ｂooｔ.ｉｍg包含内核，基本文件系统，用于正常启动手机(以下只分析正常启动的情况)2. 内核keｒnel1) 源码：ｋerｎel／*2) 说明:keｒnel由ｂooｔloａder加载3. 文件系统及应用inｉｔ1) 源码：syｓtem／ｃoｒe/ｉnit/＊2) 配置文件：ｓｙstem/ｒoｏtdir/ｉnit.rｃ,3) 说明：iｎｉｔ是一个由内核启动的用户级进程,它按照init．ｒｃ中的设置执行:启动服务(这里的服务指ｌｉnｕx底层服务，如adbd提供aｄb支持，vｏlｄ提供SD卡挂载等)，执行命令和按其中的配置语句执行相应功能4. 重要的后台程序zygote1）源码：frameworks/ｂaｓｅ/cｍdｓ/ａｐp_main.ｃｐp等2) 说明：ｚyｇｏｔe是一个在ｉnｉt.ｒc中被指定启动的服务,该服务对应的命令是/ｓystｅm/bin/app_ｐrocessa）建立Java Runtimｅ,建立虚拟机b) 建立Sｏcket接收ActivitｙMaｎａngerService的请求,用于Fork应用程序c) 启动System Ｓerｖｅr５. 系统服务system sｅrｖer1）源码：ｆrameｗorkｓ/baｓe/seｒvices/jaｖa/com/andrｏid/seｒｖer/SystemSｅrver.jav ａ2) 说明：被zｙgoｔe启动,通过SｙsｔｅｍMａｎager管理androiｄ的服务（这里的服务指ｆramｅwoｒkｓ/base/servｉces下的服务,如卫星定位服务,剪切板服务等)6. 桌面launcheｒ1）源码：AcｔivityＭanaｇeｒService.java为入口，packaｇｅs/apps/launcher*实现2) 说明：系统启动成功后ＳystｅmＳervｅr使用xxx．systeｍＲeady()通知各个服务,系统已经就绪，桌面程序Home就是在ActiｖityＭanａgerService．systｅmRｅady()通知的过程中建立的,最终调用（)启launcｈeｒ7. 解锁1) 源码:ｆraｍeworkｓ/poｌicies/ｂase/pｈonｅ/coｍ/andrｏiｄ/ｉｎteｒnal/ｐolｉcy/ｉmpl/＊loｃk* 2) 说明：系统启动成功后SystemSｅrｖer调用ｗｍ.sｙｓteｍRｅady()通知ＷindｏwＭａnageｒService,进而调用PhonｅＷｉｎdowManａger，最终通过LockＰaｔternKeｙgｕaｒｄＶiew显示解锁界面，跟踪代码可以看到解锁界面并不是一个Ａctivity,这是只是向特定层上绘图,其代码了存放在特殊的位置8. 开机自启动的第三方应用程序1) 源码:ﻫｆramｅwoｒks/bａsｅ/serｖiｃes/jaｖa／com/aｎdｒoid/serveｒ／ａm／ActivityManageｒServiｃe.ｊava2) 说明：系统启动成功后ＳｙsteｍSeｒveｒ调用ActiｖitｙＭaｎaｇeｒNaｔive.getDefa ｕlt().systｅmＲeａdy（）通知AcｔｉvｉtyMaｎａgｅr启动成功,ActivitｙＭaｎaｇer会通过置变量ｍBootiｎg,通知它的另一线程,该线程会发送广播ａnｄroid．ｉnｔeｎt.ａction.BOOＴ＿COMPＬETED以告知已注册的第三方程序在开机时自动启动。
Android启动流程分析
Zygote进程启动System Server
Zygote进程从App_main.cpp中main函数开始，调用runtime.start启动system server，最后就进入 runSelectLoopMode等待并处理来自上层的请求。
int main(int argc, const char* const argv[]){ ...... AppRuntime runtime; ...... int i = runtime.addVmArguments(argc, argv); if(i < argc){ runtime.mParentDir = argv[i++]; }
2. 从以下文件中加载默认属性值。 ① /default.prop ② /system/build.prop ③ /system/default.prop ④ /data/local.prop 属性将会按照如上顺序加载，后加载的属性覆盖原先的。
3. Init进程会启动一个属性服务器Property Service，客户端(Property Setter)只能通过 该属性服务器来进行系统属性的设置。 处理设置属性请求(Write property) 当Property Service通过unix domain socket收到用户请求时，init会调用 handle_property_set_fs函数进行处理。
Kernel创建Init进程
Android Kernel启动后，执行start_kernel函数来初始化Kernel正式运行之前各个功能。 Start_kernel函数最后调用了reset_init函数启动了如下三个进程： ① idle 是操作系统的空闲进程，当 cpu 空闲的时候会去运行它 ② kthreadd 是内核守护进程，其 PID 为 2 ③ kernel_init 函数作为进程被启动，但是之后它将读取根文件系统下的init 程序，这个
Android系统进程Zygote启动过程的源代码分析
在Android系统中，所有的应用程序进程以及系统服务进程SystemServer都是由Zygote进程孕育（fork）出来的，这也许就是为什么要把它称为Zygote（受精卵）的原因吧。
由于Zygote进程在Android 系统中有着如此重要的地位，本文将详细分析它的启动过程。
在前面一篇文章Android应用程序进程启动过程的源代码分析中，我们看到了，当ActivityManagerService启动一个应用程序的时候，就会通过Socket与Zygote进程进行通信，请求它fork 一个子进程出来作为这个即将要启动的应用程序的进程；在前面两篇文章Android应用程序安装过程源代码分析和Android系统默认Home应用程序（Launcher）的启动过程源代码分析中，我们又看到了，系统中的两个重要服务PackageManagerService和ActivityManagerService，都是由SystemServer进程来负责启动的，而SystemServer进程本身是Zygote进程在启动的过程中fork出来的。
我们知道，Android系统是基于Linux内核的，而在Linux系统中，所有的进程都是init进程的子孙进程，也就是说，所有的进程都是直接或者间接地由init进程fork出来的。
Zygote进程也不例外，它是在系统启动的过程，由init进程创建的。
在系统启动脚本system/core/rootdir/init.rc文件中，我们可以看到启动Zygote进程的脚本命令：view plain1.service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server2. socket zygote stream 6663. onrestart write /sys/android_power/request_state wake4. onrestart write /sys/power/state on5. onrestart restart media6. onrestart restart netd前面的关键字service告诉init进程创建一个名为"zygote"的进程，这个zygote进程要执行的程序是/system/bin/app_process，后面是要传给app_process的参数。
android7.x Launcher3源码解析(3)---workspace和allapps加载流程
android7.x Launcher3源码解析（3）---workspace和allapps加载流程1、整体流程先上一张整体的流程图吧。
（图片看不清可以下载下来看或者右击新开个页面查看图片）先从Launcher.Java的onCreate方法开始，protected void onCreate(Bundle savedInstanceState) {......//建立LauncherAppState对象LauncherAppState.setApplicationContext(getApplicationContext());LauncherAppState app = LauncherAppState.getInstance();......//建立LauncherModel对象mModel = app.setLauncher(this);//一些其他对象初始化......setContentView(uncher);setupViews();if (!mRestoring) {if (DISABLE_SYNCHRONOUS_BINDING_CURRENT_PAGE) {// If the user leaves launcher, then we should just load items asynchronously when// they return.mModel.startLoader(PagedView.INV ALID_RESTORE_PAGE);} else {// We only load the page synchronously if the user rotates (or triggers a// configuration change) while launcher is in the foregroundmModel.startLoader(mWorkspace.getRestorePage());}}......}重点调用了LauncherModel的startLoader的方法，startLoader里面，最重要的就是启动了LoaderTask，mLoaderTask = new LoaderTask(mApp.getContext(), synchronousBindPage);我们接着分析LoaderTask的run方法。
手把手教你开发安卓Launcher
launcher，也就是android的桌面应用程序。
下图是android2.3的launcher应用程序：接下来我们要开发一个自己的launcher，使其替代系统的默认launcher。
怎样使我们的应用程序成为一个launcher？下面我们就新建一个叫做MyHome的工程，具体步骤略。
创建完工程后整个目录结构如下图：现在我们的AndroidManifest.xml文件这样的：<?xml version="1.0" encoding="utf-8"?><manifest xmlns:android="/apk/res/android"package="org.bangchui.myhome"android:versionCode="1"android:versionName="1.0"><application android:icon="@drawable/icon" android:label="@string/app_name"> <activity android:name=".MyHome"android:label="@string/app_name"><intent-filter><action android:name="android.intent.action.MAIN" /><category android:name="UNCHER" /></intent-filter></activity></application></manifest>请注意<intent-filter></intent-filter>里面的内容。
Android 开机启动流程
Android的开机流程1. 系统引导bootloader1) 源码：bootable/bootloader/*2) 说明：加电后，CPU将先执行bootloader程序，此处有三种选择a) 开机按Camera+Power启动到fastboot，即命令或SD卡烧写模式，不加载内核及文件系统，此处可以进行工厂模式的烧写b) 开机按Home+Power启动到recovery模式，加载recovery.img，recovery.img包含内核，基本的文件系统，用于工程模式的烧写c) 开机按Power，正常启动系统，加载boot.img，boot.img包含内核，基本文件系统，用于正常启动手机（以下只分析正常启动的情况）2. 内核kernel1) 源码：kernel/*2) 说明：kernel由bootloader加载3. 文件系统及应用init1) 源码：system/core/init/*2) 配置文件：system/rootdir/init.rc，3) 说明：init是一个由内核启动的用户级进程，它按照init.rc中的设置执行：启动服务（这里的服务指linux底层服务，如adbd提供adb支持，vold提供SD卡挂载等），执行命令和按其中的配置语句执行相应功能4. 重要的后台程序zygote1) 源码：frameworks/base/cmds/app_main.cpp等2) 说明：zygote是一个在init.rc中被指定启动的服务，该服务对应的命令是/system/bin/app_processa) 建立Java Runtime，建立虚拟机b) 建立Socket接收ActivityManangerService的请求，用于Fork应用程序c) 启动System Server5. 系统服务system server1) 源码：frameworks/base/services/java/com/android/server/SystemServer.java2) 说明：被zygote启动，通过System Manager管理android的服务（这里的服务指frameworks/base/services下的服务，如卫星定位服务，剪切板服务等）6. 桌面launcher1) 源码：ActivityManagerService.java为入口，packages/apps/launcher*实现2) 说明：系统启动成功后SystemServer使用xxx.systemReady()通知各个服务，系统已经就绪，桌面程序Home就是在ActivityManagerService.systemReady()通知的过程中建立的，最终调用()启launcher7. 解锁1) 源码：frameworks/policies/base/phone/com/android/internal/policy/impl/*lock*2) 说明：系统启动成功后SystemServer调用wm.systemReady()通知WindowManagerService，进而调用PhoneWindowManager，最终通过LockPatternKeyguardView显示解锁界面，跟踪代码可以看到解锁界面并不是一个Activity，这是只是向特定层上绘图，其代码了存放在特殊的位置8. 开机自启动的第三方应用程序1) 源码：frameworks/base/services/java/com/android/server/am/ActivityManagerService.java2) 说明：系统启动成功后SystemServer调用ActivityManagerNative.getDefault().systemReady()通知ActivityManager启动成功，ActivityManager会通过置变量mBooting，通知它的另一线程，该线程会发送广播android.intent.action.BOOT_COMPLETED以告知已注册的第三方程序在开机时自动启动。
Android-launcher拖拽
转自：/wdaming1986/article/details/7585649/wdaming1986/article/details/7671318最近研究ICS4.0的Launcher，发现4.0和2.3有稍微点区别，但是区别不是特别大，所以我就先整理一下Launcher启动的大致流程。
Launcher其实是贯彻于手机的整个系统的，时时刻刻都在运行，要是Launcher不运行了，手机就得黑屏了。
Launcher的LauncherMode=singletask，所以说不管Launcher启动了哪个应用，总有个Launcher的实例在堆栈中，并且位于栈底。
点击Home键进入到Launcher，上篇Android的全局键（home键/长按耳机键）详解【android源码解析八】中有详细的介绍。
大致思路其实就是启动launcher的时候，新启动一个task。
大致先说这么多，先看截图：大明原创，转载请标明出处：/wdaming1986/article/details/7585649图（1）上图是4.0的Launcher界面，下面我们分步来解析一下Launcher的启动过程。
Step 0：首先要给大家介绍一下Launcher的数据库，这个数据库中存放着待机界面的图标，主屏底部的应用程序图标和桌面folder中各应用程序的图标，ICS4.0的folder中只能放应用程序的快捷方式，shortcut 不能放到这个folder中，先看截图：图（2）说说各字段的含义：title：表示桌面应用程序的名字，有的title为空，表示是widget的快捷方式；intent：表示启动这个图标的intent放到数据库中，当click的时候就会调用这个字段，启动相应的应用程序；container：表示应用程序的容器，folder的容器为整数，-100：表示在桌面的程序，-101：表示是主屏底部的程序；screen：表示在第几个屏，folder的screen都是0, container=-101的为0,1,3,4；2为allapp的按钮；cellX：表示在屏幕X轴的位置，（0,1,2,3），左上角为0点，往右依次增加；cellY：表示在屏幕Y轴的位置，（0,1,2,3），左上角为0点，往下依次增加；spallX：表示占X轴几个格；spallY：表示占Y轴几个格；itemType：应用程序用0表示，shortcut用1表示，folder用2表示，widget用4表示；appWidgetId：-1表示不是widget，数字大于0表示才是widget；isShortCut：值为0表示不是应用程序的ShortCut，值为1表示是应用程序的ShortCut；iconType：值为0表示图标的名字被定义为包名的资源id，值为1表示图标用bitmap保存；icon：表示应用程序的图标，二进制的；显示为一张图片；说明：folder中的应用快捷方式绑定folder---->是用container的值绑定folder的id的；详细的讲解请参考LauncherSettings.java这个类，有数据库字段的详细讲解；手机是在第一次烧机完成后，数据库的值还没有，这时候launcher解析default_workspace.xml把这个值存到数据库中；所以说想定制什么样的开机桌面就在default_workspace.xml中做相应的配置，具体参照我前面的博客：Android中源码Launcher主屏幕程序排列详解【安卓Launcher进化一】中有详细的介绍：i f (!convertDatabase(db)) {// Populate favorites table with initial favoritesloadFavorites(db, R.xml.default_workspace);}Step 1：开机后先启动LauncherApplication.java这个类的onCreate（）方法，下面看代码：[java]view plaincopyprint?1.@Override2.public void onCreate() {3.super.onCreate();4.5.// set sIsScreenXLarge and sScreenDensity *before* creating icon cache6.// 在创建图标缓存之前先设置sIsScreenXLarge和屏幕设备的分辨率7.final int screenSize = getResources().getConfiguration().screenLayout &8.Configuration.SCREENLAYOUT_SIZE_MASK;9.sIsScreenLarge = screenSize == Configuration.SCREENLAYOUT_SIZE_LARGE ||10.screenSize == Configuration.SCREENLAYOUT_SIZE_XLARGE;11.sScreenDensity = getResources().getDisplayMetrics().density;12.13.// 实例化图标缓存区的对象14.mIconCache = new IconCache(this);15.// 实例化一个LauncherModel对象，这个类是保存Launcher的内存启动状态，更新Launcher的数据库的作用16.mModel = new LauncherModel(this, mIconCache);17.18.// Register intent receivers19.// 注册监听，应用package增加，删除，改变的监听。
Android中launcher的详细分析
Android中launcher的详细分析之前一度为如何判断当前所处的界面就是home主桌面而伤脑筋的，后来找到的方法也不是很理想，由此到现在看了launcher的分析，觉得很有帮助哈~这边给大家分享下哈~~~Linux kernel启动以后会通过app_main进程来初始化android Runtime Java运行环境，而zygote是Android的第一个进程。
所有的android的应用以及大部分系统服务都是通过zygote fork出来的子进程（我现在看到的只有native的service manager不是zygote fork出来的）。
在system server中启动的若干系统服务中与我们启动进程相关的就是Acitivity Manager。
当systerm server启动好所有服务以后，系统就进入”system ready”状态，这个时候Activity Manager就登场了。
Activity Manager光看代码行就知道是一个重量级的服务，它主要管理Activity之间的跳转，以及进程的生命周期。
当Activity Manager发现系统已经启动好以后它就会发出一个intent：java代码：1Intent intent = new Intent(mTopAction, mTopData != null ?Uri.parse(mTopData) : null);2intent.setComponent(mTopComponent);3if (mFactoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL) { 4intent.addCategory(Intent.CATEGORY_HOME);5}通过这个category类型为home的intent，Activity Manager就会通过：java代码：6startActivityLocked(null, intent, null, null, 0, aInfo, null, null, 0, 0, 0, false, false);启动Home进程了。
android系统从systemserver开始的launcher启动详细流程
android系统启动流程——从systemserver开始的launcher目录1 概述: (2)2 systemserver工作内容分析 (4)2.1 SystemServer类简述 (4)2.2 ServerThread类简述 (4)3 ActivityManagerService工作内容分析 (6)3.1 ActivityManagerService之main (7)3.1.1创建ActivityManagerService实例 (7)3.1.2 创建ActivityThread实例，获取全局Context (8)3.1.3创建ActivityStackSupervisor实例 (10)3.1.4调用startRunning (10)3.2 ActivityManagerService之setSystemProcess (11)3.3. ActivityManagerService之setWindowManager (12)3.4 ActivityManagerService之systemready (12)3.4.1 启动所有Persistent属性的APK (13)3.4.2 启动launcher (14)4 ActivityStackSupervisor启动launcher (15)4.1首先回顾一下ActivityStackSupervisor实例的初始化 (15)4.2 进入ActivityStackSupervisor.resumeTopActivitiesLocked (16)4.3 进入ActivityStack.resumeTopActivityLocked (16)4.4 回到ActivityStackSupervisor.resumeHomeActivity。
(17)4.5 ActivityStackSupervisor.mProbeThread (17)4.6 ActivityStackSupervisor.mProbeHandler (18)4.7 回到ActivityManagerService.startHomeActivityLocked (18)4.8 ActivityStackSupervisor.startHomeActivity (19)4.9 ActivityStackSupervisor.startActivityUncheckedLocked (20)4.10 ActivityStack.startActivityLocked (21)4.11 ActivityStackSupervisor.resumeTopActivitiesLocked (22)4.12 ActivityStack.resumeTopActivityLocked (22)4.13 ActivityStackSupervisor.startSpecificActivityLocked (24)4.14 ActivityStackSupervisor.realStartActivityLocked (24)4.15 ActivityManagerService.startProcessLocked (25)5 Process类管理创建activity进程 (27)5.1 Process.start: (27)5.2Process.startViaZygote (28)5.3 zygoteSendArgsAndGetResult和openZygoteSocketIfNeeded (28)6 ActivityThread线程类分析 (30)6.1 ActivityThread.main分析 (30)6.1.1创建了looper对象和本线程绑定。
Android系统启动流程(四)Launcher启动过程与系统启动流程
Android系统启动流程（四）Launcher 启动过程与系统启动流程前言此前的文章我们学习了init进程、Zygote进程和SyetemServer进程的启动过程，这一篇文章我们就来学习Android系统启动流程的最后一步：Launcher的启动流程，并结合本系列的前三篇文章的内容来讲解Android系统启动流程。
建议读这篇文章前要通读本系列的前三篇文章，否则你可能不会理解我在讲什么。
uncher概述Android系统启动的最后一步是启动一个Home应用程序，这个应用程序用来显示系统中已经安装的应用程序，这个Home应用程序就叫做Launcher。
应用程序Launcher在启动过程中会请求PackageManagerService返回系统中已经安装的应用程序的信息，并将这些信息封装成一个快捷图标列表显示在系统屏幕上，这样用户可以通过点击这些快捷图标来启动相应的应用程序。
uncher启动流程SyetemServer进程在启动的过程中会启动PackageManagerService，PackageManagerService 启动后会将系统中的应用程序安装完成。
在此前已经启动的ActivityManagerService会将Launcher启动起来。
启动Launcher的入口为ActivityManagerService的systemReady函数，如下所示。
frameworks/base/services/Java/com/android/server/SystemServer.javaprivate void startOtherServices() {...mActivityManagerService.systemReady(new Runnable() {@Overridepublic void run() {Slog.i(TAG, "Making services ready");mSystemServiceManager.startBootPhase(SystemService.PHASE_ACTIVITY_MANAGER_READY);...}...}在startOtherServices函数中，会调用ActivityManagerService的systemReady函数：frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.javapublic void systemReady(final Runnable goingCallback) {...synchronized (this) {...mStackSupervisor.resumeFocusedStackTopActivityLocked();mUserController.sendUserSwitchBroadcastsLocked(-1, currentUserId);}}systemReady函数中调用了ActivityStackSupervisor的resumeFocusedStackTopActivityLocked 函数：frameworks/base/services/core/java/com/android/server/am/ActivityStackSupervisor.javaboolean resumeFocusedStackTopActivityLocked(ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) { if (targetStack != null && isFocusedStack(targetStack)) {return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);//1 }final ActivityRecord r = mFocusedStack.topRunningActivityLocked();if (r == null || r.state != RESUMED) {mFocusedStack.resumeTopActivityUncheckedLocked(null, null);}return false;}在注释1处会调用ActivityStack的resumeTopActivityUncheckedLocked函数，ActivityStack 对象是用来描述Activity堆栈的，resumeTopActivityUncheckedLocked函数如下所示。
Android_launcher源码全面分析
launcher:className="com.apical.radio.radioMainActivity" //点击图标时，需要启动的类 launcher:packageName="com.apical.radio" launcher:screen="1" launcher:x="0" l0auncher:y="0" /> //该应用的包名 //第1屏,0-4屏共5屏 //图标X位置,左上角第一个为0,向左递增,0-4共5个 //图标Y位置,左上角第一个为0,向下递增,0-2共3个
Launcher默认是有5个分屏，不过这个可以配置。同样，每行每列有多少图标也是可以配置 的。这里按我修改的是3行5列的界面排布（对应上面的效果图）。 一般配置APP的快捷方式，使用上面的属性标签就可以。
<appwidget //插件
launcher:className="de.dnsproject.clock_widget_main.Clock1AppWidgetProvider" //该应用的类 launcher:packageName="de.dnsproject.clock_widget_main" launcher:screen="1" launcher:x="2" launcher:y="1" launcher:spanX="3" launcher:spanY="2" /> //第1屏,0-4屏共5屏 //图标X位置,左上角第一个为0,向左递增,0-4共5个 //图标Y位置,左上角第一个为0,向下递增,0-2共3个 //在x方向上所占格数 //在y方向上所占格数 //该应用的包名
android系统启动过程(1)
1Android系统的启动过程1.1启动过程Android系统完整的启动过程，可分为Linux系统层、Android系统服务层、Zygote进程模型三个阶段，从开机到启动Home Launcher完成具体的任务细节可分为七个步骤。
1.启动BootLoader2.加载系统内核3.启动Init和其它重要守护进程4.启动Zygote进程5.启动Runtime进程，初始化Service Manager。
Service Manager用于binder通讯，负责绑定服务的注册与查找。
6.启动SystemService7.启动Home Laucher8.启动其它应用程序1.1.1BootLoaderAndroid 系统是基于Linux操作系统的，所以它最初的启动过程和Linux一样。
当设备通电后首先执行BootLoader引导装载器，BootLoader是在操作系统内核运行之前运行的一段小程序。
通过这段小程序初始化硬件设备、建立内存空间映射图，从而将系统的软硬件环境引导进入合适的状态，以便为最终调用操作系统内核准备好正确的运行环境。
1.1.2启动Init和守护进程当系统内核加载完成之后，会首先启动Init守护进程，它是内核启动的第一个用户级进程，进程号永远是1。
当Init进程启动后，如(图1-1)它还负责启动其他的一些重要守护进程，主要包括：Usbd进程（USB Daemon）：USB连接后台进程，负责管理USB连接。
adbd 进程（Android Debug Bridge Daemon）：ADB连接后台进程，负责管理ADB连接。
debuggerd 进程(Debugger Daemon) ：调试器后台进程，负责管理调试请求及调试过程。
rild进程(Radio Interface Layer Daemon)：无线接口层后台进程，负责管理无线通信服务。
图1-1 Init和其它重要守护进程的启动，图片来源:http://www-igm.univ-mlv.fr/~dr/XPOSE2008/android/fonct.html1.1.3启动Zygote进程如(图1-2)所示，当Init进程和一些重要的守护进程启动完成之后，将启动Zygote 进程。
Android系统默认Home应用程序(Launcher)的启动过程源代码分析
在前面一篇文章中，我们分析了Android系统在启动时安装应用程序的过程，这些应用程序安装好之后，还需要有一个Home应用程序来负责把它们在桌面上展示出来，在Android系统中，这个默认的Home 应用程序就是Launcher了，本文将详细分析Launcher应用程序的启动过程。
Android系统的Home应用程序Launcher是由ActivityManagerService启动的，而ActivityManagerService和PackageManagerService一样，都是在开机时由SystemServer组件启动的，SystemServer组件首先是启动ePackageManagerServic，由它来负责安装系统的应用程序，具体可以参考前面一篇文章Android应用程序安装过程源代码分析，系统中的应用程序安装好了以后，SystemServer 组件接下来就要通过ActivityManagerService来启动Home应用程序Launcher了，Launcher在启动的时候便会通过PackageManagerServic把系统中已经安装好的应用程序以快捷图标的形式展示在桌面上，这样用户就可以使用这些应用程序了，整个过程如下图所示：点击查看大图下面详细分析每一个步骤。
Step 1. SystemServer.main这个函数定义在frameworks/base/services/java/com/android/server/SystemServer.java文件中，具体可以参考前面一篇文章Android应用程序安装过程源代码分析的Step 1。
Step 2. SystemServer.init1这个函数是一个JNI方法，实现在 frameworks/base/services/jni/com_android_server_SystemServer.cpp文件中，具体可以参考前面一篇文章Android应用程序安装过程源代码分析的Step 2。
launcher
启动流程
• • • •
android如何启动launcher Launcher功能 UI布局 Launcher应用启动流程
android如何启动launcher
• 加电，cpu执行bootloader程序，正常启动系统，加 载boot.img(其中包含内核还有ramdisk) • bootloader加载kernel，kernel自解压，初始化，载 入built-in驱动程序，完成启动。内核启动后会创建 若干内核线程，在后装入并执行程序/sbin/init/,载入 init process，切换至用户空间（user-space） • Init进程启动 • Servicemanager属于Native Service,注册各项服务。 • Zygote用于初始化虚拟机的进程。 • System server主要负责Android系统初始化并启动其 他服务。System server加载所有的服务后，系统初 始化完成.
LauncherApplication->onCreate
• • • • 1.设置最小堆内存4M 2.建立应用图标缓存器 3.建立LauncherModel 4.注册Intent.ACTION_PACKAGE_ADDED, Intent.ACTION_PACKAGE_REMOVED, Intent.ACTION_PACKAGE_CHANGED事件监听器 LauncherModel作为广播接收器对上面3中事件 进行监听 • 5.添加对桌面favorites content provider 数据变 化监听器
android系统启动launcher简要流向
• Bootloader kernel内核载入built-in驱动 程序Init进程启动 Servicemanager Zygote System serverHome启动
android开机启动流程分析
Android的开机流程（/Blog/cns!F8AECD2A067A6B17!1579.entry）1.系统引导bootloader1)源码：bootable/bootloader/*2)说明：加电后，CPU将先执行bootloader程序，此处有三种选择a)开机按Camera+Power启动到fastboot，即命令或SD卡烧写模式，不加载内核及文件系统，此处可以进行工厂模式的烧写b)开机按Home+Power启动到recovery模式，加载recovery.img，recovery.img包含内核，基本的文件系统，用于工程模式的烧写c)开机按Power，正常启动系统，加载boot.img，boot.img包含内核，基本文件系统，用于正常启动手机（以下只分析正常启动的情况）2.内核kernel1)源码：kernel/*2)说明：kernel由bootloader加载3.文件系统及应用init1)源码：system/core/init/*2)配置文件：system/rootdir/init.rc，3)说明：init是一个由内核启动的用户级进程，它按照init.rc中的设置执行：启动服务（这里的服务指linux底层服务，如adbd提供adb支持，vold提供SD卡挂载等），执行命令和按其中的配置语句执行相应功能4.重要的后台程序zygote1)源码：frameworks/base/cmds/app_main.cpp等2)说明：zygote是一个在init.rc中被指定启动的服务，该服务对应的命令是/system/bin/app_processa)建立Java Runtime，建立虚拟机b)建立Socket接收ActivityManangerService的请求，用于Fork应用程序c)启动System Server5.系统服务system server1)源码：frameworks/base/services/java/com/android/server/SystemServer.java2)说明：被zygote启动，通过System Manager管理android的服务（这里的服务指frameworks/base/services下的服务，如卫星定位服务，剪切板服务等）6.桌面launcher1)源码：ActivityManagerService.java为入口，packages/apps/launcher*实现2)说明：系统启动成功后SystemServer使用xxx.systemReady()通知各个服务，系统已经就绪，桌面程序Home就是在ActivityManagerService.systemReady()通知的过程中建立的，最终调用startHomeActivityLocked()启launcher7.解锁1)源码：frameworks/policies/base/phone/com/android/internal/policy/impl/*lock*2)说明：系统启动成功后SystemServer调用wm.systemReady()通知WindowManagerService，进而调用PhoneWindowManager，最终通过LockPatternKeyguardView显示解锁界面，跟踪代码可以看到解锁界面并不是一个Activity，这是只是向特定层上绘图，其代码了存放在特殊的位置8.开机自启动的第三方应用程序1)源码：frameworks/base/services/java/com/android/server/am/ActivityManagerService.java2)说明：系统启动成功后SystemServer调用ActivityManagerNative.getDefault().systemReady()通知ActivityManager启动成功，ActivityManager会通过置变量mBooting，通知它的另一线程，该线程会发送广播android.intent.action.BOOT_COMPLETED以告知已注册的第三方程序在开机时自动启动。
Android启动过程
1. Boot系统初始化，具体过程参见(system\core\init\Init.c)中的main函数，这时候，手机或者模拟器出现的画面是一个console，显示“ANDROID”msg。
2. 初始化成功后，就开始mounting系统，具体参见(system\core\mountd\Mountd.c) 中的main 函数。
3．接下来运行ndroidRuntime，并开始启动java虚拟机dalvikvm。
4. Java虚拟机启动成功后，开始系统初始化。
系统初始的第一步是用JNI方式实现的，对应java代码为(frameworks\base\services\java\com\android\server\SystemServer.java) init1（Native）函数，对应的JNI C++代码为(frameworks\base\core\jni\server\com_android_server_SystemServer.cpp)，而实现的C++代码为(frameworks\base\cmds\system_server\library\ System_init.cpp) 中的system_init（）函数。
5. system_init调用SurfaceFlinger，SurfaceFlinger的readyToRun()函数用BootAnimation来实现开机动画，这时候手机或者模拟器显示是一副背景图加一个动态的小机器人。
6. 系统初始化的第二步，将启动ServerThread进程，参见SystemServer.init2()。
ServerThread 将启动各种系统服务，如Power Manager、Activity Manager等等，具体参见ServerThread的run函数，ServerThread同在SystemServer.java中。
7.这之后的事，应该就是进入系统了。
android开机启动流程说明
android开机启动流程说明第一步：启动linux1.Bootloader2.Kernel第二步android系统启动：入口为init.rc(system\core\rootdir)1./system/bin/service manager: Binder 守护进程；2.Runtime;3.Zygote :app-process/app-main;4.Start VM;5.Start server6.Start android service:Register to service Manager7.Start Launcher第三步：应用程序启动：运行package Managerl Init进程Android系统在启动时首先会启动Linux系统，引导加载Linux Kernel并启动init进程。
Init进程是一个由内核启动的用户级进程，是Android系统的第一个进程。
该进程的相关代码在platform\system\core\init\init.c。
在main 函数中，有如下代码：open_devnull_stdio();log_init();INFO("reading config file\n");init_parse_config_file("/init.rc");/* pull the kernel commandline and ramdisk properties file in */import_kernel_cmdline(0);get_hardware_name(hardware, &revision);snprintf(tmp, sizeof(tmp), "/init.%s.rc", hardware);init_parse_config_file(tmp);这里会加载解析init.rc和init.hardware.rc两个初始化脚本。
Android 启动过程
第1章Android 启动过程1.1Android 启动介绍众所周知，Android是一款基于linux基础的开放源代码的手机操作系统，是以linux内核为操作系统的内核。
那Android的启动也是在linux内核加载之后进行的。
Linux内核由bootloader加载后，经自解压、初始化、顺序载入内核模块(其中包含驱动程序)等。
在内核加载完成之后，会根据内核的传递参数寻找android的第一个用户态进程，即init进程。
Init进程根据init.rc以及init.$(hardware).rc脚本文件来启动android的必要的服务。
直到完成android 的HOME的启动。
1.1.1启动总体框架1.1.2Linux Kernel启动Start_kernel(/init/main.c),是内核启动的入口函数，它所做的事情很多，比如：中断和内存的初始化，以及内核模块的加载等。
在start_kernel函数的最后调用了rest_init。
static noinline void __init_refok rest_init(void){int pid;……kernel_thread(kernel_init, NULL, CLONE_FS | CLONE_SIGHAND);……}注意到在rest_init函数中开启了一个kernel_init的内核线程。
继续看kernel_init。
static int __init kernel_init(void * unused){……init_post();return 0;}static noinline int init_post(void){……run_init_process("/sbin/init");run_init_process("/etc/init");run_init_process("/bin/init");run_init_process("/bin/sh");panic("No init found. Try passing init= option to kernel. ""See Linux Documentation/init.txt for guidance.");}1.1.3Android Init进程Android是基于linux内核的，在内核引导和加载完毕，从上面的代码可以看出init进程是从内核态转换到到用户态的第一个应用程序。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
在前面一篇文章中，我们分析了Android系统在启动时安装应用程序的过程，这些应用程序安装好之后，还需要有一个Home应用程序来负责把它们在桌面上展示出来，在Android系统中，这个默认的Home 应用程序就是Launcher了，本文将详细分析Launcher应用程序的启动过程。
Android系统的Home应用程序Launcher是由ActivityManagerService启动的，而ActivityManagerService和PackageManagerService一样，都是在开机时由SystemServer组件启动的，SystemServer组件首先是启动ePackageManagerServic，由它来负责安装系统的应用程序，具体可以参考前面一篇文章Android应用程序安装过程源代码分析，系统中的应用程序安装好了以后，SystemServer 组件接下来就要通过ActivityManagerService来启动Home应用程序Launcher了，Launcher在启动的时候便会通过PackageManagerServic把系统中已经安装好的应用程序以快捷图标的形式展示在桌面上，这样用户就可以使用这些应用程序了，整个过程如下图所示：点击查看大图下面详细分析每一个步骤。
Step 1. SystemServer.main这个函数定义在frameworks/base/services/java/com/android/server/SystemServer.java文件中，具体可以参考前面一篇文章Android应用程序安装过程源代码分析的Step 1。
Step 2. SystemServer.init1这个函数是一个JNI方法，实现在 frameworks/base/services/jni/com_android_server_SystemServer.cpp文件中，具体可以参考前面一篇文章Android应用程序安装过程源代码分析的Step 2。
Step 3. libsystem_server.system_init函数system_init实现在libsystem_server库中，源代码位于frameworks/base/cmds/system_server/library/system_init.cpp文件中，具体可以参考前面一篇文章Android应用程序安装过程源代码分析的Step 3。
Step 4. AndroidRuntime.callStatic这个函数定义在frameworks/base/core/jni/AndroidRuntime.cpp文件中，具体可以参考前面一篇文章Android应用程序安装过程源代码分析的Step 4。
Step 5. SystemServer.init2这个函数定义在frameworks/base/services/java/com/android/server/SystemServer.java文件中，具体可以参考前面一篇文章Android应用程序安装过程源代码分析的Step 5。
Step 6. ServerThread.run这个函数定义在frameworks/base/services/java/com/android/server/SystemServer.java文件中，具体可以参考前面一篇文章Android应用程序安装过程源代码分析的Step 6。
Step 7. ActivityManagerService.main这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityManagerServcie.java文件中：view plain1.public final class ActivityManagerService extends ActivityManagerNative2.implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {3. ......4.5.public static final Context main(int factoryTest) {6. AThread thr = new AThread();7. thr.start();8.9.synchronized (thr) {10.while (thr.mService == null) {11.try {12. thr.wait();13. } catch (InterruptedException e) {14. }15. }16. }17.18. ActivityManagerService m = thr.mService;19. mSelf = m;20. ActivityThread at = ActivityThread.systemMain();21. mSystemThread = at;22. Context context = at.getSystemContext();23. m.mContext = context;24. m.mFactoryTest = factoryTest;25. m.mMainStack = new ActivityStack(m, context, true);26.27. m.mBatteryStatsService.publish(context);28. m.mUsageStatsService.publish(context);29.30.synchronized (thr) {31. thr.mReady = true;32. thr.notifyAll();33. }34.35. m.startRunning(null, null, null, null);36.37.return context;38. }39.40. ......41.}这个函数首先通过AThread线程对象来内部创建了一个ActivityManagerService实例，然后将这个实例保存其成员变量mService中，接着又把这个ActivityManagerService实例保存在ActivityManagerService类的静态成员变量mSelf中，最后初始化其它成员变量，就结束了。
Step 8. PackageManagerService.main这个函数定义在frameworks/base/services/java/com/android/server/PackageManagerService.java 文件中，具体可以参考前面一篇文章Android应用程序安装过程源代码分析的Step 7。
执行完这一步之后，系统中的应用程序的所有信息都保存在PackageManagerService中了，后面Home应用程序Launcher 启动起来后，就会把PackageManagerService中的应用程序信息取出来，然后以快捷图标的形式展示在桌面上，后面我们将会看到这个过程。
Step 9. ActivityManagerService.setSystemProcess这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityManagerServcie.java文件中：view plain1.public final class ActivityManagerService extends ActivityManagerNative2.implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {3. ......4.5.public static void setSystemProcess() {6.try {7. ActivityManagerService m = mSelf;8.9. ServiceManager.addService("activity", m);10. ServiceManager.addService("meminfo", new MemBinder(m));11.if (MONITOR_CPU_USAGE) {12. ServiceManager.addService("cpuinfo", new CpuBinder(m));13. }14. ServiceManager.addService("permission", new PermissionController(m));15.16. ApplicationInfo info =17. mSelf.mContext.getPackageManager().getApplicationInfo(18."android", STOCK_PM_FLAGS);19. mSystemThread.installSystemApplicationInfo(info);20.21.synchronized (mSelf) {22. ProcessRecord app = mSelf.newProcessRecordLocked(23. mSystemThread.getApplicationThread(), info,24. info.processName);25. app.persistent = true;26. app.pid = MY_PID;27. app.maxAdj = SYSTEM_ADJ;28. mSelf.mProcessNames.put(app.processName, .uid, app);29.synchronized (mSelf.mPidsSelfLocked) {30. mSelf.mPidsSelfLocked.put(app.pid, app);31. }32. mSelf.updateLruProcessLocked(app, true, true);33. }34. } catch (NotFoundException e) {35.throw new RuntimeException(36."Unable to find android system package", e);37. }38. }39. ......40.}这个函数首先是将这个ActivityManagerService实例添加到ServiceManager中去托管，这样其它地方就可以通过ServiceManager.getService接口来访问这个全局唯一的ActivityManagerService实例了，接着又通过调用mSystemThread.installSystemApplicationInfo函数来把应用程序框架层下面的android包加载进来，这里的mSystemThread是一个ActivityThread类型的实例变量，它是在上面的Step 7中创建的，后面就是一些其它的初始化工作了。