从源码看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_ONEWAY);
			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);
	}
}

总结：

 >AMS -> Binder Driver -> ApplicationNativeProxy -> ApplicationNative -> ApplicationThread -> ActivityThread
-> Instrumentation.newActivity(ClassLoader cl, String className, Intent intent)类的加载

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