从源码看Activity启动过程(三)AMS-ActivityThread/ApplicationThread-实例化Activity

1、ActivityThread源码解析public final class ActivityThread {
//一些重要变量
final ApplicationThread mAppThread = new ApplicationThread();
final Looper mLooper = Looper.myLooper();
//这个mH就是当前进程UI线程的handler，处理接收到的消息，比如四大组件生命周期方法的调用等
final H mH = new H();
//当前进程的所有activity数据都会封装成ActivityClientRecord放入mActivities
final ArrayMap<IBinder, ActivityClientRecord> mActivities = new ArrayMap<>();
ArrayList<WeakReference<AssistStructure>> mLastAssistStructures = new ArrayList<>();
final ArrayMap<IBinder, Service> mServices = new ArrayMap<>();
AppBindData mBoundApplication;
Profiler mProfiler;
int mCurDefaultDisplayDpi;
boolean mDensityCompatMode;
Configuration mConfiguration;
Configuration mCompatConfiguration;
Application mInitialApplication;
final ArrayList<Application> mAllApplications = new ArrayList<Application>();
// set of instantiated backup agents, keyed by package name
final ArrayMap<String, BackupAgent> mBackupAgents = new ArrayMap<String, BackupAgent>();
/** Reference to singleton {@link ActivityThread} */
private static volatile ActivityThread sCurrentActivityThread;
Instrumentation mInstrumentation;
...
//main方法
public static void main(String[] args) {
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");
SamplingProfilerIntegration.start();
CloseGuard.setEnabled(false);

Environment.initForCurrentUser();

// Set the reporter for event logging in libcore
EventLogger.setReporter(new EventLoggingReporter());

// Make sure TrustedCertificateStore looks in the right place for CA certificates
final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());
TrustedCertificateStore.setDefaultUserDirectory(configDir);

Process.setArgV0("<pre-initialized>");

Looper.prepareMainLooper();

ActivityThread thread = new ActivityThread();
thread.attach(false);

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

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

// End of event ActivityThreadMain.
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
Looper.loop();

throw new RuntimeException("Main thread loop unexpectedly exited");
}
...
/**
* ApplicationThread中封装的方法都能看到四大组件的影子activity的几个生命周期方法、receiver、service等
* 它的作用就是作为服务端，与ActivityManagerService所在进程进行通信，接收AMS的消息并执行
*/
private class ApplicationThread extends ApplicationThreadNative {

public final void schedulePauseActivity(IBinder token, boolean finished, ...) {
sendMessage(finished ? H.PAUSE_ACTIVITY_FINISHING : H.PAUSE_ACTIVITY, token, ...);
}
}
/**
* 该进程的UI线程的handler，处理该进程几乎所有需要跟系统进程交互的消息
*/
private class H extends Handler {
public void handleMessage(Message msg) {
if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
switch (msg.what) {
case LAUNCH_ACTIVITY: {
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
final ActivityClientRecord r = (ActivityClientRecord) msg.obj;
r.packageInfo = getPackageInfoNoCheck(r.activityInfo.applicationInfo, r.compatInfo);
handleLaunchActivity(r, null, "LAUNCH_ACTIVITY");
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
} break;
case SEND_RESULT:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityDeliverResult");
handleSendResult((ResultData)msg.obj);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
case RECEIVER:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "broadcastReceiveComp");
handleReceiver((ReceiverData)msg.obj);
maybeSnapshot();
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
case CREATE_SERVICE:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, ("serviceCreate: " + String.valueOf(msg.obj)));
handleCreateService((CreateServiceData)msg.obj);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
...
}
Object obj = msg.obj;//这个SomeArgs使用了单链表的对象池，避免创建大量对象导致GC卡顿吧
if (obj instanceof SomeArgs) {
((SomeArgs) obj).recycle();
}
if (DEBUG_MESSAGES) Slog.v(TAG, "<<< done: " + codeToString(msg.what));
}
}
}2、ApplicationThread源码解析
先给结果在看代码，会清晰一些，流程如下：
ActivityManagerService.startActivity()，这里会ApplicationThreadNative.asInterface(whoThread)拿到ApplicationThread
    |
很复杂的一系列逻辑判断、数据处理....
ActvityiManagerService.startActivityAsUser()
ActivityStackSupervisor.startActivityMayWait()
ActivityStackSupervisor.startActivityLocked()
ActivityStackSupervisor.startActivityUncheckedLocked()
ActivityStackSupervisor.startActivityLocked()
ActivityStackSupervisor.resumeTopActivitiesLocked()
ActivityStackSupervisor.resumeTopActivityInnerLocked()
    |
ActivityStackSupervisor.realStartActivityLocked(ActivityRecord r,...)
它内部调用ApplicationThread的app.thread.scheduleLaunchActivity() /*这个app.thread就是ApplicationThread*/
把数据传给ApplicationThread所在的server端
    |
写入之后就是ApplicationThreadProxy.scheduleLaunchActivity()写入数据
    |
通过Binder driver
    |
触发server端的ApplicationThreadNative的onTransact()
    |
ApplicationThread.launchActivity()
    |
ActivityThread.mH.sendMessage()
    |
ActivityThread.mH.handleMessage()
    |
ActivityThread.handleLaunchActivity()
    |
ActivityThread.performLaunchActivity()
    |
ActivityThread.mInstrumentation.callActivityOnCreate(),ActivityThread.mActivities.put(IBinder, ActivityClientRecord);

/**
* ApplicationThread是ActivityThread的内部类
* ApplicationThread中封装的方法都能看到四大组件的影子activity的几个生命周期方法、receiver、service等
* 它的作用就是作为服务端，与ActivityManagerService所在进程进行通信，接收AMS的消息并执行
*/
private class ApplicationThread extends ApplicationThreadNative {

public final void schedulePauseActivity(IBinder token, boolean finished, ...) {
...
//调用ActivityThread的mH.sendMessage()，发来自AMS的消息传递给UI线程的handler，并执行
sendMessage(finished ? H.PAUSE_ACTIVITY_FINISHING : H.PAUSE_ACTIVITY, token, ...);
}
}

public abstract class ApplicationThreadNative extends Binder implements IApplicationThread {

static public IApplicationThread asInterface(IBinder obj) {//给client端调用的
if (obj == null) {
return null;
}
IApplicationThread in = (IApplicationThread)obj.queryLocalInterface(descriptor);
if (in != null) {
return in;
}
return new ApplicationThreadProxy(obj);
}

public ApplicationThreadNative() {
attachInterface(this, descriptor);
}

    /**
    * AMS中获取ApplicationThreadProxy调用它的方法写入数据，然后通过server的binder.transact(),把数据传到了这里
    * 这个binder.transact()调用的是native层的方法(binder driver)
     */
@Override
public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
throws RemoteException {
switch (code) {
case SCHEDULE_PAUSE_ACTIVITY_TRANSACTION://来自AMS的PAUSE_ACTIVITY的指令
{
data.enforceInterface(IApplicationThread.descriptor);
//读取从AMS传过来的数据
IBinder b = data.readStrongBinder();
boolean finished = data.readInt() != 0;
boolean userLeaving = data.readInt() != 0;
int configChanges = data.readInt();
boolean dontReport = data.readInt() != 0;
/*
* 这个schedulePauseActivity方法是在ApplicationThread类中实现的，调用ApplicationThread.schedulePauseActivity(..)
* 在ApplicationThread中又会调用ActivityThread的mH.sendMessage()，在UI的handler-mH中接收消息并执行
*/
schedulePauseActivity(b, finished, userLeaving, configChanges, dontReport);
return true;
}
    }
}

class ApplicationThreadProxy implements IApplicationThread {
private final IBinder mRemote;//server端的binder
public ApplicationThreadProxy(IBinder remote) {
mRemote = remote;
}
public final IBinder asBinder() {
return mRemote;
}
//client端(AMS)拿到ApplicationThreadProxy后，调用该方法写入数据传给ApplicationThread(server端)
public final void schedulePauseActivity(IBinder token, boolean finished, ...) throws RemoteException {
Parcel data = Parcel.obtain();
data.writeInterfaceToken(IApplicationThread.descriptor);
data.writeStrongBinder(token);
data.writeInt(finished ? 1 : 0);
data.writeInt(userLeaving ? 1 :0);
data.writeInt(configChanges);
data.writeInt(dontReport ? 1 : 0);
//这里内部会调用到ApplicationThreadNative.onTransact()，通过binder driver把数据传给server端
mRemote.transact(SCHEDULE_PAUSE_ACTIVITY_TRANSACTION, data, null, IBinder.FLAG_ONEWA
b0e7
Y);
data.recycle();
}
}
}

public final class ActivityManagerService extends ActivityManagerNative
implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
@Override
public int startActivity(IBinder whoThread, String callingPackage, Intent intent, String resolvedType, Bundle bOptions) {
checkCaller();
int callingUser = UserHandle.getCallingUserId();
TaskRecord tr;
IApplicationThread appThread;
synchronized (ActivityManagerService.this) {
tr = mStackSupervisor.anyTaskForIdLocked(mTaskId);
if (tr == null) {
throw new IllegalArgumentException("Unable to find task ID " + mTaskId);
}
//这里是关键，获取ApplicationThreadProxy
appThread = ApplicationThreadNative.asInterface(whoThread);
if (appThread == null) {
throw new IllegalArgumentException("Bad app thread " + appThread);
}
}
return mActivityStarter.startActivityMayWait(appThread, -1, callingPackage, intent,
resolvedType, null, null, null, null, 0, 0, null, null,
null, bOptions, false, callingUser, null, tr);
}
}

总结：
[align=left] >AMS -> Binder Driver -> ApplicationNativeProxy -> ApplicationNative -> ApplicationThread -> ActivityThread
-> Instrumentation.newActivity(ClassLoader cl, String className, Intent intent)类的加载

ActivityThread中保存了当前进程的Activity、service等信息，通过ApplicationThread接收来自AMS的消息并执行
[/align]