if (false) {
Looper.myLooper().setMessageLogging(new
LogPrinter(Log.DEBUG, \ } ...
//进入消息循环 Looper.loop();
throw new RuntimeException(\ }
private void attach(boolean system) { sCurrentActivityThread = this; mSystemThread = system; if (!system) { ... /*
* ActivityManagerNative.getDefault()方法返回的是一个ActivityManagerProxy对象，
* ActivityManagerProxy实现了IActivityManager接口，并维护了一个mRemote，
* 这个mRemote就是ActivityManagerService的远程代理对象 */
final IActivityManager mgr = ActivityManagerNative.getDefault(); try {
//调用attachApplication()，并将mAppThread传入，mAppThread是ApplicationThread类的示例，他的作用是用来进程间通 信的
mgr.attachApplication(mAppThread); } catch (RemoteException ex) { // Ignore } ... } else { ... } ... } }
ActivityThread是应用程序进程中的主线程，他的作用是调度和执行activities、广播和其他操作。 main方法开启了消息循环机制，并调用
attach()方法，attach()方法会调用ActivityManagerNative.getDefault()获取到一个ActivityManagerProxy示例，上面step3中我们讲解了
ActivityManagerNative这个类，ActivityManagerProxy中维护了ActivityManagerService的远程代理对象mRemote； 然后会调用
attachApplication()方法通过mRemote调用到ActivityManagerService的attachApplication()中， 传入的mAppThread是ApplicationThread类
型，mAppThread实际上通过Handler实现ActivityManagerService与ActivityThread的消息通信。
step14: ActivityManagerProxy.attachApplication() （ActivityManagerNative内部类）
public void attachApplication(IApplicationThread app) throws RemoteException {
Parcel data = Parcel.obtain(); Parcel reply = Parcel.obtain();
data.writeInterfaceToken(IActivityManager.descriptor); data.writeStrongBinder(app.asBinder());
mRemote.transact(ATTACH_APPLICATION_TRANSACTION, data, reply, 0); reply.readException(); data.recycle(); reply.recycle(); }
attachApplication()接受IApplicationThread实例，step13中attach()方法传入的ApplicationThread实现了IApplicationThread，然后通过
ActivityManagerService的远程代理对象mRemote，进入ActivityManagerService的attachApplication()：
step15: ActivityManagerService.attachApplication()
@Override
public final void attachApplication(IApplicationThread thread) { synchronized (this) {
int callingPid = Binder.getCallingPid();
final long origId = Binder.clearCallingIdentity();
//接着调用attachAppwww.shanxiwang.netlicationLocked() attachApplicationLocked(thread, callingPid); Binder.restoreCallingIdentity(origId); } }
private final boolean attachApplicationLocked(IApplicationThread thread, int pid) { //① 获取到进程 ProcessRecord app;
if (pid != MY_PID && pid >= 0) { synchronized (mPidsSelfLocked) { app = mPidsSelfLocked.get(pid); } } else {
app = null; }
if (app == null) {
if (pid > 0 && pid != MY_PID) { ...
Process.killProcessQuiet(pid); } else {
thread.scheduleExit(); ... }
return false; } ...
//② 对app的一些成员变量进行初始化 app.makeActive(thread, mProcessStats); app.curAdj = app.setAdj = -100;
app.curSchedGroup = app.setSchedGroup = Process.THREAD_GROUP_DEFAULT; app.forcingToForeground = null;
updateProcessForegroundLocked(app, false, false); app.hasShownUi = false; app.debugging = false; app.cached = false;
app.killedByAm = false;
...
boolean normalMode = mProcessesReady || isAllowedWhileBooting(app.info); ...
boolean badApp = false;
boolean didSomething = false;
// See if the top visible activity is waiting to run in this process... /*
* ③ 检查当前进程中顶端的activity是否等着被运行，这个顶端的activity就是我们要启动的activity； *
* 此处适用于需要为activity创建新进程的情况（比如点击Launcher桌面上的图标启动应用，或者打开配置了process的activity） *
* 如果应用程序已经启动，在应用程序内部启动activity(未配置process)不会创建进程，这种情况回到step11中的第①步直接开启
activity */
if (normalMode) { try {
if (mStackSupervisor.attachApplicationLocked(app)) { didSomething = true; }
} catch (Exception e) {
Slog.wtf(TAG, \ badApp = true; } }
// Find any services that should be running in this process... //④ 查找当前进程中应该启动的服务，并将其启动 if (!badApp) { try {
didSomething |= mServices.attachApplicationLocked(app, processName); } catch (Exception e) {
Slog.wtf(TAG, \ badApp = true; } }
// Check if a next-broadcast receiver is in this process... //⑤ 查找当前进程中应该注册的广播
if (!badApp && isPendingBroadcastProcessLocked(pid)) { try {
didSomething |= sendPendingBroadcastsLocked(app); } catch (Exception e) {
// If the app died trying to launch the receiver we declare it 'bad'
Slog.wtf(TAG, \ badApp = true; } }
// Check whether the next backup agent is in this process... ...
return true; }
attachApplication()方法调用了attachApplicationLocked()方法， 在step12中，我们创建了一个ProcessRecord，这里通过进程的pid将他取
出来，赋值给app， 并初始化app的一些成员变量，然后为当前进程启动顶层activity、一些服务和广播; 这里我们就不深入研究到底启动的是
那些，我们主要研究activity的启动，所以重点看第③步，_ step6_中最后创建了一个ActivityRecord实例r，这个r只是进程堆栈中的一个活
动记录， 然后再step8中将这个r插入到堆栈最顶端，所以这个r相当于一个占位，并不是真正启动的Activity， 真正启动Activity需要判断进
程是否存在，如果存在就直接启动，如果不存在需要启动进程后再执行此处第③步调用ActivityStackSupervisor.attachApplicationLocked
(ProcessRecord)方法：
step16: ActivityStackSupervisor.attachApplicationLocked(ProcessRecord)
boolean attachApplicationLocked(ProcessRecord app) throws RemoteException { final String processName = app.processName; boolean didSomething = false;
for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
ArrayList stacks = mActivityDisplays.valueAt(displayNdx).mStacks; for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { //遍历进程中的堆栈，找到最顶层的堆栈 final ActivityStack stack = stacks.get(stackNdx); if (!isFrontStack(stack)) { continue; } // /*
* 获取位于顶层堆栈中栈顶的activity，这个activity就是目标activity(需要被启动的);
* 这个hr就是step6中创建的ActivityRecord实例r */
ActivityRecord hr = stack.topRunningActivityLocked(null); if (hr != null) {
if (hr.app == null && app.uid == hr.info.applicationInfo.uid && processName.equals(hr.processName)) { try {
//调用realStartActivityLocked()方法启动activity，同step11中的