Android系统的启动流程简要分析

这是我结合网上的资料以及自己分析android4.4的源码整理的笔记,对整个安卓系统的流程启动进行了梳理,很多细节并未展开,只是简要的进行了介绍.

一.Android系统的架构介绍

Android的整个系统分为四层,从上至下为应用层、框架层、系统库、Linux内核层.

1.应用层

各种系统应用,比如电话、浏览器、日历等.

2.框架层

也就是Framework层,提供各种服务,比如下图的一些.

3.系统库

3.1. 提供核心类库,比如OpenGl,SQlite

3.2.提供Davlik虚拟机和Java核心类库

如下图举例

4.Linux内核层

提供各种驱动和硬件抽象层.

二.Android系统的启动流程

先放张启动流程图,跟着流程走

Linux内核启动后会启动init进程,init是所有进程的父进程,代码位于根目录下 system\core\init

init进程的作用主要是显示开机动画,通过解析init.rc脚本然后启动一系列服务和进程.

这里的服务包括媒体服务MediaServer和服务管理者ServiceManager,ServiceManager是服务的管家,添加、注册和获取服务都通过它.

这里的进程包括安装app、内存管理、Zygote等进程等.

最核心的的是Zygote进程，它是Android系统的第一个Java进程. ，它是由init进程执行app_process程序启动的,app_process 程序代码位于frameworks/base/cmds/app_process

在app_main.cpp里启动ZygoteInit和Davlik虚拟机

[java]  view plain  copy

1. if (zygote) {  
2.     //启动ZygoteInit,Davlik虚拟机  
3.     runtime.start("com.android.internal.os.ZygoteInit",  
4.                startSystemServer ? "start-system-server" : "");  
5.    } else if (className) {  
6.          
7.        runtime.mClassName = className;  
8.        runtime.mArgC = argc - i;  
9.        runtime.mArgV = argv + i;  
10.        runtime.start("com.android.internal.os.RuntimeInit",  
11.                application ? "application" : "tool");  
12.    } else {  
13.        fprintf(stderr, "Error: no class name or --zygote supplied.\n");  
14.        app_usage();  
15.        LOG_ALWAYS_FATAL("app_process: no class name or --zygote supplied.");  
16.        return 10;  
17.    }  

看下ZygoteInit这个类,它位于frameworks\base\core\java\com\android\internal\os目录下.

它的代码如下,看它在main方法里究竟做了有一些什么事情.

[java]  view plain  copy

1. public static void main(String argv[]) {  
2.         try {  
3.             // 初始化Zygote  
4.             SamplingProfilerIntegration.start();  
5.             //注册ZygoteSocket服务  
6.             registerZygoteSocket();  
7.               
8.             EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_START,  
9.                 SystemClock.uptimeMillis());  
10.             //预加载Framework大部分的类和资源  
11.             preload();  
12.               
13.             EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_END,  
14.                 SystemClock.uptimeMillis());  
15.   
16.             //完成Zygote的初始化  
17.             SamplingProfilerIntegration.writeZygoteSnapshot();  
18.   
19.             // 在启动之后做一次垃圾回收  
20.             gc();  
21.             
22.             //禁止追踪,以便于派生的进程不继承这个标记  
23.             Trace.setTracingEnabled(false);  
24.        
25.             //  如果有需求,直接从Zygote启动system server               
26.             if (argv.length != 2) {  
27.                 throw new RuntimeException(argv[0] + USAGE_STRING);  
28.             }  
29.               
30.             if (argv[1].equals("start-system-server")) {  
31.                 // fork一个新的进程system_server  
32.                 startSystemServer();  
33.               
34.             } else if (!argv[1].equals("")) {  
35.                 throw new RuntimeException(argv[0] + USAGE_STRING);  
36.             }  
37.   
38.             Log.i(TAG, "Accepting command socket connections");  
39.   
40.             //处理客户端连接请求  
41.             runSelectLoop();  
42.   
43.             //关闭服务Socket  
44.             closeServerSocket();  
45.         } catch (MethodAndArgsCaller caller) {  
46.             caller.run();  
47.         } catch (RuntimeException ex) {  
48.             Log.e(TAG, "Zygote died with exception", ex);  
49.             closeServerSocket();  
50.             throw ex;  
51.         }  
52.     }  

1.初始化Zygote

在这里开启对系统性能的统计

2.注册ZygoteSocket服务

创建了一个Socket接口,用来和AMS(ActivityManagerService)通信

3.预加载Framework大部分的类和资源

它会开启3个线程分别预加载3个东西：类、资源和OpenGl

[java]  view plain  copy

1. static void preload() {  
2.         Thread preloadClasses = new Thread(new Runnable() {  
3.             public void run() {  
4.                 //加载类  
5.                 preloadClasses();  
6.             }  
7.         });  
8.         Thread preloadResources = new Thread(new Runnable() {  
9.             public void run() {  
10.                 //加载资源  
11.                 preloadResources();  
12.             }  
13.         });  
14.         Thread preloadOpenGL = new Thread(new Runnable() {  
15.             public void run() {  
16.                 //加载OpenGL  
17.                 preloadOpenGL();  
18.             }  
19.         });  
20.           
21.         preloadClasses.start();  
22.         preloadResources.start();  
23.         preloadOpenGL.start();  
24.         try {  
25.             preloadClasses.join();  
26.             preloadResources.join();  
27.             preloadOpenGL.join();  
28.         } catch (InterruptedException e) {  
29.             e.printStackTrace();  
30.         }  
31.     }  

4.完成Zygote的初始化

结束统计并生成结果文件

5.在启动之后做一次垃圾回收

6.fork一个新的进程system_server

fork是linux的的方法,会复制出一个与原来进程一样的进程,但是如果初始参数或者传入的变量不同，两个进程也可以做不同的事.

startSystemServer的代码如下

[java]  view plain  copy

1. /** 
2.      * 准备参数和fork 系统服务进程  
3.      */   
4.     private static boolean startSystemServer()  
5.             throws MethodAndArgsCaller, RuntimeException {  
6.         long capabilities = posixCapabilitiesAsBits(  
7.             OsConstants.CAP_KILL,  
8.             OsConstants.CAP_NET_ADMIN,  
9.             OsConstants.CAP_NET_BIND_SERVICE,  
10.             OsConstants.CAP_NET_BROADCAST,  
11.             OsConstants.CAP_NET_RAW,  
12.             OsConstants.CAP_SYS_MODULE,  
13.             OsConstants.CAP_SYS_NICE,  
14.             OsConstants.CAP_SYS_RESOURCE,  
15.             OsConstants.CAP_SYS_TIME,  
16.             OsConstants.CAP_SYS_TTY_CONFIG,  
17.             OsConstants.CAP_BLOCK_SUSPEND  
18.         );  
19.         /* 启动系统服务的核心命令行 */             
20.         String args[] = {  
21.             "--setuid=1000",  
22.             "--setgid=1000",  
23.             "--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1032,3001,3002,3003,3006,3007",  
24.             "--capabilities=" + capabilities + "," + capabilities,  
25.             "--runtime-init",  
26.             "--nice-name=system_server",  
27.             "com.android.server.SystemServer",  
28.         };  
29.         ZygoteConnection.Arguments parsedArgs = null;  
30.   
31.         //进程id  
32.         int pid;  
33.   
34.         try {  
35.             parsedArgs = new ZygoteConnection.Arguments(args);  
36.             ZygoteConnection.applyDebuggerSystemProperty(parsedArgs);  
37.             ZygoteConnection.applyInvokeWithSystemProperty(parsedArgs);  
38.   
39.             /* 请求fork系统服务进程 */  
40.             pid = Zygote.forkSystemServer(  
41.                     parsedArgs.uid, parsedArgs.gid,  
42.                     parsedArgs.gids,  
43.                     parsedArgs.debugFlags,  
44.                     null,  
45.                     parsedArgs.permittedCapabilities,  
46.                     parsedArgs.effectiveCapabilities);  
47.         } catch (IllegalArgumentException ex) {  
48.             throw new RuntimeException(ex);  
49.         }  
50.   
51.         /* 对新fork出的系统进程，执行handleSystemServerProcess() */  
52.         if (pid == 0) {  
53.             handleSystemServerProcess(parsedArgs);  
54.         }  
55.   
56.         return true;  
57.     }  

代码里会fork出SystemServer.之后进入到SystemServer.java这个类中.

代码位于:frameworks/base/services/java/com/android/server/SystemServer.java

SystemServer的main方法会调用

[java]  view plain  copy

1. ServerThread thr = new ServerThread();  
2. thr.initAndLoop();  

开启一个线程ServerThread,在这里面加载各种服务,比如WindowManagerServer（Wms）、ActivityManagerService（Ams）、PackageManagerServer（Pms）等.

7.runSelectLoop

处理客户端的连接请求,等待其他进程的请求.

8.closeServerSocket()

关闭服务Socket.

至此,整个系统服务已经运行起来了,至于怎么安装程序、启动桌面等,以后再写.

版权声明：本文为博主原创文章，转载请注明出处：邓志勇博客 http://blog.youkuaiyun.com/qq_31530015/