在android9.0的基础上,分析Activity的启动流程。
源码地址:https://www.androidos.net.cn/android/9.0.0_r8/xref
1.ActivityThread的启动流程
ActivityThread是应用的主线程/UI线程,其main()方法是app的入口方法。
ActivityThread继承于ClientTransactionHandler。
1.1 ActivityThread.main()
public final class ActivityThread extends ClientTransactionHandler {
public static void main(String[] args) {
...
Looper.prepareMainLooper();
...
ActivityThread thread = new ActivityThread();
thread.attach(false, startSeq);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
...
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
}
main方法说明:
1)初始化Looper(用户在主线程中无需再次初始化Looper);
2)实例化ActivityThread, 并调用attach方法(内部大量IPC过程);
3)开启消息循环。
1.2 ActivityThread#attach()
private void attach(boolean system, long startSeq) {
...
// mgr为ActivityManagerService
final IActivityManager mgr = ActivityManager.getService();
try {
mgr.attachApplication(mAppThread, startSeq);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
...
}
attach方法说明:
这里mAppThread为ApplicationThread,是Binder对象,主要用于ActivityThread与AMS之间的通信;
AMS运行在SystemServer进程,ActivityThread调用AMS的方法就是IPC过程。
1.3 ActivityManagerService#attachApplication()
@Override
public final void attachApplication(IApplicationThread thread, long startSeq) {
synchronized (this) {
int callingPid = Binder.getCallingPid();
final int callingUid = Binder.getCallingUid();
final long origId = Binder.clearCallingIdentity();
attachApplicationLocked(thread, callingPid, callingUid, startSeq);
Binder.restoreCallingIdentity(origId);
}
}
ActivityManagerService#attachApplicationLocked() 方法介绍
@GuardedBy("this")
private final boolean attachApplicationLocked(IApplicationThread thread,
int pid, int callingUid, long startSeq) {
...
// IPC调用ApplicationThread的方法,创建application并调用onCreate
thread.bindApplication(19个参数)
...
// 创建Activity并调用onCreate
if (normalMode) {
try {
if (mStackSupervisor.attachApplicationLocked(app)) {
didSomething = true;
}
} catch (Exception e) {
Slog.wtf(TAG, "Exception thrown launching activities in " + app, e);
badApp = true;
}
}
...
}
AMS#attachApplicationLocked方法说明:
1) 创建application;
IPC方式调用ApplicationThread的方法, 创建application也是有一套流程。
2)创建activity。
2.Application的创建过程
2.1 ApplicationThread#bindApplication()
由1.3节可以知道,AMS内部调用ApplicationThread的bindApplication来创建和初始化application.
public final void bindApplication(19个参数){
...
AppBindData data = new AppBindData();
...
sendMessage(H.BIND_APPLICATION, data);
}
从主线程消息队列中取出消息H.BIND_APPLICATION,调用handleBindApplication方法
private void handleBindApplication(AppBindData data) {
...
// 1.创建ContextImpl与Instrumentation
final ContextImpl instrContext = ContextImpl.createAppContext(this, pi,
appContext.getOpPackageName());
try {
final ClassLoader cl = instrContext.getClassLoader();
mInstrumentation = (Instrumentation)
cl.loadClass(data.instrumentationName.getClassName()).newInstance();
} catch (Exception e) {
throw new RuntimeException(
"Unable to instantiate instrumentation "
+ data.instrumentationName + ": " + e.toString(), e);
}
// 2.创建Application
app = data.info.makeApplication(data.restrictedBackupMode, null);
// 3.启动ContentProvider并调用onCreate方法
installContentProviders(app, data.providers);
// 4.调用applicaton.onCreate
mInstrumentation.callApplicationOnCreate(app);
...
}
2.2 Instrumentation#callApplicationOnCreate()
内部实现就是调用application的onCreate方法。
public void callApplicationOnCreate(Application app) {
app.onCreate();
}
ActivityThread#handleBindApplication方法说明:
1) handleBindApplication方法可分为4个步骤,最终完成了application的创建以及onCreate方法调用;
2)解释了ContentProvider#onCreate方法为什么比Application#onCreate先调用。
3.Activity的创建过程
3.1 ActivityStackSupervisor#attachApplicationLocked()
ActivityStackSupervisor是Activity栈管理类
attachApplicationLocked()内部调用realStartActivityLocked()
final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
boolean andResume, boolean checkConfig) throws RemoteException {
...
// Create activity launch transaction.
final ClientTransaction clientTransaction = ClientTransaction.obtain(app.thread,
r.appToken);
clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),
System.identityHashCode(r), r.info,
// TODO: Have this take the merged configuration instead of separate global
// and override configs.
mergedConfiguration.getGlobalConfiguration(),
mergedConfiguration.getOverrideConfiguration(), r.compat,
r.launchedFromPackage, task.voiceInteractor, app.repProcState, r.icicle,
r.persistentState, results, newIntents, mService.isNextTransitionForward(),
profilerInfo));
// Schedule transaction.
mService.getLifecycleManager().scheduleTransaction(clientTransaction);
...
}
说明:
android9.0与android8.0对此方法的实现有较大改变,8.0的代码更为直观。
android8.0是直接调用app.thread.scheduleLaunchActivity()。
3.2 ClientLifecycleManager#scheduleTransaction()
void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
final IApplicationThread client = transaction.getClient();
transaction.schedule();
if (!(client instanceof Binder)) {
// If client is not an instance of Binder - it's a remote call and at this point it is
// safe to recycle the object. All objects used for local calls will be recycled after
// the transaction is executed on client in ActivityThread.
transaction.recycle();
}
}
3.3 ClientTransaction#schedule()
// 这是隐藏的类 @hide,所以在sdk中检索不到
public class ClientTransaction implements Parcelable, ObjectPoolItem {
/** Target client. */
private IApplicationThread mClient;
// 3.1节调用此方法获取该类实例
public static ClientTransaction obtain(IApplicationThread client, IBinder activityToken) {
ClientTransaction instance = ObjectPool.obtain(ClientTransaction.class);
if (instance == null) {
instance = new ClientTransaction();
}
instance.mClient = client;
instance.mActivityToken = activityToken;
return instance;
}
public void schedule() throws RemoteException {
mClient.scheduleTransaction(this);
}
...
}
说明:
mClient从调用3.1节调用关系可知,其为ApplicationThread的实例对象。
因此schedule()实际上调用的是ApplicationThread#scheduleTransaction
private class ApplicationThread extends IApplicationThread.Stub {
...
@Override
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
ActivityThread.this.scheduleTransaction(transaction);
}
}
调用主线程ActivityThread父类scheduleTransaction方法
public abstract class ClientTransactionHandler {
// Schedule phase related logic and handlers.
/** Prepare and schedule transaction for execution. */
void scheduleTransaction(ClientTransaction transaction) {
transaction.preExecute(this);
sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}
...
}
主线程消息队列,分发EXECUTE_TRANSACTION
case EXECUTE_TRANSACTION:
final ClientTransaction transaction = (ClientTransaction) msg.obj;
mTransactionExecutor.execute(transaction);
if (isSystem()) {
// Client transactions inside system process are recycled on the client side
// instead of ClientLifecycleManager to avoid being cleared before this
// message is handled.
transaction.recycle();
}
// TODO(lifecycler): Recycle locally scheduled transactions.
break;
3.4 TransactionExecutor.execute()
public void execute(ClientTransaction transaction) {
final IBinder token = transaction.getActivityToken();
log("Start resolving transaction for client: " + mTransactionHandler + ", token: " + token);
executeCallbacks(transaction);
executeLifecycleState(transaction);
mPendingActions.clear();
log("End resolving transaction");
}
说明:关注TransactionExecutor#executeCallbacks()方法
public void executeCallbacks(ClientTransaction transaction) {
...
for (int i = 0; i < size; ++i) {
final ClientTransactionItem item = callbacks.get(i);
...
item.execute(mTransactionHandler, token, mPendingActions);
}
...
}
说明:此处item实为3.1节中的LaunchActivityItem
LaunchActivityItem#execute
@Override
public void execute(ClientTransactionHandler client, IBinder token,
PendingTransactionActions pendingActions) {
Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
ActivityClientRecord r = new ActivityClientRecord(token, mIntent, mIdent, mInfo,
mOverrideConfig, mCompatInfo, mReferrer, mVoiceInteractor, mState, mPersistentState,
mPendingResults, mPendingNewIntents, mIsForward,
mProfilerInfo, client);
// 此处
client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
}
说明:
此处client为ActivityThread, ActivityThread是ClientTransactionHandler 的实现类。
由此,进入ActivityThread#handleLaunchActivity流程
3.5 ActivityThread#handleLaunchActivity()
@Override
public Activity handleLaunchActivity(ActivityClientRecord r,
PendingTransactionActions pendingActions, Intent customIntent) {
...
final Activity a = performLaunchActivity(r, customIntent);
}
流程进入我们熟悉的performLaunchActivity方法:
其内部会实例一个activity,并调用其attatch方法,后续便是window的创建、添加过程。
到此,Activity的创建流程就结束了。