1、Android中第一个被启动的进程——init，init进程的PID为1，其他的服务都由其进行创建。它是通过解析init.rc脚本来构建出系统的初始运行状态的。init进程是在系统启动启动过程中启动的。 2、init.rc语法规则： 1）Actions动作 一个Action实际上就是相应某个事件的过程。下面给出boot事件的脚本
/* \system\core\rootdir\init.rc*/
on boot
# basic network init
ifup lo
hostname localhost
domainname localdomain
# set RLIMIT_NICE to allow priorities from 19 to -20
setrlimit 13 40 40
# Memory management. Basic kernel parameters, and allow the high
# level system server to be able to adjust the kernel OOM driver
# parameters to match how it is managing things.
write /proc/sys/vm/overcommit_memory 1
write /proc/sys/vm/min_free_order_shift 4
chown root system /sys/module/lowmemorykiller/parameters/adj
chmod 0220 /sys/module/lowmemorykiller/parameters/adj
chown root system /sys/module/lowmemorykiller/parameters/minfree
chmod 0220 /sys/module/lowmemorykiller/parameters/minfree
....
语法规则： on <trigger> #触发条件 <command> #执行命令 <command> #执行命令 ........ 当<trigger>所描述的触发事件产生时，便会依次执行各种command
Commands命令: ifup <interface> 使用网络接口<interface>成功连接 hostname <name> 设置主机名为<name> domainname <name> 设置域名 start <service> 如果该服务为运行的话，启动该服务 stop <service> 如果该服务正在运行的话，停止该服务 .............
2）Services服务 Services是可执行程序，它们在特定选项的约束下会被init程序运行或者重启。 先看个实例，下面是启动ServiceManager的脚本：
/* \system\core\rootdir\init.rc*/
//组件 进程名 程序文件
service servicemanager /system/bin/servicemanager //service 表明SM是以服务的形式启动的
class core
user system //表明进程是以系统用户system身份运行的
group system
critical /* 表明SM是系统中的一个关键服务，
* 在系统运行过程中，关键服务是不允许退出的；一旦退出，就会被系统重启；
* 而如果一个关键服务在4分钟内退出次数大于4，则系统会重启*/
onrestart restart healthd /* 表明一旦SM被重启，这些进程zygote等也会被重启*/
onrestart restart zygote
onrestart restart media
onrestart restart surfaceflinger
onrestart restart drm
options(约束选项) class <name> 为该Service指定一个class名。同一个class的所有服务必须同时启动或者停止；默认情况下所有Service的class均为"default" user <username> 再启动服务前将用户切换至<username>,默认情况下用户都是root group <groupname> [<groupname>]* 再启动服务前将用户组切换至<groupname> critical 表明这是对设备至关重要的一个服务。如果它在四分钟内退出超过四次，则设备将重启进入恢复模式 disabled 此服务不会自动启动，而是需要通过显示调用服务名来启动 oneshot 在此服务退出时，不要主动去重启它 onrestart 当此服务重启时，执行这些命令
二、系统关键服务 1、Zygote服务 Zygote依然是Android系统的核心，zygote是受精卵的意思，可以认为是Android framework大家族的祖先！Android中大多数应用进程和系统进程都是通过Zygote来生成的。
zygote本身是一个应用层的程序，和驱动，内核模块之类的没点关系。zygote的启动由linux的祖先init启动。zygote，其最初的名字是app_process，通过直接调用pctrl把名字给改成了”zygote”。
来看一下Zygote进程在脚本中是被如何启动的：/* \system\core\rootdir\init.zygote64.rc */可以看到Zygote的class是main（ManagerService的class是core），其路径在/system/bin/app_process64（类似的还有32,32_64,64_32情况）；后面跟的都是Zygote的参数。
service zygote /system/bin/app_process64 -Xzygote /system/bin --zygote --start-system-server
class main
socket zygote stream 660 root system
onrestart write /sys/android_power/request_state wake
onrestart write /sys/power/state on
onrestart restart media
onrestart restart netd
0）Zygote总的启动过程：
![[置顶] Android启动过程——init,Zygote,SystemServer](https://image.shishitao.com:8440/aHR0cHM6Ly93d3cuaXRkYWFuLmNvbS9pbWdzLzQvOS85LzYvMjMvYjgzNTczMmI0ZDZiZmVkMTJhMTQ1ZGQ3YWMyNTQ2NzQuanBl.jpe?w=700&webp=1 "[置顶] Android启动过程——init,Zygote,SystemServer")
1）Zygote的源码路径在\frameworks\base\cmds\app_process文件夹中：
![[置顶] Android启动过程——init,Zygote,SystemServer](https://image.shishitao.com:8440/aHR0cHM6Ly93d3cuaXRkYWFuLmNvbS9pbWdzLzQvNS85LzkvMzMvNGEwMDFjMTNjMGY0NDJlOGFjNDNiYzhkMWFhMTVkMjguanBl.jpe?w=700&webp=1 "[置顶] Android启动过程——init,Zygote,SystemServer")
2）先来看Android.mk文件：
LOCAL_PATH:= $(call my-dir)其涉及的主要文件是app_main.cpp；
include $(CLEAR_VARS)
LOCAL_SRC_FILES:= \
app_main.cpp
LOCAL_LDFLAGS := -Wl,--version-script,art/sigchainlib/version-script.txt -Wl,--export-dynamic
LOCAL_SHARED_LIBRARIES := \
libdl \
libcutils \
libutils \
liblog \
libbinder \
libandroid_runtime
LOCAL_WHOLE_STATIC_LIBRARIES := libsigchain
LOCAL_MODULE:= app_process
LOCAL_MULTILIB := both
LOCAL_MODULE_STEM_32 := app_process32
LOCAL_MODULE_STEM_64 := app_process64
include $(BUILD_EXECUTABLE)
# Create a symlink from app_process to app_process32 or 64
# depending on the target configuration.
include $(BUILD_SYSTEM)/executable_prefer_symlink.mk
# Build a variant of app_process binary linked with ASan runtime.
# ARM-only at the moment.
ifeq ($(TARGET_ARCH),arm)
/** \frameworks\base\cmds\app_process\app_main.cpp **/
int main(int argc, char* const argv[])
{
......
// 注意runtime是AppRuntime对象
AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));
/** 中间一系列代码用以解析传入参数argv **/
++i;
/*** 这些参数正是在脚本中传入的Arguments**/
while (i < argc) {
const char* arg = argv[i++];
if (strcmp(arg, "--zygote") == 0) {
zygote = true;
/* 注意这里对名字进行了修改，原来的名称为app_process,这里更改为zygote
* @value static const char ZYGOTE_NICE_NAME[] = "zygote";*/
niceName = ZYGOTE_NICE_NAME;
} else if (strcmp(arg, "--start-system-server") == 0) {
startSystemServer = true;
} else if (strcmp(arg, "--application") == 0) {
application = true;
} else if (strncmp(arg, "--nice-name=", 12) == 0) {
niceName.setTo(arg + 12);
} else if (strncmp(arg, "--", 2) != 0) {
className.setTo(arg);
break;
} else {
--i;
break;
}
}
......
/** 传进来的参数 --zygote,则zygote值为true **/
if (zygote) {
// 下面接下来分析AppRuntime类的start方法时如何启动
runtime.start("com.android.internal.os.ZygoteInit", args);
} elseif (className) {
runtime.start("com.android.internal.os.RuntimeInit", args);
} else {
....
return 10;
}
}
/*可以看到这里开启了VM虚拟机，使得Zygote进程最终也运行在虚拟机上，进而去预装载各种系统类，启动SystemServer(这是大部分Android系统服务的所在地)，而逐步建立起各种SystemServer的运行环境。 上面代码主要完成了三件事情：1>调用了startVM来开启VM虚拟机 2>调用startReg来注册JNI方法 3>调用com.android.inernel.ZygoteInit类的main函数；
* 这里启动Android Runtime.它实现了启动虚拟机，同时通过"className"来调用
* 该类中的main函数（"static void main(String[] args)"）;
*/
/* \frameworks\base\core\jni\AndroidRuntime.cpp */
void AndroidRuntime::start(const char* className, const Vector<String8>& options)
{
static const String8 startSystemServer("start-system-server");
/*
* 'startSystemServer == true' means runtime is obsolete and not run from
* init.rc anymore, so we print out the boot start event here.
*/
for (size_t i = 0; i < options.size(); ++i) {
if (options[i] == startSystemServer) {
const int LOG_BOOT_PROGRESS_START = 3000;
LOG_EVENT_LONG(LOG_BOOT_PROGRESS_START, ns2ms(systemTime(SYSTEM_TIME_MONOTONIC)));
}
}
// 设置环境变量ANDROID_ROOT为/system
const char* rootDir = getenv("ANDROID_ROOT");
if (rootDir == NULL) {
rootDir = "/system";
if (!hasDir("/system")) {
LOG_FATAL("No root directory specified, and /android does not exist.");
return;
}
setenv("ANDROID_ROOT", rootDir, 1);
}
/*******开启虚拟机 **********/
JniInvocation jni_invocation;
jni_invocation.Init(NULL);
JNIEnv* env;
if (startVm(&mJavaVM, &env) != 0) {
return;
}
onVmCreated(env);
/*
* Register android functions.
*/
if (startReg(env) < 0) {
ALOGE("Unable to register all android natives\n");
return;
}
/*
* 调用main函数
* We want to call main() with a String array with arguments in it.
* At present we have two arguments, the class name and an option string.
* Create an array to hold them.
*/
jclass stringClass;
jobjectArray strArray;
jstring classNameStr;
stringClass = env->FindClass("java/lang/String");
assert(stringClass != NULL);
strArray = env->NewObjectArray(options.size() + 1, stringClass, NULL);
assert(strArray != NULL);
classNameStr = env->NewStringUTF(className);
assert(classNameStr != NULL);
env->SetObjectArrayElement(strArray, 0, classNameStr);
for (size_t i = 0; i < options.size(); ++i) {
jstring optionsStr = env->NewStringUTF(options.itemAt(i).string());
assert(optionsStr != NULL);
env->SetObjectArrayElement(strArray, i + 1, optionsStr);
}
/*
* 启动VM虚拟机，而且这个线程也会变成VM的主线程，当VM退出前该线程都不会退出
*/
char* slashClassName = toSlashClassName(className);
jclass startClass = env->FindClass(slashClassName);
if (startClass == NULL) {
ALOGE("JavaVM unable to locate class '%s'\n", slashClassName);
/* keep going */
} else {
jmethodID startMeth = env->GetStaticMethodID(startClass, "main",
"([Ljava/lang/String;)V");
if (startMeth == NULL) {
ALOGE("JavaVM unable to find main() in '%s'\n", className);
/* keep going */
} else {
env->CallStaticVoidMethod(startClass, startMeth, strArray);
#if 0
if (env->ExceptionCheck())
threadExitUncaughtException(env);
#endif
}
}
free(slashClassName);
ALOGD("Shutting down VM\n");
if (mJavaVM->DetachCurrentThread() != JNI_OK)
ALOGW("Warning: unable to detach main thread\n");
if (mJavaVM->DestroyJavaVM() != 0)
ALOGW("Warning: VM did not shut down cleanly\n");
}
三、ZygoteInit： 一旦脚本中定义了Arguments——“--start-system-server”，ZygoteInit就会调用startSystemServer方法来进入SystemServer。
1、先接着上面来看，进入ZygoteInit#main方法：
/* @path: \frameworks\base\core\java\com\android\internal\os\ZygoteInit.java */上面main函数中主要完成三项工作的内容： 1> 调用registerZygoteSocket函数创建了一个socket接口，用来和ActivityManagerService通讯; 2> 调用startSystemServer函数来启动SystemServer组件，将系统的关键服务启动起来; 3> 调用runSelectLoopMode函数进入一个无限循环,等待AMS请求创建新的应用程序进程。
public static void main(String argv[]) {
try {
......
/*** 创建了一个socket接口，用来和ActivityManagerService(AMS)通讯 **/
registerZygoteSocket(socketName);
......
// zygote的简单初始化
SamplingProfilerIntegration.writeZygoteSnapshot();
// 启动后的进行一次初始化GC
gc();
if (startSystemServer) {
/*** 启动SystemServer组件 ***/
startSystemServer(abiList, socketName);
}
/** 进入一个无限循环，在前面创建的socket接口上等待AMS请求创建新的应用程序进程。 **/
runSelectLoop(abiList);
// 关闭socket接口
closeServerSocket();
} catch (MethodAndArgsCaller caller) {
} catch (RuntimeException ex) {
......
}
}
2、ZygoteInit#registerZygoteSocket方法： 该方法用来创建一个Server端的socket，用来等待Activity管理服务AMS请求Zygote进程来创建新的应用程序进程的。
/**
* @path： \frameworks\base\core\java\com\android\internal\os\ZygoteInit.java
* 注册一个Server端的socket来实现zygote命令通信
*/
private static void registerZygoteSocket(String socketName) {
if (sServerSocket == null) {
int fileDesc;
// @value private static final String ANDROID_SOCKET_PREFIX = "ANDROID_SOCKET_";
final String fullSocketName = ANDROID_SOCKET_PREFIX + socketName;
try {
// 获得一个名称为fullSocketName的系统环境变量名
String env = System.getenv(fullSocketName);
// 将其转化为一个文件描述符，用来描述一个类型为AF_UNIX的socket
fileDesc = Integer.parseInt(env);
} catch (RuntimeException ex) {
.......
}
try {
// 通过该文件描述符来创建Server端的socket
sServerSocket = new LocalServerSocket(createFileDescriptor(fileDesc));
} catch (IOException ex) {
......
}
}
}
上面代码完成了三件事情： 1>调用System.getenv 2>调用Integer.phraseInt 3>通过该文件描述符来创建一个Server端的Socket（LocalServerSocket对象），等待AMS向Zygote进程发送的创建新应用程序进程的请求。
3、ZygoteInit#startSystemServer来创建System进程来启动SystemServer组件
/**上面代码中通过调用Zygote.forkSystemServer来创建一个新的子进程（即Android系统中的System进程）；进而通过调用函数handleSystemServerProcess来启动System进程，进而启动各种系统服务。
* @path: \frameworks\base\core\java\com\android\internal\os\ZygoteInit.java
* Prepare the arguments and fork for the system server process.
*/
private static boolean startSystemServer(String abiList, String socketName)
throws MethodAndArgsCaller, RuntimeException {
......
/* 保存System进程的相关启动参数 */
String args[] = {
"--setuid=1000",
"--setgid=1000",
"--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1032,3001,3002,3003,3006,3007",
"--capabilities=" + capabilities + "," + capabilities,
"--runtime-init",
"--nice-name=system_server",
"com.android.server.SystemServer",// 这里是SystemServer所在的包的完整名称
};
ZygoteConnection.Arguments parsedArgs = null;
int pid;
try {
// 解析参数值
parsedArgs = new ZygoteConnection.Arguments(args);
ZygoteConnection.applyDebuggerSystemProperty(parsedArgs);
ZygoteConnection.applyInvokeWithSystemProperty(parsedArgs);
/** 通过此函数来生成一个新的进程，用以承载各种系统服务，
* 该函数最终实现调用底层的fork来产生一个新的进程，
* 这个子进程就是Android系统的System进程 **/
pid = Zygote.forkSystemServer(
parsedArgs.uid, parsedArgs.gid,
parsedArgs.gids,
parsedArgs.debugFlags,
null,
parsedArgs.permittedCapabilities,
parsedArgs.effectiveCapabilities);
// 由前面args参数值可以看出System进程的UID（用户ID）和SID（用户组ID）均设置为1000
} catch (IllegalArgumentException ex) {
throw new RuntimeException(ex);
}
/* pid=0 表示为子进程 */
if (pid == 0) {
if (hasSecondZygote(abiList)) {
waitForSecondaryZygote(socketName);
}
/*** 子进程即是SystemServer所在进程，通过调用该函数来实现启动各种系统服务***/
handleSystemServerProcess(parsedArgs);
}
return true;
}
4、ZygoteInit#runSelectLoop:(这里源码是5.1，不再是runSelectLoopMode)
/** @path \frameworks\base\core\java\com\android\internal\os\ZygoteInit.java*/这里是个通常模式的消息循环处理模式，通过静态成员函数selectReadable来判断系统保存的socket是否有数据可读。当AMS与Zygote进程通过socket建立连接，并且AMS向Zygote进程发送创建新的应用程序进程的请求时，调用ZygoteConnection.runOnce来创建新的进程。
private static void runSelectLoop(String abiList) throws MethodAndArgsCaller {
ArrayList<FileDescriptor> fds = new ArrayList<FileDescriptor>();
ArrayList<ZygoteConnection> peers = new ArrayList<ZygoteConnection>();
// 创建一个大小为4的Socket文件描述符数组fdArray,表示Zygote进程最多能同时处理4个socket连接
FileDescriptor[] fdArray = new FileDescriptor[4];
// 前面创建的Server端的Socket，该变量是静态成员变量，将其添加到文件描述符列表fds中
fds.add(sServerSocket.getFileDescriptor());
peers.add(null);
int loopCount = GC_LOOP_COUNT;
/** 消息循环处理 **/
while (true) {
int index;
// gc相关
if (loopCount <= 0) {
gc();
loopCount = GC_LOOP_COUNT;
} else {
loopCount--;
}
try {
// 将fds中的socket转换到fdArray中
fdArray = fds.toArray(fdArray);
/** 调用selectReadable来监控fdArray中的Socket有数据可读
* （有数据可读意味该socket接收到了一个连接或一个请求） */
index = selectReadable(fdArray);
} catch (IOException ex) {
......
}
if (index < 0) {
......
} else if (index == 0) {// 说明AMS与Zygote进程建立了新的连接，但此时并未请求创建新进程
// 这里只是将连接描述符添加到fds数组中
ZygoteConnection newPeer = acceptCommandPeer(abiList);
peers.add(newPeer);
fds.add(newPeer.getFileDescriptor());
} else { // 说明AMS向Zygote进程发送了一个创建应用程序进程的请求
boolean done;
/** 调用runOnce来创建一个新的应用进程*/
done = peers.get(index).runOnce();
// 处理完请求后，断开连接
if (done) {
peers.remove(index);
fds.remove(index);
}
}
}
}
四、System进程的启动过程
前面3.3中分析ZygoteInit.startSystemServer中提到，系统调用handleSystemServerProcess方法来启动System进程。
/** @path: \frameworks\base\core\java\com\android\internal\os\ZygoteInit.java */上面代码中完成两件事： 1>调用closeServerSocket来关闭由Zygote进程中复制来的Socket 2>调用RuntimeInit.zygoteInit方法来进一步启动System进程
private static void handleSystemServerProcess(ZygoteConnection.Arguments parsedArgs)
throws ZygoteInit.MethodAndArgsCaller {
/* System进程是由System进程fork来的，因此它就会获得Zygote进程中前面创建的Server端Socket
* 而实际System今进程中并不需要这个socket，因此将它关闭*/
closeServerSocket();
// 设置名称
if (parsedArgs.niceName != null) {
Process.setArgV0(parsedArgs.niceName);
}
final String systemServerClasspath = Os.getenv("SYSTEMSERVERCLASSPATH");
if (systemServerClasspath != null) {
performSystemServerDexOpt(systemServerClasspath);
}
if (parsedArgs.invokeWith != null) {
....
} else {
ClassLoader cl = null;
if (systemServerClasspath != null) {
cl = new PathClassLoader(systemServerClasspath, ClassLoader.getSystemClassLoader());
Thread.currentThread().setContextClassLoader(cl);
}
/** 传递剩余的参数到SystemServer中，进一步启动System进程 */
RuntimeInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs, cl);
}
}
2、RuntimeInit.zygoteInit():
/** @path: \frameworks\base\core\java\com\android\internal\os\RuntimeInit.java */上面主要完成三件事情： 1>调用commonInit来设置System进程的时区和键盘布局等通用信息 2>调用nativeZygoteInit在System进程中创建一个Binder线程池，nativeZygoteInit会进而调用一个native方法来实现 3>调用applicationInit，其实是调用invokeStaticMain来进入SystemServer中的main函数。
public static final void zygoteInit(int targetSdkVersion, String[] argv, ClassLoader classLoader)
throws ZygoteInit.MethodAndArgsCaller {
if (DEBUG) Slog.d(TAG, "RuntimeInit: Starting application from zygote");
// 将Sytem.out与err输出到log中
redirectLogStreams();
/** 设置System进程的时区和键盘布局等通用信息 */
commonInit();
/** 在System进程中创建一个Binder线程池，nativeZygoteInit会进而调用一个native方法来实现 */
nativeZygoteInit();
/** 转往执行SystemServer中的main函数*/
applicationInit(targetSdkVersion, argv, classLoader);
}
private static void applicationInit(int targetSdkVersion, String[] argv, ClassLoader classLoader)
throws ZygoteInit.MethodAndArgsCaller {
// If the application calls System.exit(), terminate the process
// immediately without running any shutdown hooks. It is not possible to
// shutdown an Android application gracefully. Among other things, the
// Android runtime shutdown hooks close the Binder driver, which can cause
// leftover running threads to crash before the process actually exits.
nativeSetExitWithoutCleanup(true);
// We want to be fairly aggressive about heap utilization, to avoid
// holding on to a lot of memory that isn't needed.
VMRuntime.getRuntime().setTargetHeapUtilization(0.75f);
VMRuntime.getRuntime().setTargetSdkVersion(targetSdkVersion);
final Arguments args;
try {
args = new Arguments(argv);
} catch (IllegalArgumentException ex) {
Slog.e(TAG, ex.getMessage());
// let the process exit
return;
}
// Remaining arguments are passed to the start class's static main
/** 由于System进程进入到SystemServer类的main函数中时，已经执行过很多代码了
* 因此严格意义上，main已经不是System的入口函数；
* 为了使得main看起来像System进程的入口函数，而使用该函数来巧妙地去调用它*/
invokeStaticMain(args.startClass, args.startArgs, classLoader);
}
3、SystemServer#main: 在书中的分析中一般都是讲通过调用main函数，进而调用init1与init2函数；但是这里是基于Android5.1的源码，SystemServer貌似发生了很大的变化，不再存在init1与init2函数了。
（一）下面基于按照书上流程，基于Android4.2分析：1）先来看SystemServer#main函数：
/** @path \frameworks\base\services\java\com\android\server\SystemServer.java **/main函数这里调用了重要的init1函数，该函数是个native本地方法。查到其本地实现方法在com_android_server_SystemServer.cpp文件中。
native public static void init1(String[] args);
public static void main(String[] args) {
if (System.currentTimeMillis() < EARLIEST_SUPPORTED_TIME) {
SystemClock.setCurrentTimeMillis(EARLIEST_SUPPORTED_TIME);
}
......
// Mmmmmm... more memory!
dalvik.system.VMRuntime.getRuntime().clearGrowthLimit();
// The system server has to run all of the time, so it needs to be
// as efficient as possible with its memory usage.
VMRuntime.getRuntime().setTargetHeapUtilization(0.8f);
System.loadLibrary("android_servers");
/** 看到这里调用了一个重要的方法 init1 **/
init1(args);
}
2）com_android_server_SystemServer#android_server_SystemServer_init1:
/** @path \frameworks\base\services\jni\com_android_server_SystemServer.cpp*/看到android_server_SystemServer_init1函数仅仅是一个包装函数，进而调用system_init函数来启动一些系统服务。
extern "C" int system_init();
static void android_server_SystemServer_init1(JNIEnv* env, jobject clazz)
{
system_init();
}
3）init1函数的主体实现部分：system_init():
/** @path \frameworks\base\cmds\system_server\library\system_init.cpp*/上面代码中主要实现的功能是开启一些重要的系统服务如ServiceManager，SurfaceFlinger，SensorService（传感器服务）。这些服务需要在开启Android Runtime之前就已经被启动，因此放在init1函数中；初始化这些服务完成之后，使用JNI调用SystemServer类中的init2函数，继续进行初始化。
extern"C" status_t system_init()
{
/** 前面Binder机制分析中分析 MediaServer的main函数时，其启动过程也是类似此几步流程
* http://blog.csdn.net/woliuyunyicai/article/details/46864567 */
// 获取一个ProcessState实例
sp<ProcessState> proc(ProcessState::self());
// 一个ServiceManager实例
sp<IServiceManager> sm = defaultServiceManager();
/** GrimReaper是一个死亡接收通知，具体代码见下 **/
sp<GrimReaper> grim = new GrimReaper();
// 设置SM的死亡接收通知
sm->asBinder()->linkToDeath(grim, grim.get(), 0);
char propBuf[PROPERTY_VALUE_MAX];
property_get("system_init.startsurfaceflinger", propBuf, "1");
if (strcmp(propBuf, "1") == 0) {
/*** 启动SurfaceFlinger **/
SurfaceFlinger::instantiate();
}
property_get("system_init.startsensorservice", propBuf, "1");
if (strcmp(propBuf, "1") == 0) {
// 启动SensorService（传感器服务器）
SensorService::instantiate();
}
/** 这里开启Android runtime; 我们之所以需要做前面这些事情是因为，
* Android runtime初始化之前需要这些core system services事先已经被启动。
* 其他一些服务仅需要在他们进程的main入口函数的开始（调用init函数初始化之前）进行启动即可**/
AndroidRuntime* runtime = AndroidRuntime::getRuntime();
JNIEnv* env = runtime->getJNIEnv();
if (env == NULL) {
return UNKNOWN_ERROR;
}
jclass clazz = env->FindClass("com/android/server/SystemServer");
if (clazz == NULL) {
return UNKNOWN_ERROR;
}
/** 注意这里通过JNI调用SystemServer类中init2函数，进一步进行初始化 */
jmethodID methodId = env->GetStaticMethodID(clazz, "init2", "()V");
if (methodId == NULL) {
return UNKNOWN_ERROR;
}
env->CallStaticVoidMethod(clazz, methodId);
/** 开辟Binder线程池 */
// ProcessState开辟线程池
ProcessState::self()->startThreadPool();
// IPCThreadState加入到线程池
IPCThreadState::self()->joinThreadPool();
return NO_ERROR;
}
namespace android {
/**
* This class is used to kill this process when the runtime dies.
*/
class GrimReaper : public IBinder::DeathRecipient {
public:
GrimReaper() { }
/* 当ServiceManager死亡之后，就会调用binderDied函数
* System进程通过调用kill函数来杀死自己 */
virtual void binderDied(const wp<IBinder>& who)
{
kill(getpid(), SIGKILL);
}
};
} // namespace android
下面回到SystemServer类中：
4）SystemServer#init2方法：
/** @path: \frameworks\base\services\java\com\android\server\SystemServer.java */
public static final void init2() {
/** 这里创建了一个线程，所有工作都委托给该线程进行处理*/
Thread thr = new ServerThread();
thr.setName("android.server.ServerThread");
thr.start();
}
5）SystemServer#ServerThread完成的工作：
/** @path: \frameworks\base\services\java\com\android\server\SystemServer.java */
class ServerThread extends Thread {
@Override
public void run() {
/*** 创建Looper消息循环 **/
Looper.prepareMainLooper();
// 设置进程参数
android.os.Process.setThreadPriority(
android.os.Process.THREAD_PRIORITY_FOREGROUND);
BinderInternal.disableBackgroundScheduling(true);
android.os.Process.setCanSelfBackground(false);
// 检查上次是否尝试shutdown失败
{
......
}
......
/** 创建一个系统内共享的UI Handler，它至少能够被一下组件所使用：
* - WindowManagerPolicy
* - KeyguardViewManager
* - DisplayManagerService **/
HandlerThread uiHandlerThread = new HandlerThread("UI");
uiHandlerThread.start();
Handler uiHandler = new Handler(uiHandlerThread.getLooper());
uiHandler.post(new Runnable() {
@Override
public void run() {
android.os.Process.setThreadPriority(
android.os.Process.THREAD_PRIORITY_FOREGROUND);
android.os.Process.setCanSelfBackground(false);
}
});
/*** 创建一个仅供WindowManager共享的Handler线程 **/
HandlerThread wmHandlerThread = new HandlerThread("WindowManager");
wmHandlerThread.start();
Handler wmHandler = new Handler(wmHandlerThread.getLooper());
wmHandler.post(new Runnable() {
@Override
public void run() {
android.os.Process.setThreadPriority(
android.os.Process.THREAD_PRIORITY_DISPLAY);
android.os.Process.setCanSelfBackground(false);
}
});
// Critical services...
boolean onlyCore = false;
try {
/** 创建Installer实例 **/
Slog.i(TAG, "Waiting for installd to be ready.");
installer = new Installer();
installer.ping();
/*** 使用SM注册启动一些重要的服务，这里仅挑选了其中几个重要的Service**/
// Power Manager
power = new PowerManagerService();
ServiceManager.addService(Context.POWER_SERVICE, power);
// Activity Manager
context = ActivityManagerService.main(factoryTest);
// Display Manager
display = new DisplayManagerService(context, wmHandler, uiHandler);
ServiceManager.addService(Context.DISPLAY_SERVICE, display, true);
// Telephony Registry
telephonyRegistry = new TelephonyRegistry(context);
ServiceManager.addService("telephony.registry", telephonyRegistry);
AttributeCache.init(context);
// Package Manager
pm = PackageManagerService.main(context, installer,
factoryTest != SystemServer.FACTORY_TEST_OFF, onlyCore);
ServiceManager.addService(Context.USER_SERVICE, UserManagerService.getInstance());
mContentResolver = context.getContentResolver();
// Content Manager
contentService = ContentService.main(context, factoryTest == SystemServer.FACTORY_TEST_LOW_LEVEL);
ActivityManagerService.installSystemProviders();
// Input Manager
inputManager = new InputManagerService(context, wmHandler);
// Window Manager
wm = WindowManagerService.main(context, power, display, inputManager,
uiHandler, wmHandler,
factoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL,
!firstBoot, onlyCore);
ServiceManager.addService(Context.WINDOW_SERVICE, wm);
ServiceManager.addService(Context.INPUT_SERVICE, inputManager);
ActivityManagerService.self().setWindowManager(wm);
} catch (RuntimeException e) {
}
......
/** Looper消息处理 **/
Looper.loop();
}
}
上面线程主要完成的事情包括有创建Looper消息循环；以及启动一些系统的关键服务，比如ActivityManagerService、ContentService等，并将其注册到ServiceManager中。
下面来看这几个重要的服务是如何启动的；
五、一些重要的系统服务Service：
1、 AMS（ActivityManagerService）Activity管理服务
调用：ActivityManagerService.main(factoryTest)
其通过调用ActivityManagerService类中的静态方法main来启动的：/** @path \frameworks\base\services\java\com\android\server\am\ActivityManagerService.java **/
public final class ActivityManagerService extends ActivityManagerNative
implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
static ActivityManagerService mSelf;
public static final Context main(int factoryTest) {
/** 创建一个AThread线程 */
AThread thr = new AThread();
thr.start();
synchronized (thr) {
while (thr.mService == null) {
try {
thr.wait();
} catch (InterruptedException e) {
}
}
}
// 将AThread中创建的AMS实例赋值给m,再赋值给AMS静态变量mSelf
ActivityManagerService m = thr.mService;
mSelf = m;
/** AMS两个最重要核心——
* - ActivityStack：Activity的记录者与管理者，同时也为AMS管理系统运行情况提供了基础
* - ActivityTask**/
ActivityThread at = ActivityThread.systemMain();
mSystemThread = at;
Context context = at.getSystemContext();
context.setTheme(android.R.style.Theme_Holo);
m.mContext = context;
m.mFactoryTest = factoryTest;
m.mMainStack = new ActivityStack(m, context, true);
m.mBatteryStatsService.publish(context);
m.mUsageStatsService.publish(context);
synchronized (thr) {
thr.mReady = true;
thr.notifyAll();
}
/*** 开始运行 ***/
m.startRunning(null, null, null, null);
return context;
}
static class AThread extends Thread {
ActivityManagerService mService;
boolean mReady = false;
public AThread() {
super("ActivityManager");
}
public void run() {
/** 创建消息Loopr循环 **/
Looper.prepare();
android.os.Process.setThreadPriority(
android.os.Process.THREAD_PRIORITY_FOREGROUND);
android.os.Process.setCanSelfBackground(false);
/** 在这里创建AMS实例，用以作为系统中的Activity管理服务 **/
ActivityManagerService m = new ActivityManagerService();
synchronized (this) {
mService = m;
notifyAll();
}
synchronized (this) {
while (!mReady) {
try {
wait();
} catch (InterruptedException e) {
}
}
}
Looper.loop();
}
}
}
可以看到进入ActivityManagerService.main函数之后，其会首先创建一个AThread线程，来创建AMS实例，用来作为系统中的Activity管理服务Service（注意这里并没有将其注册到SM中，需要等到PackageManagerService启动后，才进行注册）。
2、PMS(PackManagerService):Package管理服务: 调用：pm = PackageManagerService.main(context, installer,
factoryTest != SystemServer.FACTORY_TEST_OFF, onlyCore);
也是通过调用PackageManagerService的main静态方法来实现的：/** @path \frameworks\base\services\java\com\android\server\am\ActivityManagerService.java **/
public class PackageManagerService extends IPackageManager.Stub {
public static final IPackageManager main(Context context, Installer installer,
boolean factoryTest, boolean onlyCore) {
// 创建PMS实例，并将其注册到SM中，且服务名称为package
PackageManagerService m = new PackageManagerService(context, installer, factoryTest, onlyCore);
ServiceManager.addService("package", m);
return m;
}
}
3、ContentService(Content管理服务)：
调用：ContentService.main(context, factoryTest == SystemServer.FACTORY_TEST_LOW_LEVEL);
/** @path \frameworks\base\core\java\android\content\ContentService.java **/
public final class ContentService extends IContentService.Stub {
public static ContentService main(Context context, boolean factoryTest) {
ContentService service = new ContentService(context, factoryTest);
ServiceManager.addService(ContentResolver.CONTENT_SERVICE_NAME, service);
return service;
}
}
4、WindowManagerService（Window管理服务）
调用：
WindowManagerService.main(context, power, display, inputManager,
uiHandler, wmHandler,
factoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL,
!firstBoot, onlyCore);
通过main函数进入：/** @path: \frameworks\base\services\java\com\android\server\wm\WindowManagerService.java **/当这些系统关键服务Service建立起来，并且注册到ServiceManager后，其他进行就可以通过SM来获取这些服务的代理对象（这与Binder通信机制相关），然后通过这些代理对象来使用系统提供的基础服务了。
public class WindowManagerService extends IWindowManager.Stub
implements Watchdog.Monitor, WindowManagerPolicy.WindowManagerFuncs,
DisplayManagerService.WindowManagerFuncs, DisplayManager.DisplayListener {
public static WindowManagerService main(final Context context,
final PowerManagerService pm, final DisplayManagerService dm,
final InputManagerService im,
final Handler uiHandler, final Handler wmHandler,
final boolean haveInputMethods, final boolean showBootMsgs,
final boolean onlyCore) {
final WindowManagerService[] holder = new WindowManagerService[1];
wmHandler.runWithScissors(new Runnable() {
@Override
public void run() {
holder[0] = new WindowManagerService(context, pm, dm, im,
uiHandler, haveInputMethods, showBootMsgs, onlyCore);
}
}, 0);
return holder[0];
}
}