以下分析基于android 27版本，所有流程基于函数调用顺序说明
启动基本时序图如下：
image.png
main()
我们知道所有的程序都是main()函数开始的，应用程序也是一样的，安卓里面的启动main()函数就在ActivityThread里面，源码体现如下：（部分进行了省略，具体的可以自己到源码进行查看）
main()方法里面进行了主线程的准备，以及一些相关对象的初始化工作。
public static void main(String[] args) {
//···以上省略，重点代码如下
//主线程Looper准备
Looper.prepareMainLooper();
//初始化ActivityThread对象
ActivityThread thread = new ActivityThread();
//划重点！！将当前ApplicationThread信息添加到ActivityManager上
thread.attach(false);
//···以下省略，重点代码如上
}
另外，在ActivityThread里面有有一些成员变量是跟随ActivityThread的实例化进行创建的，以下展示部分：
//、、、
final ApplicationThread mAppThread = new ApplicationThread();
final Looper mLooper = Looper.myLooper();
final H mH = new H();//H继承于Handler，用于进行线程间通讯，主要进行Activity的一些生命周期的调用
final ArrayMap<IBinder, ActivityClientRecord> mActivities = new ArrayMap<>();
//此对象用于保存Activity的一些相关信息
ActivityClientRecord mNewActivities = null;
// Number of activities that are currently visible on-screen.
int mNumVisibleActivities = 0;
//、、、
ApplicationThread是ActivityThread的内部类，并且是IApplicationThread.Stub的实现类，所以我们可以知道，ApplicationThread是通过实现Binder机制对Activity的一些相关操作进行控制的，部分代码如下：
image.png
可以看出里面很多的对Activity的相关操作的方法，而方法里面的操作则是通过sendMessage()的方式回调到H里面进行操作（H是Handler的实现类）。以下举例一个方法：
public final void schedulePauseActivity(IBinder token, boolean finished,
boolean userLeaving, int configChanges, boolean dontReport) {
int seq = getLifecycleSeq();
if (DEBUG_ORDER) Slog.d(TAG, "pauseActivity " + ActivityThread.this
+ " operation received seq: " + seq);
sendMessage(
finished ? H.PAUSE_ACTIVITY_FINISHING : H.PAUSE_ACTIVITY,
token,
(userLeaving ? USER_LEAVING : 0) | (dontReport ? DONT_REPORT : 0),
configChanges,
seq);
}
attach()
此方法的作用就是将实例化好的mAppThread与ActivityManager进行注册，主要过程如下：
private void attach(boolean system) {
//···以上省略，重点代码如下
android.ddm.DdmHandleAppName.setAppName("<pre-initialized>",
UserHandle.myUserId());
RuntimeInit.setApplicationObject(mAppThread.asBinder());
//下面这行代码是重点
final IActivityManager mgr = ActivityManager.getService();
try {
//下面这行代码也是重点
mgr.attachApplication(mAppThread);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
//···以下省略，重点代码如上
}
mAppThread是ApplicationThread的对象实例。
ActivityManager.getService()会通过Binder机制获取到IActivityManager对象，获取代码如下：
使用单例模式，通过Binder机制获取到ActivityService的IBinder对象，再转换成ActivityManager的代理对象。
看懂以下代码需要有一定的Binder机制基础，activity的启动代码里面涉及了Handler原理，Binder机制等相关知识，需要对这些有一定了解。
/**
* @hide
*/
public static IActivityManager getService() {
return IActivityManagerSingleton.get();
}
private static final Singleton<IActivityManager> IActivityManagerSingleton =
new Singleton<IActivityManager>() {
@Override
protected IActivityManager create() {
final IBinder b = ServiceManager.getService(Context.ACTIVITY_SERVICE);
final IActivityManager am = IActivityManager.Stub.asInterface(b);
return am;
}
};
=======
通过以上main()方法和attach()方法，主线程的相关准备工作就完成了，剩下的就是Activity的相关启动了，而相关方法就到了ApplicationThread里面了（通过Binder机制远程调用启动）
第一步就是执行启动方法：scheduleLaunchActivity：
// we use token to identify this activity without having to send the
// activity itself back to the activity manager. (matters more with ipc)
@Override
public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,
ActivityInfo info, Configuration curConfig, Configuration overrideConfig,
CompatibilityInfo compatInfo, String referrer, IVoiceInteractor voiceInteractor,
int procState, Bundle state, PersistableBundle persistentState,
List<ResultInfo> pendingResults, List<ReferrerIntent> pendingNewIntents,
boolean notResumed, boolean isForward, ProfilerInfo profilerInfo) {
updateProcessState(procState, false);
ActivityClientRecord r = new ActivityClientRecord();
r.token = token;
r.ident = ident;
r.intent = intent;
r.referrer = referrer;
r.voiceInteractor = voiceInteractor;
r.activityInfo = info;
r.compatInfo = compatInfo;
r.state = state;
r.persistentState = persistentState;
r.pendingResults = pendingResults;
r.pendingIntents = pendingNewIntents;
r.startsNotResumed = notResumed;
r.isForward = isForward;
r.profilerInfo = profilerInfo;
r.overrideConfig = overrideConfig;
updatePendingConfiguration(curConfig);
sendMessage(H.LAUNCH_ACTIVITY, r);
}
里面可以看到实例化了一个ActivityClientRecord类，这个类的作用就是记录Activity的相关参数信息。然后将记录好的相关activity信息通过handMessage的形式发送到H（ActivityThread的内部类，是Handler的实现类）里面进行处理，相关处理方法如下：（H里面还有很多相关Activity的相关其他操作方法，可以到源码查看）
public void handleMessage(Message msg) {
//···以上省略，重点代码如下
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;
//···以下省略，重点代码如上
}
我们知道H也是ActivityThread里面的内部类，可以看到H里面的分发方法最后又调用了ActivityThread里面的handleLaunchActivity方法：具体如下
private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {
//···以上省略，重点代码如下
WindowManagerGlobal.initialize();
Activity a = performLaunchActivity(r, customIntent);
if (a != null) {
r.createdConfig = new Configuration(mConfiguration);
reportSizeConfigurations(r);
Bundle oldState = r.state;
handleResumeActivity(r.token, false, r.isForward,
!r.activity.mFinished && !r.startsNotResumed, r.lastProcessedSeq, reason);
if (!r.activity.mFinished && r.startsNotResumed) {
performPauseActivityIfNeeded(r, reason);
if (r.isPreHoneycomb()) {
r.state = oldState;
}
}
} else {
// If there was an error, for any reason, tell the activity manager to stop us.
try {
ActivityManager.getService().finishActivity(r.token, Activity.RESULT_CANCELED, null,Activity.DONT_FINISH_TASK_WITH_ACTIVITY);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
}
}
以上方法主要对WindowManager进行了实例化,window的处理也是比较需要重要了解的，相关类继承图如下：
image.png
handleLaunchActivity也初始化了一个Activity对象，初始化Activity过程如下：（通过ClassLoader获取了Activity对象）
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
//···以上省略，重点代码如下
ContextImpl appContext = createBaseContextForActivity(r);
Activity activity = null;
try {
java.lang.ClassLoader cl = appContext.getClassLoader();
activity = mInstrumentation.newActivity(
cl, component.getClassName(), r.intent);
StrictMode.incrementExpectedActivityCount(activity.getClass());
r.intent.setExtrasClassLoader(cl);
r.intent.prepareToEnterProcess();
if (r.state != null) {
r.state.setClassLoader(cl);
}
} catch (Exception e) {
if (!mInstrumentation.onException(activity, e)) {
throw new RuntimeException(
"Unable to instantiate activity " + component + ": " + e.toString(), e);
}
}
//···以下省略，重点代码如上
}
以上基本完成了对Activity的创建以及启动的之前的基本准备工作，后续的就是对窗口做相关的添加布局的操作了。
布局的处理就到了handleResumeActivity里面了，相关代码如下：
final void handleResumeActivity(IBinder token,
boolean clearHide, boolean isForward, boolean reallyResume, int seq, String reason) {
ActivityClientRecord r = mActivities.get(token);
//···以上省略，重点代码如下
if (r.window == null && !a.mFinished && willBeVisible) {
r.window = r.activity.getWindow();
View decor = r.window.getDecorView();
decor.setVisibility(View.INVISIBLE);
ViewManager wm = a.getWindowManager();
WindowManager.LayoutParams l = r.window.getAttributes();
a.mDecor = decor;
l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION;
l.softInputMode |= forwardBit;
if (r.mPreserveWindow) {
a.mWindowAdded = true;
r.mPreserveWindow = false;
// Normally the ViewRoot sets up callbacks with the Activity
// in addView->ViewRootImpl#setView. If we are instead reusing
// the decor view we have to notify the view root that the
// callbacks may have changed.
ViewRootImpl impl = decor.getViewRootImpl();
if (impl != null) {
impl.notifyChildRebuilt();
}
}
if (a.mVisibleFromClient) {
if (!a.mWindowAdded) {
a.mWindowAdded = true;
wm.addView(decor, l);
} else {
// The activity will get a callback for this {@link LayoutParams} change
// earlier. However, at that time the decor will not be set (this is set
// in this method), so no action will be taken. This call ensures the
// callback occurs with the decor set.
a.onWindowAttributesChanged(l);
}
}
// If the window has already been added, but during resume
// we started another activity, then don't yet make the
// window visible.
} else if (!willBeVisible) {
if (localLOGV) Slog.v(
TAG, "Launch " + r + " mStartedActivity set");
r.hideForNow = true;
}
//···以下省略，重点代码如上
}
handleResumeActivity里面就是关于window的添加的具体流程了，相关方法调用过程如下：
image.png
