有错误之处欢迎指正批评
源码基于9.0
理论基础
-
每个Android App都在一个独立空间里, 意味着其运行在一个单独的进程中, 拥有自己的VM, 被系统分配一个唯一的user ID。
-
当我们从桌面点击一个应用图标的启动一个App的时候，是从一个App启动另一个App。这中间就涉及了进程间通信。
-
Launcher是Android系统启动后，加载的第一个程序，是其他应用程序的入口。也可以简单的理解为我们看到的Android桌面。
-
Activity： 就是一个Java对象，它会被创建，同时也会被垃圾回收销毁，只不过它受AMS(ActivityManagerService)管理，所以它才有生命周期。
-
ActivityResult：一个活动执行结果返回到原始活动的描述。
-
AMS - ActivityManagerService：Android系统服务，Android管理的服务端，用于管理Activity的各种行为，控制Activity的生命周期，派发消息事件，低内存管理等等。实现了IBinder接口，可以用于进程间的通信。
-
ActivityThread ：ActivityThread用于管理一个应用进程内的主线程的执行，调度和执行activities，broadcasts和其他activity manager的请求操作。
-
ApplicationThread：ApplicationThread是ActivityThread的内部类，继承了IApplicationThread.Stub。是Activity整个框架中客户端(ActivityThread)和服务端(AMS)通信的接口。
-
Instrumentation：用于监控程序和系统之间的交互操作。
-
PackageManagerService：是Android系统中最常用的服务之一。它负责系统中Package的管理，应用程序的安装、卸载、信息查询等。这只是一个很笼统的说法。
整个流程可以大致分为两部分
一 从点击桌面应用图标到Application的onCreate
先来一个大概的时序图
从点击桌面应用图标到Application的onCreate.png
点击桌面图标，Launcher会调用onClick(View v)方法，最终内部会调用startActivitySafely(View v, Intent intent, ItemInfo item)方法。
Launcher类
public class Launcher extends BaseActivity
implements LauncherExterns, View.OnClickListener, OnLongClickListener,
LauncherModel.Callbacks, View.OnTouchListener, LauncherProviderChangeListener,
AccessibilityManager.AccessibilityStateChangeListener {
//...
}
Launcher的startActivitySafely方法精简版
void startActivitySafely(Intent intent) {
//在一个新的任务栈中启动Activity
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
try {
//1. 调用Activity的startActivity方法
startActivity(intent, optsBundle);
}
//...
}
这里注意一点：Launcher是如何获得我们要启动的应用的信息的呢？首先，系统在启动时会启动一个叫做PackageManagerService的管理服务，并且通过它来安装系统中的应用程序，这个过程中，PackageManagerService会对应用程序的配置文件AndroidManifest.xml进行解析，从而得到程序里面的组件信息（包括Activity、Service、Broadcast等），然后PackageManagerService去查询所有的action为android.intent.action.MAIN并且category为“android.intent.category.LAUNCHER”的Activity（通常就是我们的MainActivity），然后为每一个应用程序创建一个快捷图标，并把程序信息与之关联。所以Launcher可以通过PackageManagerService来获取我们的MainActivity的相关信息了。
Activity的startActivity方法
@Override
public void startActivity(Intent intent, @Nullable Bundle options) {
if (options != null) {
startActivityForResult(intent, -1, options);
} else {
//1. 传入小于0的requestCode表示不需要返回结果
startActivityForResult(intent, -1);
}
}
- 第二个参数requestCode传入小于0的值表示不需要返回结果。
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode) {
startActivityForResult(intent, requestCode, null);
}
Activity的startActivityForResult方法精简版
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
@Nullable Bundle options) {
if (mParent == null) {//Activity的mParent都为null
options = transferSpringboardActivityOptions(options);
//1.
Instrumentation.ActivityResult ar =
mInstrumentation.execStartActivity(
this, mMainThread.getApplicationThread(), mToken, this,
intent, requestCode, options);
if (ar != null) {
mMainThread.sendActivityResult(//发送结果，即上一个onActivityResult会被调用
mToken, mEmbeddedID, requestCode, ar.getResultCode(),
ar.getResultData());
}
if (requestCode >= 0) {
mStartedActivity = true;
}
cancelInputsAndStartExitTransition(options);
}
//...
}
- 内部调用mInstrumentation.execStartActivity来启动Activity，mInstrumentation类型为Instrumentation。
Instrumentation.ActivityResult ar =
mInstrumentation.execStartActivity(
this, mMainThread.getApplicationThread(), mToken, this,
intent, requestCode, options);
Instrumentation的execStartActivity方法精简版
/**
* 执行应用程序发出的startActivity调用
*
* @param who 一个Context对象，表示是谁要启动Activity.
* @param contextThread 参数who所在的主线程。
*
* @param token 参数who的一个系统内部标志，用来标记是谁正在启动activity，可能为null。
*
* @param target 感觉这个参数和参数who代表的是一个意思。表示哪个activity正在执行启动activity的操作; 如果这个调用不是由一个activity发起的，target可能为null。
* @param intent 要被启动的Intent。
* @param requestCode 请求码，小于0表示不需要返回结果。我们上面传入是-1
*
* @param options 附加选项。
*
* @return 默认返回 null.
*
*/
public ActivityResult execStartActivity(
Context who, IBinder contextThread, IBinder token, Activity target,
Intent intent, int requestCode, Bundle options) {
//contextThread转成一个IApplicationThread对象，这个对象
IApplicationThread whoThread = (IApplicationThread) contextThread;
//...
try {
//...
//1. 调用ActivityManagerService的startActivity方法
int result = ActivityManager.getService()
.startActivity(whoThread, who.getBasePackageName(), intent,
intent.resolveTypeIfNeeded(who.getContentResolver()),
token, target != null ? target.mEmbeddedID : null,
requestCode, 0, null, options);
//2. 检查执行结果
checkStartActivityResult(result, intent);
} catch (RemoteException e) {
throw new RuntimeException("Failure from system", e);
}
//默认返回null
return null;
}
1. 调用ActivityManagerService的startActivity方法，这里才是真正打开activity的地方。
ActivityManagerService类精简版
public class ActivityManagerService extends IActivityManager.Stub
implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
//...
private final ActivityStartController mActivityStartController;
//...
@Override
public final int startActivity(IApplicationThread caller, String callingPackage,
Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
int startFlags, ProfilerInfo profilerInfo, Bundle bOptions) {
return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
resultWho, requestCode, startFlags, profilerInfo, bOptions,
UserHandle.getCallingUserId());
}
public final int startActivityAsUser(IApplicationThread caller, String callingPackage,
Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId,
boolean validateIncomingUser) {
enforceNotIsolatedCaller("startActivity");
userId = mActivityStartController.checkTargetUser(userId, validateIncomingUser,
Binder.getCallingPid(), Binder.getCallingUid(), "startActivityAsUser");
// TODO: Switch to user app stacks here.
return mActivityStartController.obtainStarter(intent, "startActivityAsUser")
.setCaller(caller)
.setCallingPackage(callingPackage)
.setResolvedType(resolvedType)
.setResultTo(resultTo)
.setResultWho(resultWho)
.setRequestCode(requestCode)
.setStartFlags(startFlags)
.setProfilerInfo(profilerInfo)
.setActivityOptions(bOptions)
.setMayWait(userId)//1.
.execute();//2.
}
}
mActivityStartController.obtainStarter(intent, "startActivityAsUser")返回的是一个ActivityStarter对象。
ActivityStarter类的setMayWait方法
ActivityStarter setMayWait(int userId) {
//mRequest.mayWait赋值为true
mRequest.mayWait = true;
mRequest.userId = userId;
return this;
}
int execute() {
try {
// TODO(b/64750076): Look into passing request directly to these methods to allow
// for transactional diffs and preprocessing.
if (mRequest.mayWait) {//mRequest.mayWait为true
//调用startActivityMayWait方法
return startActivityMayWait(mRequest.caller, mRequest.callingUid,
mRequest.callingPackage, mRequest.intent, mRequest.resolvedType,
mRequest.voiceSession, mRequest.voiceInteractor, mRequest.resultTo,
mRequest.resultWho, mRequest.requestCode, mRequest.startFlags,
mRequest.profilerInfo, mRequest.waitResult, mRequest.globalConfig,
mRequest.activityOptions, mRequest.ignoreTargetSecurity, mRequest.userId,
mRequest.inTask, mRequest.reason,
mRequest.allowPendingRemoteAnimationRegistryLookup);
}
//...
} finally {
onExecutionComplete();
}
}
ActivityStarter类startActivityMayWait方法精简版
private int startActivityMayWait(IApplicationThread caller, int callingUid,
String callingPackage, Intent intent, String resolvedType,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
IBinder resultTo, String resultWho, int requestCode, int startFlags,
ProfilerInfo profilerInfo, WaitResult outResult,
Configuration globalConfig, SafeActivityOptions options, boolean ignoreTargetSecurity,
int userId, TaskRecord inTask, String reason,
boolean allowPendingRemoteAnimationRegistryLookup) {
//...
// Save a copy in case ephemeral needs it
final Intent ephemeralIntent = new Intent(intent);
// Don't modify the client's object!
intent = new Intent(intent);
//...
ResolveInfo rInfo = mSupervisor.resolveIntent(intent, resolvedType, userId,
0 /* matchFlags */,
computeResolveFilterUid(
callingUid, realCallingUid, mRequest.filterCallingUid));
//...
// Collect information about the target of the Intent.
ActivityInfo aInfo = mSupervisor.resolveActivity(intent, rInfo, startFlags, profilerInfo);
//...
//调用startActivity方法
int res = startActivity(caller, intent, ephemeralIntent, resolvedType, aInfo, rInfo,
voiceSession, voiceInteractor, resultTo, resultWho, requestCode, callingPid,
callingUid, callingPackage, realCallingPid, realCallingUid, startFlags, options,
ignoreTargetSecurity, componentSpecified, outRecord, inTask, reason,
allowPendingRemoteAnimationRegistryLookup);
//...
return res;
}
private int startActivity(IApplicationThread caller, Intent intent, Intent ephemeralIntent,
String resolvedType, ActivityInfo aInfo, ResolveInfo rInfo,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
IBinder resultTo, String resultWho, int requestCode, int callingPid, int callingUid,
String callingPackage, int realCallingPid, int realCallingUid, int startFlags,
SafeActivityOptions options, boolean ignoreTargetSecurity, boolean componentSpecified,
ActivityRecord[] outActivity, TaskRecord inTask, String reason,
boolean allowPendingRemoteAnimationRegistryLookup) {
//...
mLastStartActivityResult = startActivity(caller, intent, ephemeralIntent, resolvedType,
aInfo, rInfo, voiceSession, voiceInteractor, resultTo, resultWho, requestCode,
callingPid, callingUid, callingPackage, realCallingPid, realCallingUid, startFlags,
options, ignoreTargetSecurity, componentSpecified, mLastStartActivityRecord,
inTask, allowPendingRemoteAnimationRegistryLookup);
//...
return getExternalResult(mLastStartActivityResult);
}
private int startActivity(IApplicationThread caller, Intent intent, Intent ephemeralIntent,
String resolvedType, ActivityInfo aInfo, ResolveInfo rInfo,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
IBinder resultTo, String resultWho, int requestCode, int callingPid, int callingUid,
String callingPackage, int realCallingPid, int realCallingUid, int startFlags,
SafeActivityOptions options,
boolean ignoreTargetSecurity, boolean componentSpecified, ActivityRecord[] outActivity,
TaskRecord inTask, boolean allowPendingRemoteAnimationRegistryLookup) {
//...
return startActivity(r, sourceRecord, voiceSession, voiceInteractor, startFlags,
true /* doResume */, checkedOptions, inTask, outActivity);
}
private int startActivity(final ActivityRecord r, ActivityRecord sourceRecord,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
ActivityRecord[] outActivity) {
//...
result = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor,
startFlags, doResume, options, inTask, outActivity);
//...
postStartActivityProcessing(r, result, mTargetStack);
return result;
}
ActivityStarter.startActivityMayWait方法中调用多个startActivity重载方法后会调用到一个比较重要的方法startActivityUnchecked。这个方法里会根据启动标志位和Activity启动模式来决定如何启动一个Activity。
// Note: This method should only be called from {@link startActivity}.
private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
ActivityRecord[] outActivity) {
//...
//这个方法的作用目前不知道，猜测是把要启动的activity放在栈顶
mTargetStack.startActivityLocked(mStartActivity, topFocused, newTask, mKeepCurTransition,
mOptions);
//...
if (mDoResume) {
//...
mSupervisor.resumeFocusedStackTopActivityLocked(mTargetStack, mStartActivity,
mOptions);
//...
}
return START_SUCCESS;
}
无论以何种模式启动最终都会调用ActivityStackSupervisor.resumeFocusedStackTopActivityLocked方法。
ActivityStackSupervisor的resumeFocusedStackTopActivityLocked方法精简版
boolean resumeFocusedStackTopActivityLocked(
ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
//...
return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
//...
}
ActivityStack 类resumeTopActivityUncheckedLocked方法精简版
boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
//...
boolean result = false;
//...
result = resumeTopActivityInnerLocked(prev, options);
//...
return result;
}
private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
//...
//1. 暂停其他Activity
boolean pausing = mStackSupervisor.pauseBackStacks(userLeaving, next, false);
if (mResumedActivity != null) {
pausing |= startPausingLocked(userLeaving, false, next, false);
}
//...
//2. 启动Activity
mStackSupervisor.startSpecificActivityLocked(next, true, true);
//...
return true;
}
在ActivityStack.resumeTopActivityInnerLocked方法中会去判断是否有Activity处于resume状态，如果有的话会先让Activity执行pause过程，然后再执行startSpecificActivityLocked方法启动要启动的Activity。
直接看ActivityStackSupervisor的startSpecificActivityLocked方法
void startSpecificActivityLocked(ActivityRecord r,
boolean andResume, boolean checkConfig) {
//如果要启动的Activity的应用已经在运行了
ProcessRecord app = mService.getProcessRecordLocked(r.processName,
r.info.applicationInfo.uid, true);
getLaunchTimeTracker().setLaunchTime(r);
//如果要启动的Activity的应用已经在运行了
if (app != null && app.thread != null) {
//...
//1.
realStartActivityLocked(r, app, andResume, checkConfig);
return;
}
//2. 没有启动则调用ActivityManagerService.startProcessLocked方法创建新的进程处理
mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,
"activity", r.intent.getComponent(), false, false, true);
}
ActivityManagerService.startProcessLocked方法
final ProcessRecord startProcessLocked(String processName,
ApplicationInfo info, boolean knownToBeDead, int intentFlags,
String hostingType, ComponentName hostingName, boolean allowWhileBooting,
boolean isolated, boolean keepIfLarge) {
return startProcessLocked(processName, info, knownToBeDead, intentFlags, hostingType,
hostingName, allowWhileBooting, isolated, 0 /* isolatedUid */, keepIfLarge,
null /* ABI override */, null /* entryPoint */, null /* entryPointArgs */,
null /* crashHandler */);
final ProcessRecord startProcessLocked(String processName, ApplicationInfo info,
boolean knownToBeDead, int intentFlags, String hostingType, ComponentName hostingName,
boolean allowWhileBooting, boolean isolated, int isolatedUid, boolean keepIfLarge,
String abiOverride, String entryPoint, String[] entryPointArgs, Runnable crashHandler) {
//...
final boolean success = startProcessLocked(app, hostingType, hostingNameStr, abiOverride);
//...
return success ? app : null;
}
private final boolean startProcessLocked(ProcessRecord app,
String hostingType, String hostingNameStr, String abiOverride) {
return startProcessLocked(app, hostingType, hostingNameStr,
false /* disableHiddenApiChecks */, abiOverride);
}
private final boolean startProcessLocked(ProcessRecord app, String hostingType,
String hostingNameStr, boolean disableHiddenApiChecks, String abiOverride) {
//...
//1.这里注意一下，后面新的进程启动的时候会加载这个类
final String entryPoint = "android.app.ActivityThread";
return startProcessLocked(hostingType, hostingNameStr, entryPoint, app, uid, gids,
runtimeFlags, mountExternal, seInfo, requiredAbi, instructionSet, invokeWith,
startTime);
//...
}
ActivityManagerService的startProcessLocked方法
private boolean startProcessLocked(String hostingType, String hostingNameStr, String entryPoint,
ProcessRecord app, int uid, int[] gids, int runtimeFlags, int mountExternal,
String seInfo, String requiredAbi, String instructionSet, String invokeWith,
long startTime) {
//...
final ProcessStartResult startResult = startProcess(app.hostingType, entryPoint,
app, app.startUid, gids, runtimeFlags, mountExternal, app.seInfo,
requiredAbi, instructionSet, invokeWith, app.startTime);
//...
return app.pid > 0;
}
private ProcessStartResult startProcess(String hostingType, String entryPoint,
ProcessRecord app, int uid, int[] gids, int runtimeFlags, int mountExternal,
String seInfo, String requiredAbi, String instructionSet, String invokeWith,
long startTime) {
//...
startResult = Process.start(entryPoint,
app.processName, uid, uid, gids, runtimeFlags, mountExternal,
app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,
app.info.dataDir, invokeWith,
new String[] {PROC_START_SEQ_IDENT + app.startSeq});
return startResult;
}
ActivityManagerService.startProcessLocked方法经过多次跳转最终会通过Process.start方法来为应用创建进程。
Process的start方法
public static final ProcessStartResult start(final String processClass,
final String niceName,
int uid, int gid, int[] gids,
int runtimeFlags, int mountExternal,
int targetSdkVersion,
String seInfo,
String abi,
String instructionSet,
String appDataDir,
String invokeWith,
String[] zygoteArgs) {
return zygoteProcess.start(processClass, niceName, uid, gid, gids,
runtimeFlags, mountExternal, targetSdkVersion, seInfo,
abi, instructionSet, appDataDir, invokeWith, zygoteArgs);
}
经过一步步调用，可以发现其最终调用了Zygote并通过socket通信的方式让Zygote进程fork出一个新的进程，并根据传递的”android.app.ActivityThread”字符串，反射出该对象并执行ActivityThread的main方法对其进行初始化。
ActivityThread类的main方法,感觉到这里已经隐隐约约的看到了胜利的曙光
public static void main(String[] args) {
//...
Process.setArgV0("<pre-initialized>");
//1.
Looper.prepareMainLooper();
//...
// 初始化 ActivityThread对象
ActivityThread thread = new ActivityThread();
//2. 连接当前进程和Application
thread.attach(false, startSeq);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
//
//3.
Looper.loop();
}
ActivityThread的attach方法
private void attach(boolean system, long startSeq) {
//...
if (!system) {
//...
//获取ActivityManagerService对象
final IActivityManager mgr = ActivityManager.getService();
try {
//1. 调用ActivityManagerService的attachApplication方法
mgr.attachApplication(mAppThread, startSeq);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
//...
}
//...
}
ActivityManagerService的attachApplication方法
@Override
public final void attachApplication(IApplicationThread thread, long startSeq) {
synchronized (this) {
//...
attachApplicationLocked(thread, callingPid, callingUid, startSeq);
//...
}
}
ActivityManagerService的attachApplicationLocked方法
private final boolean attachApplicationLocked(IApplicationThread thread,
int pid, int callingUid, long startSeq) {
//...
//1. 调用ApplicationThread的bindApplication方法
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);
// 要启动的Activity等待在这个进程中运行
if (normalMode) {
try {
//2. 调用ActivityStackSupervisor的attachApplicationLocked方法
if (mStackSupervisor.attachApplicationLocked(app)) {
didSomething = true;
}
} catch (Exception e) {
Slog.wtf(TAG, "Exception thrown launching activities in " + app, e);
badApp = true;
}
}
//...
return true;
}
1. 调用ApplicationThread的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) {
//1.调用ActivityThread的sendMessage方法
sendMessage(H.BIND_APPLICATION, data);
}
ActivityThread的sendMessage方法内部是调用mH来发送消息的，mH是一个H类型的对象。H是ActivityThread的内部类，继承了Handler类。我们看一下H的handleMessage方法。
case BIND_APPLICATION:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "bindApplication");
AppBindData data = (AppBindData)msg.obj;
//1. 调用handleBindApplication方法
handleBindApplication(data);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
ActivityThread的handleBindApplication方法
private void handleBindApplication(AppBindData data) {
//...
//设置应用的名字
Process.setArgV0(data.processName);
//创建Instrumentation对象
mInstrumentation = new Instrumentation();
Application app;
//注释1处
app = data.info.makeApplication(data.restrictedBackupMode, null);
mInitialApplication = app;
//...
//注释2处启动app
mInstrumentation.callApplicationOnCreate(app);
//...
}
注释1处，data.info是一个LoadedApk类型的对象，我们看一下LoadedApk的makeApplication方法。
public Application makeApplication(boolean forceDefaultAppClass,
Instrumentation instrumentation) {
//如果mApplication不为空，直接返回mApplication,这个mApplication就是我们调用getApplicationContext返回的
if (mApplication != null) {
return mApplication;
}
Application app = null;
//获取appClass
String appClass = mApplicationInfo.className;
if (forceDefaultAppClass || (appClass == null)) {
appClass = "android.app.Application";
}
try {
java.lang.ClassLoader cl = getClassLoader();
//在这里创建了应用的context
ContextImpl appContext = ContextImpl.createAppContext(mActivityThread, this);
//注释1处，创建Application对象
app = mActivityThread.mInstrumentation.newApplication(
cl, appClass, appContext);
appContext.setOuterContext(app);
}
mActivityThread.mAllApplications.add(app);
//把app赋值给mApplication
mApplication = app;
//我们在这里传入的instrumentation是null
if (instrumentation != null) {
try {
instrumentation.callApplicationOnCreate(app);
}
}
//...
return app;
}
在makeApplication方法中的注释1处，调用了Instrumentation的newApplication方法。
public Application newApplication(ClassLoader cl, String className, Context context)
throws InstantiationException, IllegalAccessException,
ClassNotFoundException {
//创建了Application对象
Application app = getFactory(context.getPackageName())
.instantiateApplication(cl, className);
//注释1处，调用Application的attach方法。之后我们就可以获取应用的context了。
app.attach(context);
return app;
}
在handleBindApplication方法的注释2处调用了Instrumentation的callApplicationOnCreate方法
public void callApplicationOnCreate(Application app) {
//到这里app已经启动了
app.onCreate();
}
到这里Application的onCreate方法已经被调用了，第一部分已经完毕。
二 MainActivity的启动过程
先来一张大概的时序图
MainActivity的启动流程.png
在上面的分析中，我们知道ActivityManagerService的attachApplicationLocked方法中会调用ActivityStackSupervisor的attachApplicationLocked方法
ActivityManagerService的attachApplicationLocked方法
boolean attachApplicationLocked(ProcessRecord app) throws RemoteException {
//...
try {
if (realStartActivityLocked(activity, app,top == activity, true)) {
didSomething = true;
}
}
//...
return didSomething;
}
ActivityStackSupervisor的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);
//1. 添加一个LaunchActivityItem类型的callBack
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;
lifecycleItem = ResumeActivityItem.obtain(mService.isNextTransitionForward());
//设置生命周期状态请求为ResumeActivityItem
clientTransaction.setLifecycleStateRequest(lifecycleItem);
// Schedule transaction.
mService.getLifecycleManager().scheduleTransaction(clientTransaction);
//...
return true;
}
在ActivityStackSupervisor.realStartActivityLocked方法中为ClientTransaction对象添加LaunchActivityItem的callback，然后设置当前的生命周期状态请求为ResumeActivityItem，最后调用ClientLifecycleManager.scheduleTransaction方法执行。
ClientLifecycleManager的scheduleTransaction方法
void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
//...
transaction.schedule();
//...
}
ClientTransaction的schedule方法
public void schedule() throws RemoteException {
//这里的mClient就是一个ApplicationThread对象
mClient.scheduleTransaction(this);
}
内部调用了ActivityThread的scheduleTransaction方法。这个方法是继承自ClientTransactionHandler类
void scheduleTransaction(ClientTransaction transaction) {
transaction.preExecute(this);
//发送消息
sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}
发送消息最终是由ActivityThread中的mH对象发送的，mH的类型是H，H是ActivityThread的一个内部类，H继承了Handler类。
H 的handleMessage方法
case EXECUTE_TRANSACTION:
final ClientTransaction transaction = (ClientTransaction) msg.obj;
mTransactionExecutor.execute(transaction);
break;
mTransactionExecutor的类型是TransactionExecutor
TransactionExecutor的execute方法
public void execute(ClientTransaction transaction) {
final IBinder token = transaction.getActivityToken();
log("Start resolving transaction for client: " + mTransactionHandler + ", token: " + token);
//1. 先执行callback
executeCallbacks(transaction);
//2. 执行生命周期状态请求
executeLifecycleState(transaction);
mPendingActions.clear();
log("End resolving transaction");
}
- 先执行callback
public void executeCallbacks(ClientTransaction transaction) {
//...
//调用ClientTransactionItem的execute方法，还记得我们传入的是LaunchActivityItem。
item.execute(mTransactionHandler, token, mPendingActions);
//...
}
LaunchActivityItem的execute方法
@Override
public void execute(ClientTransactionHandler client, IBinder token,
PendingTransactionActions pendingActions) {
//调用ClientTransactionHandler的handleLaunchActivity
client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
}
ClientTransactionHandler 是一个抽象类，ActivityThread继承了ClientTransactionHandler 并重写了handleLaunchActivity方法
ActivityThread的handleLaunchActivity方法
@Override
public Activity handleLaunchActivity(ActivityClientRecord r,
PendingTransactionActions pendingActions, Intent customIntent) {
//1. 调用performLaunchActivity方法
final Activity a = performLaunchActivity(r, customIntent);
//...
return a;
}
ActivityThread的performLaunchActivity方法精简版，这个方法内部会执行Activity的attach方法和onCreate方法
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
//...
//构建Activity的上下文
ContextImpl appContext = createBaseContextForActivity(r);
//...
//创建Activity实例
Activity activity = null;
try {
java.lang.ClassLoader cl = appContext.getClassLoader();
activity = mInstrumentation.newActivity(
cl, component.getClassName(), r.intent);
//...
} catch (Exception e) {
//...
}
try {
//1.获取Application对象
Application app = r.packageInfo.makeApplication(false, mInstrumentation);
//...
if (activity != null) {
//...
appContext.setOuterContext(activity);
//2. activity调用attach方法
activity.attach(appContext, this, getInstrumentation(), r.token,
r.ident, app, r.intent, r.activityInfo, title, r.parent,
r.embeddedID, r.lastNonConfigurationInstances, config,
r.referrer, r.voiceInteractor, window, r.configCallback);
//...
//3. 调用Activity的onCreate方法
mInstrumentation.callActivityOnCreate(activity, r.state);
//...
// 这时候Activity的状态已经是ON_CREATE
r.setState(ON_CREATE);
// 4. 将ActivityRecord对象保存在ActivityThread的mActivities中
mActivities.put(r.token, r);
} catch (SuperNotCalledException e) {
throw e;
} catch (Exception e) {
//...
}
return activity;
}
- Instrumentation的callActivityOnCreate方法
/**
* 执行调用Activity的onCreate方法
*
* @param activity The activity being created.
* @param icicle The previously frozen state (or null) to pass through to onCreate().
*/
public void callActivityOnCreate(Activity activity, Bundle icicle) {
prePerformCreate(activity);
//这个方法名看起来看起来有戏
activity.performCreate(icicle);
postPerformCreate(activity);
}
Activity的performCreate方法
final void performCreate(Bundle icicle, PersistableBundle persistentState) {
mCanEnterPictureInPicture = true;
restoreHasCurrentPermissionRequest(icicle);
if (persistentState != null) {
onCreate(icicle, persistentState);
} else {
//亲人啊，终于找到你了
onCreate(icicle);
}
mActivityTransitionState.readState(icicle);
mVisibleFromClient = !mWindow.getWindowStyle().getBoolean(
com.android.internal.R.styleable.Window_windowNoDisplay, false);
mFragments.dispatchActivityCreated();
mActivityTransitionState.setEnterActivityOptions(this, getActivityOptions());
}
现在Activity状态已经走到生命周期方法onCreate了，那么是怎么从onCreate到onResume的呢？
让我们回到ActivityStackSupervisor.realStartActivityLocked方法中，我们设置了onResume生命周期状态请求生命周期状态，最后调用ClientLifecycleManager.scheduleTransaction方法执行。
lifecycleItem = ResumeActivityItem.obtain(mService.isNextTransitionForward());
//设置OnResume生命周期状态请求
clientTransaction.setLifecycleStateRequest(lifecycleItem);
// Schedule transaction.
mService.getLifecycleManager().scheduleTransaction(clientTransaction);
所以在TransactionExecutor的execute方法中，我们执行完了callback，然后继续执行生命周期状态请求
public void execute(ClientTransaction transaction) {
final IBinder token = transaction.getActivityToken();
log("Start resolving transaction for client: " + mTransactionHandler + ", token: " + token);
//1. 先执行callback
executeCallbacks(transaction);
//2. 执行生命周期状态请求
executeLifecycleState(transaction);
mPendingActions.clear();
log("End resolving transaction");
}
TransactionExecutor的executeLifecycleState方法
private void executeLifecycleState(ClientTransaction transaction) {
//生命周期是onResume，lifecycleItem 是ResumeActivityItem对象
final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();
//...
//1. 我们当前状态是onCreate，所以需要先过渡到onStart
cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */);
// 2. ResumeActivityItem调用
lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
//...
}
private void cycleToPath(ActivityClientRecord r, int finish,
boolean excludeLastState) {
//...
performLifecycleSequence(r, path);
}
private void performLifecycleSequence(ActivityClientRecord r, IntArray path) {
//...
case ON_START:
mTransactionHandler.handleStartActivity(r, mPendingActions);
break;
//...
}
这个方法最终由ActivityThread执行handleStartActivity方法，最终Activity会调用onStart方法。
然后是调用ResumeActivityItem的execute方法，内部还是由ActivityThread执行handleResumeActivity方法
ActivityThread的handleResumeActivity方法
public void handleResumeActivity(IBinder token, boolean finalStateRequest, boolean isForward,
String reason) {
//...
final ActivityClientRecord r = performResumeActivity(token, finalStateRequest, reason);
//...
}
public ActivityClientRecord performResumeActivity(IBinder token, boolean finalStateRequest,
String reason) {
//...
r.activity.performResume(r.startsNotResumed, reason);
//...
}
Activity的performResume方法
final void performResume(boolean followedByPause, String reason) {
//...
mInstrumentation.callActivityOnResume(this);
//...
}
Instrumentation的callActivityOnResume方法
public void callActivityOnResume(Activity activity) {
activity.mResumed = true;
//终于onResume了。
activity.onResume();
//...
}
结尾：就先这样吧。总结起来就是一句话：自己选择看源码，就是跪着也要看完。
参考链接：
网友评论