该篇是Android启动系列的最后一篇，本文从应用进程的创建启动角度出发，分析ActivityThread是如何创建的。相对于上篇，本文内容较少，阅读无压力~
从接触Android的那一刻开始，看到最多的是：耗时任务不能在主线程执行，UI操作要在主线程执行……当时人傻无知，从来没有想过什么是主线程，为啥不能在主线程做耗时任务等等。
大家都说ActivityThread是主线程，那它是线程吗？它为什么被称为主线程？它做啥了？
回顾
在上文《沉思曲：Activity启动》一文中，分析了Activity的启动过程。并在调用startSpecificActivityLocked方法时，提到这里会判断目的Activity进程是否存在，如果不存在，就会创建新进程，本文就从这个创建新进程的分支开始。
创建应用进程
先回顾下startSpecificActivityLocked方法
该方法在ActivityStackSupervisor.java中
void startSpecificActivityLocked(ActivityRecord r,
boolean andResume, boolean checkConfig) {
//获取待启动Activity的进程信息
ProcessRecord app = mService.getProcessRecordLocked(r.processName,
r.info.applicationInfo.uid, true);
r.task.stack.setLaunchTime(r);
//待启动Activity所在进程存在
if (app != null && app.thread != null) {
try {
app.addPackage(r.info.packageName, mService.mProcessStats);
//接着往下执行
realStartActivityLocked(r, app, andResume, checkConfig);
return;
} catch (RemoteException e) {
Slog.w(TAG, "Exception when starting activity "
+ r.intent.getComponent().flattenToShortString(), e);
}
}
//待启动Activity所在进程不存在，为其创建新进程
mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,
"activity", r.intent.getComponent(), false, false, true);
}
- 上方法中，如果目的Activity所在进程不存在，调用AMS的startProcessLocked方法创建目的应用进程。
1.1、startProcessLocked
startProcessLocked定义在ActivityManagerService.java中，该方法会调用Process的start方法。
// Start the process. It will either succeed and return a result containing
// the PID of the new process, or else throw a RuntimeException.
Process.ProcessStartResult startResult = Process.start("android.app.ActivityThread",
app.processName, uid, uid, gids, debugFlags, mountExternal,
app.info.targetSdkVersion, app.info.seinfo, null);
- 该方法调用Process的start方法，注意传入参数：<u>"android.app.ActivityThread"</u>
1.2、 start | Process.java
/**
* Start a new process.
*
* <p>If processes are enabled, a new process is created and the
* static main() function of a <var>processClass</var> is executed there.
* The process will continue running after this function returns.
*
* <p>If processes are not enabled, a new thread in the caller's
* process is created and main() of <var>processClass</var> called there.
*
* <p>The niceName parameter, if not an empty string, is a custom name to
* give to the process instead of using processClass. This allows you to
* make easily identifyable processes even if you are using the same base
* <var>processClass</var> to start them.
*
* @param processClass The class to use as the process's main entry
* point.
* @param niceName A more readable name to use for the process.
* @param uid The user-id under which the process will run.
* @param gid The group-id under which the process will run.
* @param gids Additional group-ids associated with the process.
* @param debugFlags Additional flags.
* @param targetSdkVersion The target SDK version for the app.
* @param seInfo null-ok SE Android information for the new process.
* @param zygoteArgs Additional arguments to supply to the zygote process.
*
* @return An object that describes the result of the attempt to start the process.
* @throws RuntimeException on fatal start failure
*
* {@hide}
*/
public static final ProcessStartResult start(final String processClass,
final String niceName,
int uid, int gid, int[] gids,
int debugFlags, int mountExternal,
int targetSdkVersion,
String seInfo,
String[] zygoteArgs) {
try {
//通过Zygote启动新进程
return startViaZygote(processClass, niceName, uid, gid, gids,
debugFlags, mountExternal, targetSdkVersion, seInfo, zygoteArgs);
} catch (ZygoteStartFailedEx ex) {
Log.e(LOG_TAG,
"Starting VM process through Zygote failed");
throw new RuntimeException(
"Starting VM process through Zygote failed", ex);
}
}
从注释可知，该方法用来启动一个新进程：
- 如果进程启动，则processClass（此处入参为“android.app.ActivityThread”）会运行在该新进程中，并且在该方法调用完成后，新进程会继续运行。
- 如果进程未启动，则调用该start方法所在的进程会创建一个新的线程，然后processClass运行在该新线程中。
方法调用startViaZygote方法，从方法名看出，进程创建似乎是要交给zygote。
1.3、startViaZygote | Process.java
private static ProcessStartResult startViaZygote(final String processClass,
final String niceName,
final int uid, final int gid,
final int[] gids,
int debugFlags, int mountExternal,
int targetSdkVersion,
String seInfo,
String[] extraArgs)
throws ZygoteStartFailedEx {
synchronized(Process.class) {
//启动新进程的参数
ArrayList<String> argsForZygote = new ArrayList<String>();
//添加各种参数到argsForZygote
argsForZygote.add("--runtime-init");
argsForZygote.add("--setuid=" + uid);
argsForZygote.add("--setgid=" + gid);
...
if (niceName != null) {
argsForZygote.add("--nice-name=" + niceName);
}
if (seInfo != null) {
argsForZygote.add("--seinfo=" + seInfo);
}
argsForZygote.add(processClass);
...
//调用该方法，由zygote创建进程，并获取新进程信息
return zygoteSendArgsAndGetResult(argsForZygote);
}
}
这个方法设置启动新进程所需参数，并往下调用zygoteSendArgsAndGetResult方法。
1.4、zygoteSendArgsAndGetResult | Process.java
private static ProcessStartResult zygoteSendArgsAndGetResult(ArrayList<String> args)
throws ZygoteStartFailedEx {
//进程通信，连接到Zygote的Server Socket，交由Zygote创建
openZygoteSocketIfNeeded();
try {
//sZygoteWriter将参数发送到Server Socket
sZygoteWriter.write(Integer.toString(args.size()));
sZygoteWriter.newLine();
int sz = args.size();
for (int i = 0; i < sz; i++) {
String arg = args.get(i);
if (arg.indexOf('\n') >= 0) {
throw new ZygoteStartFailedEx(
"embedded newlines not allowed");
}
sZygoteWriter.write(arg);
sZygoteWriter.newLine();
}
sZygoteWriter.flush();
//sZygoteInputStream从Server Socket读取结果
ProcessStartResult result = new ProcessStartResult();
result.pid = sZygoteInputStream.readInt();
...
result.usingWrapper = sZygoteInputStream.readBoolean();
return result;
...
}
从方法名可以猜出该方法大致干啥了：发送启动参数给Zygote进程，交由Zygote进程启动，并获得启动结果。看下是否如此：
1、调用openZygoteSocketIfNeeded方法。
2、调用sZygoteWriter往ServerSocket写创建进程所需要的参数，ServerSocket是啥？
3、创建ProcessStartResult，并写入从ServerSocket读取的数据，作为结果返回。
看来重点在openZygoteSocketIfNeeded方法！
1.5、openZygoteSocketIfNeeded | Process.java
private static void openZygoteSocketIfNeeded()
throws ZygoteStartFailedEx {
//重连次数
int retryCount;
if (sPreviousZygoteOpenFailed) {
retryCount = 0;
} else {
retryCount = 10;
}
for (int retry = 0
; (sZygoteSocket == null) && (retry < (retryCount + 1))
; retry++ ) {
...
try {
//client socket
sZygoteSocket = new LocalSocket();
//连接到Zygote的server socket
sZygoteSocket.connect(new LocalSocketAddress(ZYGOTE_SOCKET,
LocalSocketAddress.Namespace.RESERVED));
//sZygoteInputStream负责读取server socket信息
sZygoteInputStream
= new DataInputStream(sZygoteSocket.getInputStream());
//sZygoteWriter发送信息到server socket
sZygoteWriter =
new BufferedWriter(
new OutputStreamWriter(
sZygoteSocket.getOutputStream()),
256);
sPreviousZygoteOpenFailed = false;
break;
...
}
详细大家都能一眼看懂，这不是Java中的Socket的连接吗，这不过这里是用来进程连接。
1、创建Client Socket：sZygoteSocket
2、ClientSocket连接到服务端，ServerSocket：ZYGOTE_SOCKET
3、创建输入流负责从ServerSocket读数据，创建输出流向ServerSocket写数据。
即：
- openZygoteSocketIfNeeded方法负责连接到Zygote的Server Socket，并发送/读取Server Socket的信息。
- ServerSocket即ZYGOTE_SOCKET，它有Zygote进程创建。
既然client socket连接到Zygote的创建的ServerSocket了，那接下来看下Zygote是如何处理连接的。
Zygote处理客户端连接
Zygote进程由init进程启动，Zygote的实现在ZygoteInit.java中，其main方法调用标志着Zygote的启动。
2.1、main | ZygoteInit.java
public static void main(String argv[]) {
try {
//注册server socket
//其它进程的创建,通过连接到该Socket后，由zygote孵化出来
registerZygoteSocket();
...
//预加载android framework类和资源
preload();
...
if (argv[1].equals("start-system-server")) {
//启动SystemServer
startSystemServer();
} else if (!argv[1].equals("")) {
throw new RuntimeException(argv[0] + USAGE_STRING);
}
//死循环接收client socket连接，由此创建新进程
runSelectLoop();
closeServerSocket();
} catch (MethodAndArgsCaller caller) { //标注加红，这个异常捕获是重点！！！
caller.run();
} catch (RuntimeException ex) {
closeServerSocket();
throw ex;
}
}
- Zygote进程启动时，注册了ServerSocket，即上面提到的ZYGOTE_SOCKET，就是它来处理client socket的连接。
- Zygote进程启动时还启动了SystemServer，这在第一篇文章中已经分析过了。
- 最后调用runSelectLoop方法，死循环处理client socket连接。
最后需要注意的是：
main方法采用了try-catch的方式，其中捕获了异常MethodAndArgsCaller。由后面代码可知，通过这种抛异常的方式，使进程跳出死循环，并执行caller.run方法。
2.2、runSelectLoop | ZygoteInit.java
上面方法调用runSelectLoop，死循环处理client连接，看下其内容。
private static void runSelectLoop() throws MethodAndArgsCaller {
ArrayList<FileDescriptor> fds = new ArrayList<FileDescriptor>();
//client socket连接列表
ArrayList<ZygoteConnection> peers = new ArrayList<ZygoteConnection>();
FileDescriptor[] fdArray = new FileDescriptor[4];
//将server socket添加到fds中
fds.add(sServerSocket.getFileDescriptor());
peers.add(null);
int loopCount = GC_LOOP_COUNT;
while (true) {
int index;
...
try {
//将fds转换成数组
fdArray = fds.toArray(fdArray);
//在fdArray中找到可读的连接
index = selectReadable(fdArray);
} catch (IOException ex) {
throw new RuntimeException("Error in select()", ex);
}
if (index < 0) {
throw new RuntimeException("Error in select()");
} else if (index == 0) {
//第一个为Server socket，此时等待client socket连接
ZygoteConnection newPeer = acceptCommandPeer();
peers.add(newPeer);
fds.add(newPeer.getFileDesciptor());
} else {
boolean done;
//处理连接
done = peers.get(index).runOnce();
//处理完连接，从列表中移除
if (done) {
peers.remove(index);
fds.remove(index);
}
}
}
}
代码逻辑还是比较清楚：
- Zygote死循环处理已连接的client socket，client的连接封装成ZygoteConnection 表示，并调用其的runOnce()方法。
- 如果已连接的client socket都处理完成，那就等待新的client连接。
2.3、runOnce | ZygoteConnection.java
看下连接的处理方法runOnce()：
boolean runOnce() throws ZygoteInit.MethodAndArgsCaller {
String args[];
Arguments parsedArgs = null;
FileDescriptor[] descriptors;
try {
//读取client socket传入的参数列表
args = readArgumentList();
descriptors = mSocket.getAncillaryFileDescriptors();
}
...
try {
//转换参数
parsedArgs = new Arguments(args);
...
//Zygote创建 新进程并负责虚拟机实例到该进程
pid = Zygote.forkAndSpecialize(parsedArgs.uid, parsedArgs.gid, parsedArgs.gids,
parsedArgs.debugFlags, rlimits, parsedArgs.mountExternal, parsedArgs.seInfo,
parsedArgs.niceName);
}
...
try {
//新进程
if (pid == 0) {
IoUtils.closeQuietly(serverPipeFd);
serverPipeFd = null;
//新进程中调用
handleChildProc(parsedArgs, descriptors, childPipeFd, newStderr);
return true;
}
...
}
要划重点了：
1、该方法读取client socket连接时传入的参数，并封装。
2、调用Zygote的forkAndSpecialize创建指定进程。
3、pid=0时即子进程，在子进程中调用handleChildProc方法。
这里涉及到以下几点：
- 应用进程的确是有Zygote进程创建的，包括前文提到的SystemServer进程
- 新进程时如何与虚拟机关联的？
在forkAndSpecialize方法中，Zygote会将创建的Dalvik虚拟机实例复制到新的应用程序进程里面去，从而使得每一个应用程序进程都有一个独立的Dalvik虚拟机实例。
好了，新进程已经创建好了，但似乎还没解决问题，ActivityThread是如何运行在新进程中的呢？接着往下看handleChildProc方法。
2.4、handleChildProc | ZygoteConnection.java
private void handleChildProc(Arguments parsedArgs,
FileDescriptor[] descriptors, FileDescriptor pipeFd, PrintStream newStderr)
throws ZygoteInit.MethodAndArgsCaller {
//子进程中关闭client/server socket
closeSocket();
ZygoteInit.closeServerSocket();
...
if (parsedArgs.niceName != null) {
//设置进程名
Process.setArgV0(parsedArgs.niceName);
}
//是否设置了runtimeInit参数
if (parsedArgs.runtimeInit) {
if (parsedArgs.invokeWith != null) {
WrapperInit.execApplication(parsedArgs.invokeWith,
parsedArgs.niceName, parsedArgs.targetSdkVersion,
pipeFd, parsedArgs.remainingArgs);
} else {
//zygoteInit最后仍会创建ActivityThread实例，并调用其main方法
RuntimeInit.zygoteInit(parsedArgs.targetSdkVersion,
parsedArgs.remainingArgs);
}
} else {
String className;
try {
//传入的类全限定名，此处为：“android.app.ActivityThread”
className = parsedArgs.remainingArgs[0];
}
...
if (parsedArgs.invokeWith != null) {
WrapperInit.execStandalone(parsedArgs.invokeWith,
parsedArgs.classpath, className, mainArgs);
} else {
ClassLoader cloader;
if (parsedArgs.classpath != null) {
//ClassLoader
cloader = new PathClassLoader(parsedArgs.classpath,
ClassLoader.getSystemClassLoader());
} else {
cloader = ClassLoader.getSystemClassLoader();
}
try {
//反射创建className（此处为ActivityThread）实例，并调用其main方法
ZygoteInit.invokeStaticMain(cloader, className, mainArgs);
}
...
}
}
}
注意哦，现在已经是在新创建的子进程了哦：
1、子进程关闭client/server socket连接，为什么呢？
2、解析参数，根据前面传入的参数“android.app.ActivityThread”，调用ZygoteInit.invokeStaticMain方法，反射创建ActivityThread实例，并调用该实例main方法。
回答两个问题：
1、子进程为什么要关闭client/server socket连接，关闭client还好理解，server socket不是在Zygote进程吗？
了解Linux的都知道，通过fork创建的子进程会继承父进程的代码、数据，也就是：子进程除了自己的堆栈地址跟父进程不同外，其它数据都是直接从父进程拷贝过来的。那新创建的子进程，肯定也是有一份ServerSocket实例拷贝，子进程在创建完成后当然需要关闭。
2、为什么ActivityThread被称为主线程？
首先，ActivityThread不是线程，被称为主线程是因为：它运行在新进程的主线程中（当然了，主线程就是进程中的第一个线程了，此处没有额外再创建新线程，那肯定是主线程了）。
2.5、invokeStaticMain | ZygoteInit.java
static void invokeStaticMain(ClassLoader loader,
String className, String[] argv)
throws ZygoteInit.MethodAndArgsCaller {
Class<?> cl;
try {
cl = loader.loadClass(className);
} catch (ClassNotFoundException ex) {
throw new RuntimeException(
"Missing class when invoking static main " + className,
ex);
}
Method m;
try {
m = cl.getMethod("main", new Class[] { String[].class });
} catch (NoSuchMethodException ex) {
throw new RuntimeException(
"Missing static main on " + className, ex);
} catch (SecurityException ex) {
throw new RuntimeException(
"Problem getting static main on " + className, ex);
}
int modifiers = m.getModifiers();
if (! (Modifier.isStatic(modifiers) && Modifier.isPublic(modifiers))) {
throw new RuntimeException(
"Main method is not public and static on " + className);
}
/*
* This throw gets caught in ZygoteInit.main(), which responds
* by invoking the exception's run() method. This arrangement
* clears up all the stack frames that were required in setting
* up the process.
*/
throw new ZygoteInit.MethodAndArgsCaller(m, argv);
}
这个方法不写注释也能一眼看懂：
1、反射获得入参对应的Class，此处入参为：“android.app.ActivityThread”
2、反射获取main方法对应的Method
3、新建MethodAndArgsCaller，并以异常形式抛出
- 前面都好理解，关键是为什么要将main方法封装成异常的形式抛出呢？
前面提到：子进程实际是从父进程将代码数据拷贝而来，父进程Zygote在死循环中创建了子进程，那子进程当然也存在这份死循环的代码。子进程通过异常抛出的形式，然后异常被捕获，跳出死循环，并在调用异常的run方法，在该run方法中调用被封装的方法main。
ActivityThread
至此，应用进程已经创建好了，并通过反射方式创建了ActivityThread的实例，然后调用该实例的main方法。那看下其main方法都做了啥：
3.1、main | ActivityThread.java
public static void 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());
Security.addProvider(new AndroidKeyStoreProvider());
Process.setArgV0("<pre-initialized>");
//为当前线程创建Looper,并未改Looper创建关联的MessageQueue
Looper.prepareMainLooper();
//创建实例
ActivityThread thread = new ActivityThread();
//入口
thread.attach(false);
//创建Handler，即：H
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
AsyncTask.init();
if (false) {
Looper.myLooper().setMessageLogging(new
LogPrinter(Log.DEBUG, "ActivityThread"));
}
//mainLooper循环从消息队列中取消息，并交给H处理
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
有代码知，main方法创建了主线程关联的Looper已经H handler，这些相信大家都很熟了，但还是废话几句吧：
-
main方法在当前进程的主线程中运行，即主线程创建了Looper，并为Looper创建了关联的消息队列，以及handler H。创建完成后，调用Looper的loop方法，循环从消息队列中取出消息交给Looper处理。
- 关于Looper、MessageQueue、Handler以及Message的关系，大致如下：
- Looper与线程相关联，在Looper类中采用线程局部变量保存每个线程关联的Looper。主线程默认关联一个Looper，即MainLooper；当然也可以为子线程手动创建关联的Looper，即调用Looper.prepare()方法。
- 每个Looper实例中，存在一个关联的MessageQueue实例，调用Looper的prepare方法时，会创建Looper实例，以及Looper关联的MessageQueue实例。调用Looper.loop()方法，Looper会循环去关联的MessageQueue中取出消息处理。
- Handler，当构造Handler的实例时，会获取当前线程关联的Looper对象和MessageQueue对象引用。调用handler发送消息时，实际是将消息放入到MessageQueue中。
- Message，每个Message对象都关联了一个target，该target就是发送该消息的Handler实例。当Looper从MessageQueue中取出消息时，会将消息发送给其关联的target进行处理。（why：因为一个MessageQueue可能被多个handler引用。）
- 关于Looper、MessageQueue、Handler以及Message的关系，大致如下：
方法中另外创建了一个ActivityThread的实例，并调用其attach方法，开始应用的启动。
3.2、attach | ActivityThread.java
private void attach(boolean system) {
sCurrentActivityThread = this;
mSystemThread = system;
//普通App进这里
if (!system) {
ViewRootImpl.addFirstDrawHandler(new Runnable() {
@Override
public void run() {
ensureJitEnabled();
}
});
android.ddm.DdmHandleAppName.setAppName("<pre-initialized>",
UserHandle.myUserId());
//VM中保存该应用标志，用于上报错误
//mAppThread是Binder对象，AMS通过该对象实现与该应用进程通信，ActivityThread初始化时会创建该实例
RuntimeInit.setApplicationObject(mAppThread.asBinder());
//AMS代理
IActivityManager mgr = ActivityManagerNative.getDefault();
try {
//AMS保存该应用进程信息，通过该Binder实现与该应用进程通信
mgr.attachApplication(mAppThread); //入口
} catch (RemoteException ex) {
// Ignore
}
} else {
......
}
......
}
- 该方法入参为false，即普通应用app。
- 将应用进程Binder关联到VM，用于上报错误信息；
- 将应用进程Binder关联到AMS，用于AMS与该应用进程通信；
- 最后，通过AIDL调用AMS的attachApplication方法，所以此时又交由AMS来处理了。
什么是应用进程Binder？
在上文《沉思曲：Acitivity启动》中提到，AMS通过持有应用进程的Binder实现与应用进程的通信。该Binder实现了IApplicationThread接口，实现是ApplicaitonThread。
3.3、attachApplication | ActivityManagerService.java
public final void attachApplication(IApplicationThread thread) {
synchronized (this) {
//应用进程pid
int callingPid = Binder.getCallingPid();
final long origId = Binder.clearCallingIdentity();
//入口
attachApplicationLocked(thread, callingPid);
Binder.restoreCallingIdentity(origId);
}
}
- 该方法继续调用attachApplicationLocked方法。
- attachApplicationLocked方法主要是应用进程进行校验，并调用thread的bindApplication方法。thread就是上一方法中的入参：应用进程Binder，实现为ApplicaitonThread，是Binder对象。
- 由于thread是Binder对象，即应用进程在AMS中的Binder对象，所以此处又由AMS进程切换到应用进程中！！！
3.4、bindApplication | ActivityThread.java
note：ApplicaitonThread是ActivityThread的内部类。
public final void bindApplication(String processName,
ApplicationInfo appInfo, List<ProviderInfo> providers,
ComponentName instrumentationName, String profileFile,
ParcelFileDescriptor profileFd, boolean autoStopProfiler,
Bundle instrumentationArgs, IInstrumentationWatcher instrumentationWatcher,
IUiAutomationConnection instrumentationUiConnection, int debugMode,
boolean enableOpenGlTrace, boolean isRestrictedBackupMode, boolean persistent,
Configuration config, CompatibilityInfo compatInfo, Map<String, IBinder> services,
Bundle coreSettings) {
if (services != null) {
// Setup the service cache in the ServiceManager
ServiceManager.initServiceCache(services);
}
setCoreSettings(coreSettings);
AppBindData data = new AppBindData();
data.processName = processName;
data.appInfo = appInfo;
data.providers = providers;
data.instrumentationName = instrumentationName;
data.instrumentationArgs = instrumentationArgs;
data.instrumentationWatcher = instrumentationWatcher;
data.instrumentationUiAutomationConnection = instrumentationUiConnection;
data.debugMode = debugMode;
data.enableOpenGlTrace = enableOpenGlTrace;
data.restrictedBackupMode = isRestrictedBackupMode;
data.persistent = persistent;
data.config = config;
data.compatInfo = compatInfo;
data.initProfileFile = profileFile;
data.initProfileFd = profileFd;
data.initAutoStopProfiler = false;
//发送消息到H，消息类型为H.BIND_APPLICATION
queueOrSendMessage(H.BIND_APPLICATION, data);
}
该方法在应用进程中，调用H handler发送消息H.BIND_APPLICATION，看下H handler是如何处理该消息的。
3.5、 H处理H.BIND_APPLICATION消息 | ActivityThread.java
case BIND_APPLICATION:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "bindApplication");
AppBindData data = (AppBindData)msg.obj;
//入口
handleBindApplication(data);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
- 该方法接着调用 handleBindApplication
3.6、 handleBindApplication | ActivityThread.java
private void handleBindApplication(AppBindData data) {
mBoundApplication = data;
mConfiguration = new Configuration(data.config);
mCompatConfiguration = new Configuration(data.config);
mProfiler = new Profiler();
mProfiler.profileFile = data.initProfileFile;
mProfiler.profileFd = data.initProfileFd;
mProfiler.autoStopProfiler = data.initAutoStopProfiler;
//设置进程名
Process.setArgV0(data.processName);
android.ddm.DdmHandleAppName.setAppName(data.processName,
UserHandle.myUserId());
//是否开启硬件加速
if (data.persistent) {
if (!ActivityManager.isHighEndGfx()) {
HardwareRenderer.disable(false);
}
}
if (mProfiler.profileFd != null) {
mProfiler.startProfiling();
}
//Honeycomb MR1版本前，设置AsyncTask的底层由线程池实现
if (data.appInfo.targetSdkVersion <= android.os.Build.VERSION_CODES.HONEYCOMB_MR1) {
AsyncTask.setDefaultExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
}
//设置TimeZone、Locale
TimeZone.setDefault(null);
Locale.setDefault(data.config.locale);
//更新系统设置，AppBindData中配置默认是最新的
mResourcesManager.applyConfigurationToResourcesLocked(data.config, data.compatInfo);
mCurDefaultDisplayDpi = data.config.densityDpi;
applyCompatConfiguration(mCurDefaultDisplayDpi);
//获取Package信息，返回LoadedApk对象。先从缓存读，没有则创建。
data.info = getPackageInfoNoCheck(data.appInfo, data.compatInfo);
//设置分辨率信息
if ((data.appInfo.flags&ApplicationInfo.FLAG_SUPPORTS_SCREEN_DENSITIES)
== 0) {
mDensityCompatMode = true;
Bitmap.setDefaultDensity(DisplayMetrics.DENSITY_DEFAULT);
}
updateDefaultDensity();
//创建ContextImpl实例
final ContextImpl appContext = new ContextImpl();
appContext.init(data.info, null, this);
if (!Process.isIsolated()) {
final File cacheDir = appContext.getCacheDir();
if (cacheDir != null) {
// Provide a usable directory for temporary files
System.setProperty("java.io.tmpdir", cacheDir.getAbsolutePath());
setupGraphicsSupport(data.info, cacheDir);
} else {
Log.e(TAG, "Unable to setupGraphicsSupport due to missing cache directory");
}
}
//系统应用，开启debug log
if ((data.appInfo.flags &
(ApplicationInfo.FLAG_SYSTEM |
ApplicationInfo.FLAG_UPDATED_SYSTEM_APP)) != 0) {
StrictMode.conditionallyEnableDebugLogging();
}
//Honeycomb版本以后，不允许在主线程进行网络操作
if (data.appInfo.targetSdkVersion > 9) {
StrictMode.enableDeathOnNetwork();
}
//设置debug
......
// 是否启动GL
if (data.enableOpenGlTrace) {
GLUtils.setTracingLevel(1);
}
// Allow application-generated systrace messages if we're debuggable.
boolean appTracingAllowed = (data.appInfo.flags&ApplicationInfo.FLAG_DEBUGGABLE) != 0;
Trace.setAppTracingAllowed(appTracingAllowed);
//设置time zone时，走http代理；通过ConnectivityManager设置
IBinder b = ServiceManager.getService(Context.CONNECTIVITY_SERVICE);
if (b != null) {
IConnectivityManager service = IConnectivityManager.Stub.asInterface(b);
try {
ProxyProperties proxyProperties = service.getProxy();
Proxy.setHttpProxySystemProperty(proxyProperties);
} catch (RemoteException e) {}
}
//是否指定trumentation类名，难道可以指定？！
if (data.instrumentationName != null) {
InstrumentationInfo ii = null;
try {
//获取Instrumentation信息
ii = appContext.getPackageManager().
getInstrumentationInfo(data.instrumentationName, 0);
}
......
mInstrumentationAppDir = ii.sourceDir;
mInstrumentationAppLibraryDir = ii.nativeLibraryDir;
mInstrumentationAppPackage = ii.packageName;
mInstrumentedAppDir = data.info.getAppDir();
mInstrumentedAppLibraryDir = data.info.getLibDir();
//创建ApplicationInfo，用来保存应用信息
ApplicationInfo instrApp = new ApplicationInfo();
instrApp.packageName = ii.packageName;
instrApp.sourceDir = ii.sourceDir;
instrApp.publicSourceDir = ii.publicSourceDir;
instrApp.dataDir = ii.dataDir;
instrApp.nativeLibraryDir = ii.nativeLibraryDir;
//创建LoadedApk实例，保存应用APK信息
LoadedApk pi = getPackageInfo(instrApp, data.compatInfo,
appContext.getClassLoader(), false, true);
//创建应用关联的CotextImpl
ContextImpl instrContext = new ContextImpl();
instrContext.init(pi, null, this);
try {
java.lang.ClassLoader cl = instrContext.getClassLoader();
//为应用创建指定的Instrumentation实例
mInstrumentation = (Instrumentation)
cl.loadClass(data.instrumentationName.getClassName()).newInstance();
}
......
//init，保存应用信息到Instrumentation
mInstrumentation.init(this, instrContext, appContext,
new ComponentName(ii.packageName, ii.name), data.instrumentationWatcher,
data.instrumentationUiAutomationConnection);
......
} else {
//未指定Instrmentation名称，创建默认Instrumentation
mInstrumentation = new Instrumentation();
}
if ((data.appInfo.flags&ApplicationInfo.FLAG_LARGE_HEAP) != 0) {
dalvik.system.VMRuntime.getRuntime().clearGrowthLimit();
}
//允许application和provider启动时访问disk
final StrictMode.ThreadPolicy savedPolicy = StrictMode.allowThreadDiskWrites();
try {
//创建Application实例
Application app = data.info.makeApplication(data.restrictedBackupMode, null);
mInitialApplication = app;
//restricted模式下，c处理provider
if (!data.restrictedBackupMode) {
List<ProviderInfo> providers = data.providers;
if (providers != null) {
installContentProviders(app, providers);
mH.sendEmptyMessageDelayed(H.ENABLE_JIT, 10*1000);
}
}
try {
//调用Instrumentation的onCreate方法，用于Applicaiton启动onCreate()启动前的操作
mInstrumentation.onCreate(data.instrumentationArgs);
}
......
try {
//Instrumentation回调应用Applicaiton的onCreate，启动应用
mInstrumentation.callApplicationOnCreate(app);
}
......
}
该方法负责启动应用：
- 设置进程名、是否开启硬件加速
- 设置AsyncTask的底层实现方式
- 设置TimeZone、Locale
- 设置分辨率、不允许主线程网络操作等
- 为应用进程设置Instrumentation，用于管理应用进程
- 通过Instrumentation调用应用Applicationde 的onCreate方法，实现应用的启动等
- 设置timezone、openGl等信息后，创建Instrumentation用于管理该应用进程，最后并回调该应用的Application的onCreate方法启动应用。
至此，本文内容就差不多结束了，后面应用的启动就不讲了，感兴趣的可以看源码，大同小异。
总结
三篇文章到此结束了，三文粗略的分析了Android系统启动、Activity启动、ActivityThread创建三部分内容。内容都是整理之前资料得到的，网上关于这部分内容的资料也很多，但都比较零散。这里把这部分内容整理出来，一来备忘，二来抛砖引玉。本人才疏学浅，大部分内容都是自己理解加注释，有不当错误之处，恳请指正~
