App启动简单流程描述
- 在手机上点击App的快捷图标，此时手机屏幕就是一个Activity，而这个Activity所在的APP，业界称为launchActivity
- 当我们自己开发一款APP的时候，AndvoidManifest一般会这么写来启动默认Activity
<activity
android:name=".login.LuanchActivity"
android:screenOrientation="portrait"
android:theme="@style/SplashAppTheme"
android:windowSoftInputMode="stateAlwaysHidden">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
- Launch中为每个App图标提供了启动这个App所需要的Intent信息,这些信息是App安装或者启动的时候，PackManagerService从自己的apk包的Manifest文件中读取到的，所以点击图标就会启动了自己的app的引导页或者首页
App启动流程
我们会发现：Launcher和自己的APP(假设App名为为测试),它们位于不同的进程中，它们之间的通信是通过Binder完成——这时候ActivityManagerService(AMS)就起到了至关重要
以启动demo为例，整体流程分为7个阶段
- 1.Launcher通知AMS，要启动测试App,而且指定要启动App的哪个页面(也就是AndvoidManifest中设置的首页)
- 2.AMS通知Launcher,"好了，我知道了，没你什么事情了“，同时记住要启动的首页
- 3.Launcher当前页面进入Paused状态，通知AMS，“我睡了，你可以去找测试App了”
- 4.AMS检查测试App是否已经启动，是，则唤起测试App即可，否，就要启动一个新的进程，AMS在新的进程创建一个ActiivtyThread,启动其中的main函数
- 5.测试App启动后，通知AMS，“我启动好了”
- 6.AMS找到第二步存放的值，告诉测试APP，启动哪个页面
- 7.测试App启动首页，创建context并与首页Activity关联，然后调用Activity的onCreate方法
至此启动流程完成，可分成两部分：第1～3阶段，Launcher和AMS相互通信；第4～7阶段，测试App和AMS相互通信
Activity启动流程源码(源码是API25)
第一阶段：Launcher通知AMS
- 第1步和第2步—点击图标启动APP：点击Launcher上的测试APP的快捷图标，这时候会调用Launcher的startActIvitySafely方法,其实还是会调用Activity的startActivity方法，intent中带着要启动测试App所需要的如下关键信息:
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER"
cmp="com.test.activity.LaunchActivity"
我们看Activity中的startActivity方法
@Override
public void startActivity(Intent intent, @Nullable Bundle options) {
if (options != null) {
startActivityForResult(intent, -1, options);
} else {
// Note we want to go through this call for compatibility with
// applications that may have overridden the method.
startActivityForResult(intent, -1);
}
}
startActivityForResult的源码
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode) {
startActivityForResult(intent, requestCode, null);
}
requestCode为-1，表示Launcher并不关心测试App是否启动成功返回的结果
- 第三步:startActivityForResult，对上面代码继续往下走
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
@Nullable Bundle options) {
if (mParent == null) {
Instrumentation.ActivityResult ar =
mInstrumentation.execStartActivity(
this, mMainThread.getApplicationThread(), mToken, this,
intent, requestCode, options);
//...代码省略
}
我们可以看到有个mMainThread的变量,这是一个ActivityThread类型的变量,
ActivityThread，就是主线程，也就是UI线程，它是在App启动时创建的，它代表了App应用程序。而Application实际只是整个ActivityThread的上下文
这里需要注意两个参数:mMainThread.getApplicationThread(),和mToken
1.通过ActivityThread中的getApplicationThread方法取到一个binder对象,这个对象的类型为ApplicationThread，代表launcher所在的APP进程
2.mToken也是一个Binder对象，代表Launcher这个Activity也通过mInstrumentation传递给AMS，AMS一查就知道谁像AMS发送请求
这两个参数是伏笔，传递给AMS，以后AMS想反过来通知Launcher，就能通过这两个参数找到Launcher。
- 第四步，Instrumentation.execStartActivity源码分析(Instrumentation可以帮我们找到我们要启动的activity)
public ActivityResult execStartActivity(
Context who, IBinder contextThread, IBinder token, Activity target,
Intent intent, int requestCode, Bundle options) {
//...代码省略
try {
intent.migrateExtraStreamToClipData();
intent.prepareToLeaveProcess(who);
int result = ActivityManagerNative.getDefault()
.startActivity(whoThread, who.getBasePackageName(), intent,
intent.resolveTypeIfNeeded(who.getContentResolver()),
token, target != null ? target.mEmbeddedID : null,
requestCode, 0, null, options);
checkStartActivityResult(result, intent);
} catch (RemoteException e) {
throw new RuntimeException("Failure from system", e);
}
return null;
}
实际做的就是借助Instrumentation，把Activity数据传递给ActivityManagerNative（AMN）
- 第五步AMN的getDefault方法（API26以后是getService,并且没有AMN的代理对象ActivityManagerProxy）
static public IActivityManager getDefault() {
return gDefault.get();
}
private static final Singleton<IActivityManager> gDefault = new Singleton<IActivityManager>() {
protected IActivityManager create() {
IBinder b = ServiceManager.getService("activity");
if (false) {
Log.v("ActivityManager", "default service binder = " + b);
}
IActivityManager am = asInterface(b);
if (false) {
Log.v("ActivityManager", "default service = " + am);
}
return am;
}
};
}
ServiceManager是一个容器类，AMN通过getDefault方法，从ServiceManager获得一个对象
IBinder b = ServiceManager.getService("activity")
然后把它封装成一个ActivityMangerProxy对象(AMP)
IActivityManager是一个实现了IInterface的接口，里面定义了四大组件所有的生命周期和常用方法，比如startActivity。
- 第六步——AMP的startActivity方法。
public int startActivity(IApplicationThread caller, String callingPackage, Intent intent,
String resolvedType, IBinder resultTo, String resultWho, int requestCode,
int startFlags, ProfilerInfo profilerInfo, Bundle options) throws RemoteException {
Parcel data = Parcel.obtain();
Parcel reply = Parcel.obtain();
data.writeInterfaceToken(IActivityManager.descriptor);
data.writeStrongBinder(caller != null ? caller.asBinder() : null);
data.writeString(callingPackage);
intent.writeToParcel(data, 0);
data.writeString(resolvedType);
data.writeStrongBinder(resultTo);
data.writeString(resultWho);
data.writeInt(requestCode);
data.writeInt(startFlags);
if (profilerInfo != null) {
data.writeInt(1);
profilerInfo.writeToParcel(data, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
} else {
data.writeInt(0);
}
if (options != null) {
data.writeInt(1);
options.writeToParcel(data, 0);
} else {
data.writeInt(0);
}
mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);
reply.readException();
int result = reply.readInt();
reply.recycle();
data.recycle();
return result;
}
实际就是写数据到另一个进程,也就是AMS，然后等待AMS返回结果
第二阶段:AMS处理Launcher传过来的信息
接着上面，看上面AMP的startActivity源码
- Binder(也就是AMN/AMP)和AMS通信，当启动自己的APP的时候会将会发送类型START_ACTIVITY请求给AMS， 同时告诉AMS启动哪个Activity
- AMS会去检查自己App中的Manmifest文件，是否存在要启动的APP，如果不存在，就抛出Activity Not found错误
- AMS通知Launcher，“没你什么事情了，你休息吧”
AMS通过ApplicationThreadProxy发送消息，而App端则通过ApplicationThread来接收这个消息。
第三阶段：Launcher去休眠，然后通知AMS：“我真的已经睡了”
接下来将是一顿操作去寻找代码,我只贴主要的流程代码,首先由上面分析我们可以知道最终到的是ActivityManagerService中的startActivity方法
@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());
}
@Override
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) {
enforceNotIsolatedCaller("startActivity");
userId = mUserController.handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(),
userId, false, ALLOW_FULL_ONLY, "startActivity", null);
// TODO: Switch to user app stacks here.
return mActivityStarter.startActivityMayWait(caller, -1, callingPackage, intent,
resolvedType, null, null, resultTo, resultWho, requestCode, startFlags,
profilerInfo, null, null, bOptions, false, userId, null, null);
}
final 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, IActivityManager.WaitResult outResult, Configuration config,
Bundle bOptions, boolean ignoreTargetSecurity, int userId,
IActivityContainer iContainer, TaskRecord inTask) {
// PackageManagerService-----> 扫描app，注册组件
ResolveInfo rInfo = mSupervisor.resolveIntent(intent, resolvedType, userId);
// Collect information about the target of the Intent.
ActivityInfo aInfo = mSupervisor.resolveActivity(intent, rInfo, startFlags, profilerInfo);
rInfo = mSupervisor.resolveIntent(intent, null /*resolvedType*/, userId);
int res = startActivityLocked(caller, intent, ephemeralIntent, resolvedType,
aInfo, rInfo, voiceSession, voiceInteractor,
resultTo, resultWho, requestCode, callingPid,
callingUid, callingPackage, realCallingPid, realCallingUid, startFlags,
options, ignoreTargetSecurity, componentSpecified, outRecord, container,
inTask);
}
final int startActivityLocked(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,
ActivityOptions options, boolean ignoreTargetSecurity, boolean componentSpecified,
ActivityRecord[] outActivity, ActivityStackSupervisor.ActivityContainer container,
TaskRecord inTask) {
// 验证intent、Class、Permission等
// 保存将要启动的Activity的Record
err = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor, startFlags,
true, options, inTask);
return err;
}
private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask) {
// 检查将要启动的Activity的launchMode和启动Flag
// 根据launcheMode和Flag配置task
final boolean dontStart = top != null && mStartActivity.resultTo == null
&& top.realActivity.equals(mStartActivity.realActivity)
&& top.userId == mStartActivity.userId
&& top.app != null && top.app.thread != null
&& ((mLaunchFlags & FLAG_ACTIVITY_SINGLE_TOP) != 0
|| mLaunchSingleTop || mLaunchSingleTask);
// 举一个例子 SingleTop
if (dontStart) {
top.deliverNewIntentLocked(
mCallingUid, mStartActivity.intent, mStartActivity.launchedFromPackage);
// Don't use mStartActivity.task to show the toast. We're not starting a new activity
// but reusing 'top'. Fields in mStartActivity may not be fully initialized.
mSupervisor.handleNonResizableTaskIfNeeded(
top.task, preferredLaunchStackId, topStack.mStackId);
return START_DELIVERED_TO_TOP;
}
mTargetStack.startActivityLocked(mStartActivity, newTask, mKeepCurTransition, mOptions);
if (mDoResume) {
//看这个
mSupervisor.resumeFocusedStackTopActivityLocked(mTargetStack, mStartActivity,
mOptions);
}
}
ActivityStackSupervirsor
boolean resumeFocusedStackTopActivityLocked() {
return resumeFocusedStackTopActivityLocked(null, null, null);
}
boolean resumeFocusedStackTopActivityLocked(
ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
if (targetStack != null && isFocusedStack(targetStack)) {
return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
}
final ActivityRecord r = mFocusedStack.topRunningActivityLocked();
if (r == null || r.state != RESUMED) {
mFocusedStack.resumeTopActivityUncheckedLocked(null, null);
}
return false;
}
实际调用的是ActivityStack的resumeTopActivityUncheckedLocked
boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
//代码省略
boolean result = false;
try {
//代码省略
result = resumeTopActivityInnerLocked(prev, options);
}
return result;
}
private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
//代码省略
if (mResumedActivity != null) {
if (DEBUG_STATES) Slog.d(TAG_STATES,
"resumeTopActivityLocked: Pausing " + mResumedActivity);
pausing |= startPausingLocked(userLeaving, false, next, dontWaitForPause);
}
}
final boolean startPausingLocked(boolean userLeaving, boolean uiSleeping,
ActivityRecord resuming, boolean dontWait) {
if (prev.app != null && prev.app.thread != null) {
if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Enqueueing pending pause: " + prev);
try {
EventLog.writeEvent(EventLogTags.AM_PAUSE_ACTIVITY,
prev.userId, System.identityHashCode(prev),
prev.shortComponentName);
mService.updateUsageStats(prev, false);
//主要这个
prev.app.thread.schedulePauseActivity(prev.appToken, prev.finishing,
userLeaving, prev.configChangeFlags, dontWait);
} catch (Exception e) {
// 代码省略
}
}
}
prev.app.thread实际是ActivityThread也就是说实际调用的是ActivityThread中的schedulePauseActivity方法
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);
}
ApplicationThread(APT)接受到AMS消息后，调用ActivityThread的sendMessage方法，向Launcher的主线程消息队列发送一个PAUSE_ACTIVITY消息
我们都知道Hnadler会调用handlerMessager，继续走
public void handleMessage(Message msg) {
case PAUSE_ACTIVITY: {
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityPause");
SomeArgs args = (SomeArgs) msg.obj;
handlePauseActivity((IBinder) args.arg1, false,
(args.argi1 & USER_LEAVING) != 0, args.argi2,
(args.argi1 & DONT_REPORT) != 0, args.argi3);
maybeSnapshot();
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
} break;
}
handlePauseActivity源码
private void handlePauseActivity(IBinder token, boolean finished,
boolean userLeaving, int configChanges, boolean dontReport, int seq) {
ActivityClientRecord r = mActivities.get(token);
if (DEBUG_ORDER) Slog.d(TAG, "handlePauseActivity " + r + ", seq: " + seq);
if (!checkAndUpdateLifecycleSeq(seq, r, "pauseActivity")) {
return;
}
if (r != null) {
//Slog.v(TAG, "userLeaving=" + userLeaving + " handling pause of " + r);
if (userLeaving) {
performUserLeavingActivity(r);
}
r.activity.mConfigChangeFlags |= configChanges;
performPauseActivity(token, finished, r.isPreHoneycomb(), "handlePauseActivity");
// Tell the activity manager we have paused.
if (!dontReport) {
try {
ActivityManagerNative.getDefault().activityPaused(token);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
}
mSomeActivitiesChanged = true;
}
}
handlePauseActivity主要做两件事情
- ActvityThread有一个mActivities集合，保存当前App也就是launcher中所有打开的 Activity，把它找出来，然后让它休眠
- 通过AMP通知AMS，“我真的休眠了”
第四阶段:AMS启动新的进程
AMS要启动测试App,因为后台进程没有该APP，所以要启动一个新的进程，并且制定ActvityThread的main函数为入口函数。这阶段了解即可
第五阶段：新的进程启动，以ActivityThread的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
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");
}
thread.attach方法
private void attach(boolean system) {
sCurrentActivityThread = this;
mSystemThread = system;
if (!system) {
RuntimeInit.setApplicationObject(mAppThread.asBinder());
final IActivityManager mgr = ActivityManagerNative.getDefault();
try {
mgr.attachApplication(mAppThread);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
//代码省略
}
}
实际调用的AMS中的attachApplication方法
ActivityManagerService中的方法：
public final void attachApplication(IApplicationThread thread) {
synchronized (this) {
int callingPid = Binder.getCallingPid();
final long origId = Binder.clearCallingIdentity();
attachApplicationLocked(thread, callingPid);
Binder.restoreCallingIdentity(origId);
}
}
attachApplicationLocked代码较长直接截取(这行需要注意下面还会分析第二个方法)
AMS中的方法，主要功能有以下两步
private final boolean attachApplicationLocked(IApplicationThread thread, int pid) {
//代码省略
主要用于创建Application，用调用onCreate方法
thread.bindApplication(...);
//代码省略
//主要用于创建Activity
if (mStackSupervisor.attachApplicationLocked(app)) {
//代码省略
}
}
此时回到ActivityThread的bindApplication方法其实里面主要是这个方法
sendMessage(H.BIND_APPLICATION, data);
//handlermessage中的方法
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;
AppBindData会创建一个loadapk对象,标记当前APK信息
handleBindApplication源码
private void handleBindApplication(AppBindData data) {
try {
//其他省略直接看这行,实际调用的LoadApk中的makeApplication方法
Application app = data.info.makeApplication(data.restrictedBackupMode, null);
mInitialApplication = app;
}
public Application makeApplication(boolean forceDefaultAppClass, Instrumentation instrumentation) {
try {
java.lang.ClassLoader cl = getClassLoader();
ContextImpl appContext = ContextImpl.createAppContext(mActivityThread, this);
app = mActivityThread.mInstrumentation.newApplication(
cl, appClass, appContext);
appContext.setOuterContext(app);
}
if (instrumentation != null) {
try {
//这行源码就不看了实际就是调用onCreate方法
instrumentation.callApplicationOnCreate(app);
} catch (Exception e) {
//代码省略
}
}
}
//newApplication最终走到这里,实际就是通过反射创建Application对象
static public Application newApplication(Class<?> clazz, Context context)
throws InstantiationException, IllegalAccessException,
ClassNotFoundException {
Application app = (Application)clazz.newInstance();
app.attach(context);
return app;
}
回到刚才attachApplicationLocked中的源码mStackSupervisor.attachApplicationLocked(app)源码
boolean attachApplicationLocked(ProcessRecord app) throws RemoteException {
//代码省略
if (realStartActivityLocked(hr, app, true, true)) {
//代码省略
}
//代码省略
}
final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
boolean andResume, boolean checkConfig) throws RemoteException {
//代码省略
try {
调用ApplicationThread的scheduleLaunchActivity用于启动一个Activity
app.thread.scheduleLaunchActivity(...);
} catch (RemoteException e) {
}
}
1）创建一个主线程Looper，也就是MainLooper。注意，MainLooper就是在这里创建的。
2）创建Application。注意，Application是在这里生成的。
主线程在收到BIND_APPLICATION消息后，根据传递过来的ApplicationInfo创建一个loadApk对象(标记当前APK信息),然后创建ContextImpl对象（标志当前进程的环境），紧接着通过反射创建目标Application，并调用其attach方法，将ContextImpl对象设置为目标Application的上下文环境，最后调用Application的onCreate函数，做一些初始工作。
第六阶段：AMS告诉新APP启动哪个Activity
AMS把传入ActivityThread对象转换成ApplicationThread对象，用于以后和这个App跨进程通信
在第一阶段，Launcher通知AMS，要启动测试APP的哪个Activity，在第二阶段，这个信息AMS保存下来，第六阶段，AMS从过去的记录中翻出要启动哪个Activity,通过APT告诉app
第七阶段：启动测试App的首页Activity
回到刚才的第五阶段接着分析app.thread.scheduleLaunchActivity(的源码，实际是ActivityThread的scheduleLaunchActivity，里面实际就是发送了个消息
sendMessage(H.LAUNCH_ACTIVITY, r);
//handlerMessage中查看
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;
ActivityClientRecord 是AMS传递过来的要启动的Activity
getPackageInfoNoCheck方法，这个方法会提取apk中的所有资源，然后设置r的packageInfo属性。
handleLaunchActivity源码分析
private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {
//代码省略
Activity a = performLaunchActivity(r, customIntent);
//代码省略
}
//performLaunchActivity源码
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
//通过反射获得activity的实列
Activity activity = null;
try {
java.lang.ClassLoader cl = r.packageInfo.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) {
//代码省略
}
try {
Application app = r.packageInfo.makeApplication(false, mInstrumentation);
if (activity != null) {
//为activity创建一个上下文
Context appContext = createBaseContextForActivity(r, activity);
CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
Configuration config = new Configuration(mCompatConfiguration);
//将上下文传给activity
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);
//代码省略
activity.mCalled = false;
if (r.isPersistable()) {
mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
} else {
mInstrumentation.callActivityOnCreate(activity, r.state);
}
if (!r.activity.mFinished) {
activity.mCalled = false;
if (r.isPersistable()) {
mInstrumentation.callActivityOnPostCreate(activity, r.state,
r.persistentState);
} else {
mInstrumentation.callActivityOnPostCreate(activity, r.state);
}
if (!activity.mCalled) {
throw new SuperNotCalledException(
"Activity " + r.intent.getComponent().toShortString() +
" did not call through to super.onPostCreate()");
}
}
}
//代码省略
return activity;
}
1）通过Instrumentation的newActivity方法，创建要启动的Activity实例。
2）为这个Activity创建一个上下文Context对象，并与Activity进行关联。
3）通过Instrumentation的callActivityOnCreate方法，执行Activity的onCreate()方法，从而启动Activity。
参考书籍：<<android插件化开发指南>>