我们要思考1.Application是如何创建的
2.activity生命周期如何绑定的
在java中程序入口是main方法
public static void main(String[] args){
...
}
在Android中也一样，Android中的main方法在 ActivityThread
/**
* This manages the execution of the main thread in an
* application process, scheduling and executing activities,
* broadcasts, and other operations on it as the activity
* manager requests.
*
* {@hide}
*/
public final class ActivityThread extends ClientTransactionHandler {
}
我们看到ActivityThread继承于ClientTransactionHandler 进入该类我们看到是一个抽象类
public abstract class ClientTransactionHandler {
void scheduleTransaction()
void executeTransaction()
abstract TransactionExecutor getTransactionExecutor();
abstract void sendMessage(int what, Object obj);
//看到跟我们的生命周期有关系了
abstract void handleDestroyActivity()
abstract void handlePauseActivity()
abstract void handleResumeActivity()
abstract void handleStopActivity()
abstract void performRestartActivity()
...
}
我们再回到ActivityThread中去寻找main方法
public static void main(String[] args) {
...
//上面代码都省略
//发现Activity中的looper是在这里初始化的
Looper.prepareMainLooper();
...
//这里看到初始化ActivityThread,就是我们想要的
ActivityThread thread = new ActivityThread();
//这里执行attach方法
thread.attach(false, startSeq);
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");
}
我们跟进ActivityThread的Attach方法
private void attach(boolean system, long startSeq) {
sCurrentActivityThread = this;
mSystemThread = system;
if (!system) {
ViewRootImpl.addFirstDrawHandler(new Runnable() {
@Override
public void run() {
ensureJitEnabled();
}
});
android.ddm.DdmHandleAppName.setAppName("<pre-initialized>",
UserHandle.myUserId());
RuntimeInit.setApplicationObject(mAppThread.asBinder());
//这里发现初始化一个ActivityManagerService
final IActivityManager mgr = ActivityManager.getService();
try {
//调用attachApplication方法
mgr.attachApplication方法(mAppThread, startSeq);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
}
}
我们跟进ActivityManagerService类中的attachApplication方法
//首先我们看到该类继承于IActivityManager
public class ActivityManagerService extends IActivityManager.Stub
implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
@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);
}
}
@GuardedBy("this")
private final boolean attachApplicationLocked(IApplicationThread thread,
int pid, int callingUid, long startSeq) {
...
//
if (app.isolatedEntryPoint != null) {
// This is an isolated process which should just call an entry point instead of
// being bound to an application.
thread.runIsolatedEntryPoint(app.isolatedEntryPoint, app.isolatedEntryPointArgs);
} else if (app.instr != null) {
//这里IApplicationThread的实现类是ApplicationThread,
//ApplicationThread是ActivityThread的子类
thread.bindApplication(processName, appInfo, providers,
app.instr.mClass,
profilerInfo, app.instr.mArguments,
app.instr.mWatcher,
app.instr.mUiAutomationConnection, testMode,
mBinderTransactionTrackingEnabled, enableTrackAllocation,
isRestrictedBackupMode || !normalMode, app.persistent,
new Configuration(getGlobalConfiguration()), app.compat,
getCommonServicesLocked(app.isolated),
mCoreSettingsObserver.getCoreSettingsLocked(),
buildSerial, isAutofillCompatEnabled);
} else {
thread.bindApplication(processName, appInfo, providers, null, profilerInfo,
null, null, null, testMode,
mBinderTransactionTrackingEnabled, enableTrackAllocation,
isRestrictedBackupMode || !normalMode, app.persistent,
new Configuration(getGlobalConfiguration()), app.compat,
getCommonServicesLocked(app.isolated),
mCoreSettingsObserver.getCoreSettingsLocked(),
buildSerial, isAutofillCompatEnabled);
}
// See if the top visible activity is waiting to run in this process...
if (normalMode) {
try {
//这个类
if (mStackSupervisor.attachApplicationLocked(app)) {
didSomething = true;
}
} catch (Exception e) {
Slog.wtf(TAG, "Exception thrown launching activities in " + app, e);
badApp = true;
}
}
}
}
> 这里我们发现有两个分支 1.thread.bindApplication() 2.mStackSupervisor.attachApplicationLocked(app) 我们先跟进第一个
我们去ActivityThread中寻找bindApplication方法
public final void bindApplication(String processName, ApplicationInfo appInfo,
List<ProviderInfo> providers, ComponentName instrumentationName,
ProfilerInfo profilerInfo, Bundle instrumentationArgs,
IInstrumentationWatcher instrumentationWatcher,
IUiAutomationConnection instrumentationUiConnection, int debugMode,
boolean enableBinderTracking, boolean trackAllocation,
boolean isRestrictedBackupMode, boolean persistent, Configuration config,
CompatibilityInfo compatInfo, Map services, Bundle coreSettings,
String buildSerial, boolean autofillCompatibilityEnabled) {
...
AppBindData data = new AppBindData();
data.processName = processName;
data.appInfo = appInfo;
data.providers = providers;
data.instrumentationName = instrumentationName;
data.instrumentationArgs = instrumentationArgs;
data.instrumentationWatcher = instrumentationWatcher;
data.instrumentationUiAutomationConnection = instrumentationUiConnection;
data.debugMode = debugMode;
data.enableBinderTracking = enableBinderTracking;
data.trackAllocation = trackAllocation;
data.restrictedBackupMode = isRestrictedBackupMode;
data.persistent = persistent;
data.config = config;
data.compatInfo = compatInfo;
data.initProfilerInfo = profilerInfo;
data.buildSerial = buildSerial;
data.autofillCompatibilityEnabled = autofillCompatibilityEnabled;
////这里发现发送了消息BIND_APPLICATION，跟进去
sendMessage(H.BIND_APPLICATION, data);
}
//发现是个handler类
class H extends Handler {
public void handleMessage(Message msg) {
if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
switch (msg.what) {
case BIND_APPLICATION:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "bindApplication");
AppBindData data = (AppBindData)msg.obj;
//在这里收到消息处理，继续跟进
handleBindApplication(data);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
}
}
}
private void handleBindApplication(AppBindData data) {
...
//然后我们找关键代码，找啊找
//发现很多都是获取包名啊等一些info,继续往下
else {
//返现初始化一个Instrumentation的类
mInstrumentation = new Instrumentation();
mInstrumentation.basicInit(this);
}
// Do this after providers, since instrumentation tests generally start their
// test thread at this point, and we don't want that racing.
try {
//该方法创建本身
mInstrumentation.onCreate(data.instrumentationArgs);
}
try {
//在这里点击去，发现去创建application
mInstrumentation.callApplicationOnCreate(app);
}
}
到这我们发现创建完成application的oncreate方法，我们先整理下流程
- ActivityThread的main方法发现 new ActivityThread后，调用attach方法
- 创建ActivityManagerService final IActivityManager mgr = ActivityManager.getService(); 调用attachApplication方法
- 调用attachApplicationLocked方法
- thread.bindApplication方法 和 mStackSupervisor.attachApplicationLocked(app)方法(这里IApplicationThread的实现ApplicationThread,ApplicationThread的父类是ActivityThread，最终回到ActivityThread)
- 在ActivityThread的bindApplication方法中发送BIND_APPLICATION消息
- 在handler消息接收处handleBindApplication(data);
- mInstrumentation.callApplicationOnCreate(app);完成Application的oncreate初始化
接着进行第二条路mStackSupervisor.attachApplicationLocked，应该可以猜到是去绑定Activity的生命周期 继续回到ActivityManagerService中的attachApplicationLocked方法
//这里跟进去
if (mStackSupervisor.attachApplicationLocked(app)) {
didSomething = true;
}
发现我们来到ActivityStackSuperVisor类中
boolean attachApplicationLocked(ProcessRecord app) throws RemoteException {
...
//寻找关键代码
if (realStartActivityLocked(activity, app,
top == activity /* andResume */, true /* checkConfig */)) {
didSomething = true;
}
}
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);
//这里用addCallBack传进来一个LaunchActivityItem
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));
// Set desired final state.
final ActivityLifecycleItem lifecycleItem;
if (andResume) {
//ResumeActivityItem
lifecycleItem = ResumeActivityItem.obtain(mService.isNextTransitionForward());
} else {
//PauseActivityItem
lifecycleItem = PauseActivityItem.obtain();
}
//这里通过setLifecycleStateRequest传进去ResumeActivityItem、PauseActivityItem
clientTransaction.setLifecycleStateRequest(lifecycleItem);
//这里mService为ActivityManagerService
//获取到ClientLifeCycleManager
// Schedule transaction.
mService.getLifecycleManager().scheduleTransaction(clientTransaction);
}
继续跟进
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();
}
}
进入ClientTransaction类找到schedule方法
public void schedule() throws RemoteException {
//这里mClient又是IApplicationThread的实现类那我们直接取ActivityThread方法中找
mClient.scheduleTransaction(this);
}
回到ActivityThread
@Override
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
//跟进发现跳转到ActivityThread的父类ClientTransactionHandler中
ActivityThread.this.scheduleTransaction(transaction);
}
}
public abstract class ClientTransactionHandler {
// Schedule phase related logic and handlers.
/** Prepare and schedule transaction for execution. */
void scheduleTransaction(ClientTransaction transaction) {
transaction.preExecute(this);
//这里发现发送了个handler消息EXECUTE_TRANSACTION
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;
发现在TransactionExecutor中调用了execute方法，我们跟进TransactionExecutor类
public class TransactionExecutor {
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");
}
//跟进executeCallbacks(transaction)
/** Cycle through all states requested by callbacks and execute them at proper times. */
@VisibleForTesting
public void executeCallbacks(ClientTransaction transaction) {
//这里获取ClientTransaction的getCallbacks方法获取的就是上面的LaunchActivityItem
final List<ClientTransactionItem> callbacks = transaction.getCallbacks();
if (callbacks == null) {
// No callbacks to execute, return early.
return;
}
log("Resolving callbacks");
final IBinder token = transaction.getActivityToken();
ActivityClientRecord r = mTransactionHandler.getActivityClient(token);
// In case when post-execution state of the last callback matches the final state requested
// for the activity in this transaction, we won't do the last transition here and do it when
// moving to final state instead (because it may contain additional parameters from server).
final ActivityLifecycleItem finalStateRequest = transaction.getLifecycleStateRequest();
final int finalState = finalStateRequest != null ? finalStateRequest.getTargetState()
: UNDEFINED;
// Index of the last callback that requests some post-execution state.
final int lastCallbackRequestingState = lastCallbackRequestingState(transaction);
final int size = callbacks.size();
for (int i = 0; i < size; ++i) {
final ClientTransactionItem item = callbacks.get(i);
log("Resolving callback: " + item);
final int postExecutionState = item.getPostExecutionState();
final int closestPreExecutionState = mHelper.getClosestPreExecutionState(r,
item.getPostExecutionState());
if (closestPreExecutionState != UNDEFINED) {
cycleToPath(r, closestPreExecutionState);
}
//这里调用LaunchActivityItem中的方法，跟进去
item.execute(mTransactionHandler, token, mPendingActions);
item.postExecute(mTransactionHandler, token, mPendingActions);
if (r == null) {
// Launch activity request will create an activity record.
r = mTransactionHandler.getActivityClient(token);
}
if (postExecutionState != UNDEFINED && r != null) {
// Skip the very last transition and perform it by explicit state request instead.
final boolean shouldExcludeLastTransition =
i == lastCallbackRequestingState && finalState == postExecutionState;
cycleToPath(r, postExecutionState, shouldExcludeLastTransition);
}
}
}
}
我们进入LaunchActivityItem类中
@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为ActivityThread的父类ClientTransactionHandler
client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
}
那我们直接去ClientTransactionHandler的实现类ActivityThread中寻找handleLaunchActivity
@Override
public Activity handleLaunchActivity(ActivityClientRecord r,
PendingTransactionActions pendingActions, Intent customIntent) {
...
//还是寻找关键代码
final Activity a = performLaunchActivity(r, customIntent);
}
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
...
//这里可以看到有activity的创建
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);
}
}
//这里看到我们熟悉的callActivityOnCreate,跟进去发现就是Activity的oncreate方法
if (r.isPersistable()) {
mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
} else {
mInstrumentation.callActivityOnCreate(activity, r.state);
}
}
到这我们走完TransactionExecutor类中的executeCallbacks，接着我们跟进executeLifecycleState方法，同理该方法获取的是ResumeActivityItem
private void executeLifecycleState(ClientTransaction transaction) {
//获取ResumeActivityItem
final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();
}
进入ResumeActivityItem类然后我们跟进ActivityThread的handleResumeActivity()方法
@Override
public void handleResumeActivity(IBinder token, boolean finalStateRequest, boolean isForward,
String reason) {
// If we are getting ready to gc after going to the background, well
// we are back active so skip it.
unscheduleGcIdler();
mSomeActivitiesChanged = true;
//这里我们发现跟handleLaunchActivity一样performResumeActivity继续跟进
// TODO Push resumeArgs into the activity for consideration
final ActivityClientRecord r = performResumeActivity(token, finalStateRequest, reason);
...
}
public ActivityClientRecord performResumeActivity(IBinder token, boolean finalStateRequest,
String reason) {
try {
r.activity.onStateNotSaved();
r.activity.mFragments.noteStateNotSaved();
checkAndBlockForNetworkAccess();
if (r.pendingIntents != null) {
deliverNewIntents(r, r.pendingIntents);
r.pendingIntents = null;
}
if (r.pendingResults != null) {
deliverResults(r, r.pendingResults, reason);
r.pendingResults = null;
}
//发现activity的resume方法
r.activity.performResume(r.startsNotResumed, reason);
r.state = null;
r.persistentState = null;
r.setState(ON_RESUME);
} catch (Exception e) {
if (!mInstrumentation.onException(r.activity, e)) {
throw new RuntimeException("Unable to resume activity "
+ r.intent.getComponent().toShortString() + ": " + e.toString(), e);
}
}
}
到此我们找到了我们Activity的生命周期 上面我们在ActivityManagerService的attachApplicationLocked方法中通过thread.bindApplication方法一步步走过了创建application流程 接着下面的mStackSupervisor.attachApplicationLocked(app)方法开始初始化activity及相关的生命周期
- 进入StackSupervisor类中的attachApplicationLocked方法
- 该方法创建activityStack栈并且开启activity,通过realStartActivityLocked方法
- 在该方法中通过clientTransaction.addCallback添加进LaunchActivityItem，通过setLifecycleStateRequest添加进ResumeActivityItem或者PauseActivityItem，并通过mService.getLifecycleManager().scheduleTransaction(clientTransaction)方法传给ClientTransaction
- 在ClientTransaction类中调用schedule()方法，然后调用ActivityThread中的scheduleTransaction方法
- 在该方法中发送消息EXECUTE_TRANSACTION，到TransactionExecutor的execute方法中，该方法有两个方法executeCallbacks(transaction)和executeLifecycleState(transaction)
- 通过executeCallbacks获取LaunchActivityItem，最终调用ActivityThread方法中的handleLaunchActivity方法，在performLaunchActivity方法中mInstrumentation.callActivityOnCreate方法最终调用到Activity的oncreate方法
- 同理通过executeLifecycleState获取ResumeActivityItem,最终调用ActivityThread方法中的handleResumeActivity方法，在PerformResumeActivity方法中调用r.activity.performResume方法最终调用Activity的onResume方法
