add some files

5 years ago · 42e3500b4f
parent 16cec8ca89
commit 42e3500b4f
5 changed files with 464 additions and 0 deletions
--- a/blogs/Android/Framework/Android
+++ b/blogs/Android/Framework/Android
@ -0,0 +1,163 @@
+---
+Android 系统的启动流程
+---
+
+#### Android 有哪些主要的系统进程？
+
+在 init.rc 启动配置文件中定义了很多 Service，这些 Service 就是要单独启动的系统服务进程。
+
+```ini
+service zygote /system/bin/app_process ...
+service servicemanager /system/bin/servicemanager ...
+service surfaceflinger /system/bin/surfaceflinger ...
+service media /system/bin/mediaserver ...
+...
+```
+
+#### 这些系统进程是怎么启动的？以及做了什么事？
+
+Zygote 启动：
+
+1. init 进程 fork 出 zygote 进程
+2. 启动虚拟机，注册 jni 函数，为进入 Java 世界做准备
+3. 预加载系统资源
+4. 启动 SystemServer
+5. 进入 Socket Loop
+
+Zygote 工作流程就是执行 runOnce 函数的过程。
+
+SystemServer 启动：
+
+```java
+private static boolean startSystemServer(...) {
+		String args[] = {
+      	...
+        "com.android.server.SystemServer",
+    }
+  	int pid = Zygote.forkSystemServer(...);
+  	if(pid == 0){
+      	handlerSystemServerProcess(parsedArgs);
+    }
+  	return true;
+}
+```
+
+```java
+void handlerSystemServerProcess(Arguments parsedArgs) {
+		RuntimeInit.zygoteInit(parsedArgs.targetSdkVersion, ...);
+}
+```
+
+```java
+void zygoteInit(String[] argv, ...) {
+		commonInit();
+		nativeZygoteInit();
+		applicationInit(argv, ...);
+}
+```
+
+```java
+// 启动 Binder 机制
+void nativeZygoteInit() {
+		sp<ProcessState> proc = ProcessState::self();
+  	proc->startThreadPool();
+}
+```
+
+```java
+// 执行 SystemServer 的 main 函数
+void applicationInit() {
+		invokeStaticMain(args, ...);
+}
+```
+
+```java
+public static void main() {
+		new SystemServer().run();
+}
+```
+
+```java
+// SystemServer#run
+
+```
+
+```java
+private void run() {
+		Looper.prepareMainLooper();
+		
+		System.loadLibrary("android_servers");
+		createSystemContext();
+		
+		startBootstrapServcies();
+		startCoreServices();
+		startOtherServices();
+		
+		Looper.loop();
+}
+```
+
+
+
+#### 两个问题：
+
+1. 系统服务是怎么启动的？
+2. 怎么解决系统服务之间的相互依赖？
+
+第一个问题，系统服务是怎么启动的？
+
+我们只需要关注两个问题：
+
+1. 系统服务怎么发布，让应用程序可见？
+
+   ```java
+   void publishBinderService(String name, IBiner service, ...) {
+   		ServiceManager.addService(name, service, allowlsolated);
+   }
+   ```
+
+   也就是把系统服务的 Binder 注册到 ServiceManager 中。
+
+2. 系统服务跑在什么线程？
+
+3. 
+
+课堂作业：
+
+1. 为什么系统服务不都跑在 binder 线程里呢？
+2. 为什么系统服务不都跑在自己私有的工作线程里呢？
+3. 跑在 binder 线程和跑在工作线程，如何取舍？
+
+第二个问题，怎么解决系统服务之间的相互依赖？
+
+1. 分批启动（AMS、PMS、PKMS）
+2. 分阶段启动（阶段1、阶段2...）
+
+#### 桌面启动
+
+在 AMS 服务就绪的时候，会调用以下函数：
+
+```java
+public void systemReady(final Runnable goingCallback) {
+		//...
+  	startHomeActivityLocked(mCurrentUserId, "systemReady");
+}
+```
+
+在 Launcher2 Activity 的 onCreate 里面会启动一个 LoaderTask：
+
+```java
+mLoaderTask = new LoaderTask(mApp.getContext(), loadFlags);
+```
+
+这个 LoaderTask 会向 PMS 去查询已经安装的应用：
+
+```
+mPm.queryIntentActivitiesAsUser
+```
+
+#### 说说 Android 系统的启动流程？
+
+1. Zygote 是怎么启动的？
+2. systemServer 是怎么启动的？
+3. 系统服务是怎么启动的？
--- a/blogs/Android/Framework/Choreographer.md
+++ b/blogs/Android/Framework/Choreographer.md
@ -0,0 +1,23 @@
+---
+Choreographer
+---
+
+#### 概述
+
+Choreographer 是用来控制同步处理输入（Input）、动画（Animation）、绘制（Draw）三个操作（UI 显示的时候每一帧要完成的事情只有这三种）。其内部维护着一个 Queue，使用者可以通过 postXxx 来把一系列待运行的 UI 操作放到 Queue 中。这些事件会在 Choreographer 接收 VSYNC 信号后执行这些操作，比如 ViewRootImpl 对于 ViewTree 的更新事件：
+
+```java
+// ViewRootImpl
+void scheduleTraversals() {
+     ...
+     mChoreographer.postCallback(Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
+}
+```
+
+#### 对 Vsync 信号的监听
+
+
+
+#### 参考
+
+[Choreographer工作逻辑总结](https://github.com/SusionSuc/AdvancedAndroid/blob/master/Rabbit%E5%AE%9E%E7%8E%B0%E5%8E%9F%E7%90%86%E5%89%96%E6%9E%90/Choreographer%E5%B7%A5%E4%BD%9C%E9%80%BB%E8%BE%91%E6%80%BB%E7%BB%93.md)
--- a/blogs/Android/Framework/Zygote
+++ b/blogs/Android/Framework/Zygote
@ -0,0 +1,139 @@
+---
+谈谈你对 Zygote 的理解？
+---
+
+#### 了解 Zygote 的作用
+
+1. 启动 SystemServer
+2. 孵化应用进程
+
+#### 熟悉 Zygote 的启动流程
+
+启动三段式：
+
+进程启动 -> 准备工作 -> LOOP
+
+Zygote 的启动可以分为两块：
+
+1. 进程是怎么启动的？
+2. 进程启动之后做了什么？
+
+第一个问题：进程是怎么启动的？
+
+Init 进程是 Linux 启动之后，用户空间的第一个进程。加载了一个 init.rc 配置文件，里面配置了很多系统服务。通过 fork+execev 系统调用。
+
+```ini
+// Service Name: zygote, 可执行路径 + 参数
+service zygote /system/bin/app_process -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
+writepid /dev/cpuset/foreground/tasks
+```
+
+启动进程有两种方式：
+
+第一种是 fork + handle：
+
+```c
+pid_t pid = fork();
+if(pid == 0){
+		// child process
+} else {
+		// parent process
+}
+```
+
+第二种是 fork + execve：
+
+```c
+pid_t pid = fork();
+if(pid == 0){
+		// child process
+		execve(path, argv, env);
+} else {
+		// parent process
+}
+```
+
+调用 fork 函数创建子进程，它会返回两次，子进程返回的 pid == 0，父进程返回的 pid 等于子进程的 pid。
+
+默认情况下，子进程继承了父进程创建的所有资源，如果调用了系统调用 execve 去加载另一个二进程程序的话，那么继承父进程的资源就会被清掉。
+
+信号处理，SIGCHLD 信号：
+
+父进程 fork 出了子进程，如果子进程挂了，那么它的父进程就会收到 SIGCHLD 信号，然后就可以重启。
+
+第二个问题：Zygote 进程启动之后做了什么？
+
+* Zygote 的 Native 世界
+* Zygote 的 Java 世界
+
+Native 世界其实就是为了进入 Java 世界做准备，有以下三件事：
+
+1. 启动虚拟机
+2. 注册 Android 的 JNI 函数
+3. 进入 Java 世界
+
+```c
+int main(int argc, char *argv[]) {
+		JavaVM *jvm;
+  	JNIEnv *env;
+  	// 1
+  	JNI_CreateJavaVM(&jvm, (void**)&env, &vm_args);
+  	// 2
+  	jclass clazz = env->FindClass("ZygoteInit");
+  	jmethodID method = env->GetStaticMethodID(clazz, "Main", "(Ljava/lang/String;)V");
+  	env->CallStaticVoidMethod(clazz, method, args);
+  	jvm->DestoryJavaVM();
+}
+```
+
+Java 虚拟机在 Zygote 都已经创建好了，应用程序都是由 Zygote 创建而来的，就直接继承了它的虚拟机。
+
+再来看一下 Zygote 的世界，做了以下事情：
+
+1. 通过 registerServerSockert 方法来创建一个 Server 端的 Socket，这个 name 为 zygote 的 socket 用于等待 AMS 请求 Zygote 来创建新的应用程序进程
+2. 预加载资源，Preload Resources，在 Zygote 进程预加载系统资源后，然后通过它孵化出其他的虚拟机进程，进而共享虚拟机内存和框架层资源，这样大幅度提高应用程序的启动和运行速度
+3. 启动 System Server
+4. 进入 Loop 循环，执行 runSelectLoop 方法等待消息去创建应用进程
+
+Zygote 处理请求的关键代码：
+
+```java
+boolean runOnce() {
+  	// 1. 读取参数列表
+		String[] args = readArgumentList();
+  	// 2. 启动子进程
+		int pid = Zygote.forkAndSpecialize();
+		if(pid == 0){
+      // 3. 在进程里面干活，其实就是执行了一个 java 类的 main 函数，java 类名就是上面读取的参数列表，参数列表是 AMS 跨进程发过来的，类名其实就是 ActivityThread
+			// in child
+			handleChildProc(args, ...);
+			return true;
+		}
+}
+```
+
+注意细节：
+
+1. Zygote 在 fork 的时候要保证是单线程的，为了避免造成死锁和状态不一致等问题
+2. Zygote 的 IPC 没有采用 Binder，而是本地 Socket
+
+问题：
+
+1. 孵化应用进程这种事为什么不交给 SystemServer 来做，而专门设计一个 Zygote ？
+
+> 我们知道，应用在启动的时候需要做很多准备工作，包括启动虚拟机，加载各类资源系统等等，这些都是非常耗时的，如果能在 zygote 里就给这些必要的初始化工作做好，子进程在 fork 的时候就能直接共享，那么这样的话效率就会非常高。这个就是 zygote 存在的价值，这一点 SystemServer 是替代不了的，主要是因为 SystemServer 里跑了一堆系统服务，这些是不能继承到应用程序的。而且我们应用程序在启动的时候，内存空间除了必要的资源外，最好是干干净净的，不要继承一些乱七八糟的东西，所以呢，不如给 SystemServer 和应用进程里都要用到的资源抽出来单独放到一个进程里，也就是这个 zygote 进程，然后 zygote 进程在分别孵化出 SystemServer 进程和应用进程。孵化出来之后，SystemServer 进程和应用程序进程就可以各干各事了。
+
+1. Zygote 的 IPC 通信机制为什么不采用 Binder？如果采用 Binder 的话会有什么问题呢？
+
+> https://www.zhihu.com/question/312480380
+>
+> https://blog.csdn.net/qq_39037047/article/details/88066589
+
+#### 深刻理解 Zygote 的工作原理
+
--- a/内核设计思想/SurfaceFlinger.md
+++ b/内核设计思想/SurfaceFlinger.md
@ -0,0 +1,12 @@
+---
+SurfaceFlinger
+---
+
+#### 概述
+
+SurfaceFlinger 是负责绘制应用 UI 的核心，从名字上可以看出其功能是将所有的 Surface 合成工作。不论使用什么渲染 API，所有的东西最终都是渲染到 Surface 上，Surface 代表 BufferQueue 的生产者端，并且由 SurfaceFlinger 消费。Android 平台所创建的 Window 都由 Surface 所支持，所有可见的 Surface 渲染到显示设备都是通过 SurfaceFlinger来完成的。
+
+SurfaceFlinger 进程是由 init 进程创建的，运行在独立的 SurfaceFlinger 进程。Android 应用程序必须跟 SurfaceFlinger 进程交互，才能完成将应用 UI 绘制到 FrameBuffer（帧缓冲区）。这个交互便涉及到进程间的通信，采用 Binder IPC 方式，名为 "SurfaceFlinger" 的 Binder 服务端运行在 SurfaceFlinger 进程。
+
+
+
--- a/blogs/Android/Framework/添加系统服务.md
+++ b/blogs/Android/Framework/添加系统服务.md
@ -0,0 +1,127 @@
+---
+怎么添加一个系统服务？
+---
+
+1. 了解如何使用系统服务？
+2. 了解系统服务调用的基本原理
+3. 了解服务的注册原理
+
+#### 如何使用系统服务以及基本原理
+
+```java
+// ContextImpl
+public Object getSystemServer(String name) {
+		return SystemServiceRegistry.getSystemService(this, name);
+}
+
+// SystemServiceRegistry
+
+SYSTEM_SERVICE_FETCHERS = new ArrayMap<String, ServiceFetcher<?>>();
+public static Object getSystemService(ContextImpl ctx, String name) {
+  	ServiceFetcher<?> fetcher = SYSTEM_SERVICE_FETCHERS.get(name);
+  	return fetcher != null ? fetcher.getService(ctx) : null;
+}
+
+// 具体实现
+    public final T getService(ContextImpl ctx) {
+        final Object[] cache = ctx.mServiceCache;
+        T service = (T) cache[mCacheIndex];
+        if (service != null) {
+            return service;
+        } else {
+            service = createService(ctx);
+            cache[mCacheIndex] = service;
+        }
+    }
+```
+
+然后看一下 createService 是如何实现的，这里以 Power Service 为例：
+
+```java
+registerService(Context.POWER_SERVICE, PowerManager.class, new CachedServiceFetcher<PowerManager>()) {
+	@Override
+	public PowerManager createService(ContextImpl ctx) {
+		IBinder b = ServiceManager.getService(Context.POWER_SERVICE);
+		IPowerManager service = IPowerManager.Stub.asInterface(b);
+		return new PowerManager(ctx.getOuterContext(), service, ctx.mMainThread.getHandler());
+	}
+}
+```
+
+```java
+    // ServiceManager#getService
+    public static IBinder getService(String name) {
+        try {
+            IBinder service = sCache.get(name);
+            if (service != null) {
+                return service;
+            } else {
+                return Binder.allowBlocking(rawGetService(name));
+            }
+        } catch (RemoteException e) {
+            Log.e(TAG, "error in getService", e);
+        }
+        return null;
+    }
+```
+
+#### 服务的注册原理
+
+```java
+public static void addService(String name, IBinder service) {
+	getIServiceManager().addService(name, service, false);
+}
+```
+
+什么时候注册的系统服务？
+
+就是在 SystemServer 启动时注册。它的主要流程是：启用 binder 机制 -> 启动各类系统服务 -> 进去 Loop 循环。
+
+需要注意的是，并不是所有的系统服务都是在 SystemServer 进程里的，有一些服务·是单开一个进程的，比如 ServiceManager、SurfaceFlinger、MediaService 等，但是同样需要注册到 ServiceManager 中。
+
+独立进程的系统服务实现，以 SurfaceFlinger 为例：
+
+```ini
+service surfaceflinger /system/bin/surfaceflinger
+class core
+user system
+group graphics drmrpc
+onrestart restart zygote
+writepid /dev/cpuset/system-background/tasks
+```
+
+```c
+int main(int, char**) {
+	sp<ProcessState> ps(ProcessState::self());
+    // 启动 binder 线程池
+	ps->startThreadPool();
+	
+	sp<SurfaceFlinger> flinger = new SurfaceFlinger();
+	flinger->init();
+	
+    // 注册 SurfaceFlinger 服务
+	sp<IServiceManager> sm(defaultServiceManager());
+	sm->addService(serviceName, flinger, false);
+	
+	flinger->run();
+	return 0;
+}
+```
+
+ProcessState 是一个进程内的单例，它的构造函数里面会启动 binder 机制，包括打开 binder 驱动，映射内存，分配缓冲区等等。
+
+最后看一下defaultServiceManager 函数：
+
+```c
+sp<IServiceManager> defaultServiceManager() {
+	if(gDefaultServiceManager != null) {
+		return gDefaultServiceManager;
+	}
+	while(gDefaultServiceManager == null) {
+		gDefaultServiceManager = getContextObject();
+		if(gDefaultServiceManager==null) sleep(1);
+	}
+}
+```
+
+因为 ServiceManager 和 SurfaceFlinger 都是由 init 进程启动的，所以这里如果是独立线程启动，可能在注册服务时，ServiceManager 还未来得及向 binder 驱动注册，所以如果拿不到 ServiceManager 就睡眠不停循环获取。