写在四大组件之前------androidframework框架分析简略分析和系统启动流程

Zygote和SystemServer

Android系统是基于Linux内核的，而在Linux系统中，所有的进程都是init进程的子孙进程，

也就是说，所有的进程都是直接或者间接地由init进程fork出来的。Zygote进程也不例外，它是在系统启动的过程，由init进程创建的。在系统启动脚本system/core/rootdir/init.rc文件中，我们可以看到启动Zygote进程的脚本命令：

service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server
    socket zygote stream 666
    onrestart write /sys/android_power/request_state wake
    onrestart write /sys/power/state on
    onrestart restart media
    onrestart restart netd

Zygote是安卓运行的第一个Dalvik虚拟机进程，负责孵化其他的安卓进程。zygote翻译成中文是受精卵的意思，大概意思就是源头，孵化其他的进程。

SystemServer是由zygote进程fork出来framework 核心的进程。系统里面重要的服务都是在这个进程里面开启的，比如ActivityManagerService（AMS）、PackageManagerService、WindowManagerService等等

zygote开启的时候，会调用ZygoteInit.main()进行初始化,

 ..
public static void main(String argv[]) {
 ........
//在加载首个zygote的时候，会传入初始化参数，使得startSystemServer = true
 boolean startSystemServer = false;
 for (int i = 1; i < argv.length; i++) {
            if ("start-system-server".equals(argv[i])) {
                startSystemServer = true;
            } else if (argv[i].startsWith(ABI_LIST_ARG)) {
                abiList = argv[i].substring(ABI_LIST_ARG.length());
            } else if (argv[i].startsWith(SOCKET_NAME_ARG)) {
                socketName = argv[i].substring(SOCKET_NAME_ARG.length());
            } else {
                throw new RuntimeException("Unknown command line argument: " + argv[i]);
            }
        }
        
        ...ignore some code...
        
     //开始fork我们的SystemServer进程
 if (startSystemServer) {
            startSystemServer(abiList, socketName);
     }

 ...ignore some code...

}

再来看下startSystemServer()的源码看看做了些什么

 * Prepare the arguments and fork for the system server process.
 */
private static boolean startSystemServer(String abiList, String socketName)
        throws MethodAndArgsCaller, RuntimeException {
     .....     
    //留着这段注释，就是为了说明上面ZygoteInit.main(String argv[])里面的argv就是通过这种方式传递进来的
    /* Hardcoded command line to start the system server */
    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",
    };

    int pid;
    try {
        parsedArgs = new ZygoteConnection.Arguments(args);
        ZygoteConnection.applyDebuggerSystemProperty(parsedArgs);
        ZygoteConnection.applyInvokeWithSystemProperty(parsedArgs);

    //fork 出SystemServer
         /* Request to fork the system server process */
        pid = Zygote.forkSystemServer( parsedArgs.uid, parsedArgs.gid,
                parsedArgs.gids,parsedArgs.debugFlags,  null, parsedArgs.permittedCapabilities,parsedArgs.effectiveCapabilities);
    } catch (IllegalArgumentException ex) {
        throw new RuntimeException(ex);
    }

    if (pid == 0) {
        if (hasSecondZygote(abiList)) {
            waitForSecondaryZygote(socketName);
        }
        handleSystemServerProcess(parsedArgs);
    }
    return true;
}

ActivityManagerService

简称AMS，系统服务对象，负责系统中所有Activity的生命周期。
ActivityManagerService进行初始化的时机很明确，就是在SystemServer进程开启的时候，就会初始化ActivityManagerService。从下面的代码中可以看到。

public final class SystemServer {

//zygote的主入口
public static void main(String[] args) {
    new SystemServer().run();
}

public SystemServer() {
    // Check for factory test mode.
    mFactoryTestMode = FactoryTest.getMode();
}

private void run() {
    
    ...ignore some code...
    
    //加载本地系统服务库，并进行初始化 
    System.loadLibrary("android_servers");
    nativeInit();
    
    // 创建系统上下文
    createSystemContext();
    
    //初始化SystemServiceManager对象，下面的系统服务开启都需要调用SystemServiceManager.startService(Class<T>)，这个方法通过反射来启动对应的服务
    mSystemServiceManager = new SystemServiceManager(mSystemContext);
    
    //开启服务
    try {
        startBootstrapServices();
        startCoreServices();
        startOtherServices();
    } catch (Throwable ex) {
        Slog.e("System", "******************************************");
        Slog.e("System", "************ Failure starting system services", ex);
        throw ex;
    }
   
    ...ignore some code...

}

//初始化系统上下文对象mSystemContext，并设置默认的主题,mSystemContext实际上是一个ContextImpl对象。
调用ActivityThread.systemMain()的时候，会调用ActivityThread.attach(true)，而在attach()里面，则创建了Application对象，并调用了Application.onCreate()。

private void createSystemContext() {
    ActivityThread activityThread = ActivityThread.systemMain();
    mSystemContext = activityThread.getSystemContext();
    mSystemContext.setTheme(android.R.style.Theme_DeviceDefault_Light_DarkActionBar);
}

//在这里开启了几个核心的服务，因为这些服务之间相互依赖，所以都放在了这个方法里面。
private void startBootstrapServices() {
    
    ...ignore some code...
    
    //初始化ActivityManagerService
    mActivityManagerService = mSystemServiceManager.startService(
            ActivityManagerService.Lifecycle.class).getService();
    mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
    
    //初始化PowerManagerService，因为其他服务需要依赖这个Service，因此需要尽快的初始化
    mPowerManagerService = mSystemServiceManager.startService(PowerManagerService.class);

    // 现在电源管理已经开启，ActivityManagerService负责电源管理功能
    mActivityManagerService.initPowerManagement();

    // 初始化DisplayManagerService
    mDisplayManagerService = mSystemServiceManager.startService(DisplayManagerService.class);

//初始化PackageManagerService
mPackageManagerService = PackageManagerService.main(mSystemContext, mInstaller,
   mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF, mOnlyCore);

...ignore some code...

}}

这段代码发生了太多事情，开启了n个服务，ActivityThread的创建和main（）方法也在此调用。

我们的ActivityManagerService对象已经创建好了，并且完成了成员变量初始化。而且在这之前，调用createSystemContext()创建系统上下文的时候，也已经完成了mSystemContext和ActivityThread的创建。注意，这是系统进程开启时的流程，在这之后，会开启系统的Launcher程序，完成系统界面的加载与显示.

所有App共用一些系统服务，比如我们这里提到的ActivityManagerService，和前面提到的PackageManagerService、WindowManagerService等等，这些基础的系统服务是被所有的App公用的，当某个App想实现某个操作的时候，要告诉这些系统服务，比如你想打开一个App，那么我们知道了包名和MainActivity类名之后就可以打开。

Intent intent = new Intent(Intent.ACTION_MAIN);
intent.addCategory(Intent.CATEGORY_LAUNCHER);
ComponentName cn = new ComponentName(packageName, className);
intent.setComponent(cn);
startActivity(intent);

AMS来通知zygote进程来fork一个新进程，来开启我们的目标App的。

App与AMS通过Binder进行IPC通信，AMS(SystemServer进程)与zygote通过Socket进行IPC通信。

那么AMS有什么用呢？在前面我们知道了，如果想打开一个App的话，需要AMS去通知zygote进程，除此之外，其实所有的Activity的开启、暂停、关闭都需要AMS来控制，所

以我们说，AMS负责系统中所有Activity的生命周期。
在Android系统中，任何一个Activity的启动都是由AMS和应用程序进程（主要是ActivityThread）相互配合来完成的。AMS服务统一调度系统中所有进程的Activity启动，而每个Activity的启动过程则由其所属的进程具体来完成。

Launcher

本质上也是一个应用程序，和我们的App一样，也是继承自Activity.

launcher.xml

<com.android.launcher2.DragLayer
    android:id="@+id/drag_layer"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:fitsSystemWindows="true">

    <!-- Keep these behind the workspace so that they are not visible when
         we go into AllApps -->
    <include
        android:id="@+id/dock_divider"
        layout="@layout/workspace_divider"
        android:layout_marginBottom="@dimen/button_bar_height"
        android:layout_gravity="bottom" />

    <include
        android:id="@+id/paged_view_indicator"
        layout="@layout/scroll_indicator"
        android:layout_gravity="bottom"
        android:layout_marginBottom="@dimen/button_bar_height" />

    <!-- The workspace contains 5 screens of cells -->
    <com.android.launcher2.Workspace
        android:id="@+id/workspace"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:paddingStart="@dimen/workspace_left_padding"
        android:paddingEnd="@dimen/workspace_right_padding"
        android:paddingTop="@dimen/workspace_top_padding"
        android:paddingBottom="@dimen/workspace_bottom_padding"
        launcher:defaultScreen="2"
        launcher:cellCountX="@integer/cell_count_x"
        launcher:cellCountY="@integer/cell_count_y"
        launcher:pageSpacing="@dimen/workspace_page_spacing"
        launcher:scrollIndicatorPaddingLeft="@dimen/workspace_divider_padding_left"
        launcher:scrollIndicatorPaddingRight="@dimen/workspace_divider_padding_right">

        <include android:id="@+id/cell1" layout="@layout/workspace_screen" />
        <include android:id="@+id/cell2" layout="@layout/workspace_screen" />
        <include android:id="@+id/cell3" layout="@layout/workspace_screen" />
        <include android:id="@+id/cell4" layout="@layout/workspace_screen" />
        <include android:id="@+id/cell5" layout="@layout/workspace_screen" />
    </com.android.launcher2.Workspace>

...ignore some code...

</com.android.launcher2.DragLayer>

Launcher大量使用标签来实现界面的复用，而且定义了很多的自定义控件实现界面效果，dock_divider从布局的参数声明上可以猜出，是底部操作栏和上面图标

布局的分割线，而paged_view_indicator则是页面指示器，和App首次进入的引导页下面的界面引导是一样的道理。当然，我们最关心的是Workspace这个布局，因为注释里

面说在这里面包含了5个屏幕的单元格，想必你也猜到了，这个就是在首页存放我们图标的那五个界面(不同的ROM会做不同的DIY，数量不固定)。

不管我们从哪儿点图片，最后都会调用。

mLauncher.startActivitySafely(v, appInfo.intent, appInfo);而startActivitySafely内部是调用了startActivity(v, intent, tag)

再深入看源码发现，startActivity()调用的其实是startActivityForResult()这个方法。

所以，Launcher中开启一个App，其实和我们在Activity中直接startActivity()基本一样，都是调用了Activity.startActivityForResult()

@Override
public void startActivity(Intent intent, @Nullable Bundle options) {
    if (options != null) {
        startActivityForResult(intent, -1, options);
    } else {
        // Note we want to go through this call for compatibility with
        // applications that may have overridden the method.
        startActivityForResult(intent, -1);
    }
}

Instrumentation

每个Activity都持有Instrumentation对象的一个引用，但是整个进程只会存在一个Instrumentation对象。当startActivityForResult()调用之后，实际上还是调用了mInstrumentation.execStartActivity()

这个类里面的方法大多数和Application和Activity有关，是的，这个类就是完成对Application和Activity初始化和生命周期的工具类

App和AMS是通过Binder传递信息的，那么ActivityThread就是专门与AMS的外交工作的，Instrumentation在ActivityThread大量调用实现这些交互。

Binder通信是单方向的，当从ActivityManagerProxy指向ActivityManagerService

客户端：ActivityManagerProxy =>Binder驱动=> ActivityManagerService：系统服务

AMS想要通知ActivityThread做一些事情

客户端：ApplicationThread <=Binder驱动<= ApplicationThreadProxy：系统服务

在应用中通过intent启动Activity的过程
首先调用startActivity，最后都会转到startActivityForResult。然后调用Instrumentation.execStartActivity，在

execStartActivity里会调用ActivityManagerNative.getDefault().startActivity。ActivityManagerNative.getDefault()就是ActivityManagerProxy，这个是AMS在客户

端进程使用的代理类，在ActivityManagerNative.getDefault()中会通过ServiceManager.getService(“activity”)获取ActivityManagerService 提供的 Binder 接口，并

将这个binder传入ActivityManagerProxy。这样ActivityManagerProxy调用starActivity，里面就会调用了AMS的相应函数。这样就完成了从Activity到AMS的一次调用。

一个App的程序真正入口是ActivityThread.main()。
而ActivityThread.main()中，Application和oncreate创建和调用。

        ...
 private void attach(boolean system) {
    sCurrentActivityThread = this;
    mSystemThread = system;
    //普通App进这里
    if (!system) {
      ignore some code...    
    
        RuntimeInit.setApplicationObject(mAppThread.asBinder());
        final IActivityManager mgr = ActivityManagerNative.getDefault();
        try {
            mgr.attachApplication(mAppThread);
        } catch (RemoteException ex) {
            // Ignore
        }
       } else {
         //这个分支在SystemServer加载的时候会进入，通过调用
         // private void createSystemContext() {
         //    ActivityThread activityThread = ActivityThread.systemMain()；
         //} 
         
         // public static ActivityThread systemMain() {
    //        if (!ActivityManager.isHighEndGfx()) {
    //            HardwareRenderer.disable(true);
    //        } else {
    //            HardwareRenderer.enableForegroundTrimming();
    //        }
    //        ActivityThread thread = new ActivityThread();
    //        thread.attach(true);
    //        return thread;
    //    }       
       }
}

ActivityThread

整个Android应用进程的体系非常复杂，而ActivityThread是真正的核心类，它的main方法，是整个应用进程的真正入口。

ActivityThread类的对象的关联图

从图中可以知道，mActivities、mServices和mProviderMap 这三个变量都被保存在ArrayMap之中，他们分别保存了应用中所有的

Activity对象、Services对象、和ContentProvider对象。
同为四大组件的BroadcastReceive去哪里了？注意，BroadcastReceiver对象没有必要用任何数据结构来保存，因为BroadcastReceiver对象的生命周期很短暂，属于我调用它时，再创建运行，因此不需要保存BroadcastReceiver的对象。

我们都知道应用中Applicaiton对象是唯一的，而mInitialApplication变量是恰恰是Application对象。当你的应用自定义一个派生Applicaiton类，则它就是mInitialApplication了。
ApplicationThread类型变量mAppThread是一个Binder实体对象，ActivityManagerService作为Client端调用ApplicationThread的接口，目的是用来调度管理Activity，这个我们未来会细说。

变量mResourcesManager管理着应用中的资源。

ActivityThread相当于一个CEO，管理调度着几乎所有的Android应用进程的资源和四大组件

ActivityThread的main方法

main方法的代码：

public static void More …main(String[] args) {
SamplingProfilerIntegration.start();

    // CloseGuard defaults to true and can be quite spammy.  We
    // disable it here, but selectively enable it later (via
    // StrictMode) on debug builds, but using DropBox, not logs.
    CloseGuard.setEnabled(false);
    // 初始化应用中需要使用的系统路径
     Environment.initForCurrentUser();

    // Set the reporter for event logging in libcore
    EventLogger.setReporter(new EventLoggingReporter());
//增加一个保存key的provider
Security.addProvider(new AndroidKeyStoreProvider());

// Make sure TrustedCertificateStore looks in the right place for CA certificates
        //为应用设置当前用户的CA证书保存的位置
final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());
TrustedCertificateStore.setDefaultUserDirectory(configDir);
//设置进程的名称
Process.setArgV0("<pre-initialized>");

Looper.prepareMainLooper();
//创建ActivityThread 对象
ActivityThread thread = new ActivityThread();
thread.attach(false);

if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}

  if (false) {
Looper.myLooper().setMessageLogging(new
LogPrinter(Log.DEBUG, "ActivityThread"));
}

Looper.loop();

throw new RuntimeException("Main thread loop unexpectedly exited");
  }



   if (!system) {
ViewRootImpl.addFirstDrawHandler(new Runnable() {
@Override
public void More ...run() {
ensureJitEnabled();
}
});
android.ddm.DdmHandleAppName.setAppName("<pre-initialized>",
UserHandle.myUserId());

//将mAppThread放到RuntimeInit类中的静态变量
RuntimeInit.setApplicationObject(mAppThread.asBinder());
            final IActivityManager mgr = ActivityManagerNative.getDefault();
	try {
                //将mAppThread传入ActivityThreadManager中
	mgr.attachApplication(mAppThread);
	} catch (RemoteException ex) {
     // Ignore
	}
	// Watch for getting close to heap limit.
	BinderInternal.addGcWatcher(new Runnable() {
	@Override public void More ...run() {
	if (!mSomeActivitiesChanged) {
	return;
		}
		Runtime runtime = Runtime.getRuntime();
		long dalvikMax = runtime.maxMemory();
		long dalvikUsed = runtime.totalMemory() - runtime.freeMemory();
		if (dalvikUsed > ((3*dalvikMax)/4)) {
		if (DEBUG_MEMORY_TRIM) Slog.d(TAG, "Dalvik max=" + (dalvikMax/1024)
		+ " total=" + (runtime.totalMemory()/1024)
			+ " used=" + (dalvikUsed/1024));
		mSomeActivitiesChanged = false;
		try {
	mgr.releaseSomeActivities(mAppThread);
	} catch (RemoteException e) {
	}
		}
	}
	});
	}

当传入的参数为false时，就走到了如上面贴出的代码中：
此时主要完成两件事
1.调用 RuntimeInit.setApplicationObject() 方法，把对象mAppThread（Binder）放到了RuntimeInit类中的静态变量mApplicationObject中。

mAppThread的类型是ApplicationThread，它是ActivityThread的成员变量，定义和初始化如下：

final ApplicationThread mAppThread = new ApplicationThread();

第二件事比较关键了，就是调用ActivityManagerService的attachApplication()方法，将mAppThread 作为参数传入ActivityManagerService，这样ActivityManagerService就可以调用ApplicaitonThread的接口了。这与我们刚才说的，ActivityManagerService作为Client端调用ApplicaitonThread的接口管理Activity，就不谋而合了。

总结

PackageManagerService负责安装系统的应用程序：

1、 Android系统在启动的过程中，Zygote进程启动SystemServer组件，SystemServer组件启动PackageManagerService服务、ActivityManagerService服务等。

2、PackageManagerService服务启动过程：创建了一个PackageManagerService服务实例，把这个服务添加到ServiceManager中去（ServiceManager是Android系统Binder进程间通信机制的守护进程，负责管理系统中的Binder对象）。

3、PackageManagerService类的构造函数中开始执行安装应用程序的过程：调用scanDirLI函数来扫描移动设备上的五个目录中的Apk文件（ /system/framework、 /system/app、 /vendor/app、/data/app、 /data/app-private），对于目录中的每一个文件，如果是以Apk作为后缀名，那么就调用scanPackageLI函数来对它进行解析和安装首先会为这个Apk文件创建一个PackageParser实例，接着调用这个实例的parsePackage函数来对这个Apk文件进行解析（这个函数最后还会调用另外一个版本的scanPackageLI函数把来解析后得到的应用程序信息保存在PackageManagerService中。见后）：

4、每一个Apk文件都是一个归档文件，它里面包含了Android应用程序的配置文件AndroidManifest.xml，这里主要就是要对这个配置文件解析就行了。从Apk归档文件中得到这个配置文件后，就调用另一外版本的parsePackage函数对这个应用程序进行解析：对AndroidManifest.xml文件中的各个标签进行解析，如application标签的解析，这是通过调用parseApplication函数来进行的。

5、解析完成后，一层层返回，调用另一个版本的scanPackageLI函数，把前面解析应用程序得到的package、provider、service、receiver和activity等信息保存在PackageManagerService服务中（保存在mPackages、mActivities、mReceivers、mServices等成员变量(HashMap类型)中）

Android应用程序进程启动过程

1、Android系统中，所有的应用程序进程以及系统服务进程SystemServer都是由Zygote进程孕育（fork）出来的。
系统中的两个重要服务PackageManagerService和ActivityManagerService，都是由SystemServer进程来负责启动的，而SystemServer进程本身是Zygote进程在启动的过程中fork出来的。

2、当ActivityManagerService启动一个应用程序的时候，就会通过Socket与Zygote进程进行通信，请求它fork一个子进程出来作为这个即将要启动的应用程序的进程；
3、ActivityManagerService组件一般会在什么情况下会为应用程序创建一个新的进程呢？：当系统决定要在一个新的进程中启动一个Activity或者Service时，它就会创建一个新的进程了，然后在这个新的进程中启动这个Activity或者Service。

4、Android应用程序进程启动过程：指定新的进程的入口函数是ActivityThread的main函数；为进程内的Binder对象提供了Binder进程间通信机制的基础设施（定义了Binder线程池：我们在开发Android应用程序的时候，当我们要和其它进程中进行通信时，只要定义自己的Binder对象，然后把这个Binder对象的远程接口通过其它途径传给其它进程后，其它进程就可以通过这个Binder对象的远程接口来调用我们的应用程序进程的函数了）