總流程圖
啟動(dòng)
我們?cè)诖a中啟動(dòng)Activity都使用 Context.startActivity()的方式；來啟動(dòng)Activity。那么在這個(gè)過程中到底發(fā)生了什么？跟著源碼來看一下。
首先Context.startActivity()之后會(huì)調(diào)用Conetxt的子類ContextWrapper，這是一個(gè)Context的包裝類。Context還有一個(gè)子類是ContextImpl，這是Context的實(shí)現(xiàn)子類。
在ContextWrapper中的代碼是這樣的：
@Override
public void startActivity(Intent intent) {
mBase.startActivity(intent);
}
其中mBase就是Attach進(jìn)來的Context，他的實(shí)現(xiàn)就是在ContextImpl里面。
@Override
public void startActivity(Intent intent, Bundle options) {
warnIfCallingFromSystemProcess();
if ((intent.getFlags()&Intent.FLAG_ACTIVITY_NEW_TASK) == 0) {
throw new AndroidRuntimeException(
"Calling startActivity() from outside of an Activity "
+ " context requires the FLAG_ACTIVITY_NEW_TASK flag."
+ " Is this really what you want?");
}
mMainThread.getInstrumentation().execStartActivity(
getOuterContext(), mMainThread.getApplicationThread(), null,
(Activity) null, intent, -1, options);
}
在這個(gè)方法內(nèi)部會(huì)調(diào)用Instrumentation。這個(gè)類封裝著Activity的各種操作。所以在這邊跳轉(zhuǎn)到Instrumentation.execStartActivity()的執(zhí)行方法。
public ActivityResult execStartActivity(
Context who, IBinder contextThread, IBinder token, Activity target,
Intent intent, int requestCode, Bundle options) {
...
...
try {
intent.migrateExtraStreamToClipData();
intent.prepareToLeaveProcess();
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;
}
在這個(gè)方法里面有這么一絕ActivityManagerNative.getDefault().startActivity() 我們看一下ActivityManagerNative 是什么東西.
ActivityManagerNative類的定義是這樣的：
public abstract class ActivityManagerNative extends Binder implements IActivityManager{}
這邊ActivityManagerNative是一個(gè)典型的Binder對(duì)象，繼承Binder并實(shí)現(xiàn)一個(gè)接口。這邊如果不理解Binder，建議先去學(xué)習(xí)了解Binder，了解Android的IPC機(jī)制。4大組件底層的啟動(dòng)大部分都是通過Binder進(jìn)行關(guān)聯(lián)啟動(dòng)。
如果了解Binder，那我們繼續(xù)下去，我們?cè)趯慉IDL的時(shí)候，IDE自動(dòng)幫我們生成Binder代碼，我們知道Binder有兩個(gè)內(nèi)容，一個(gè)是Stub，用來服務(wù)端通信的，還有一個(gè)Proxy代理用來客戶端信息。而ActivityManagerNative本身就是一個(gè)Stub，它是由Google自己寫的一個(gè)Binder。ActivityManagerNative 里面也有一個(gè)Proxy。就是ActivityManagerProxy。
class ActivityManagerProxy implements IActivityManager{
private IBinder mRemote;
public ActivityManagerProxy(IBinder remote)
{
mRemote = remote;
}
public IBinder asBinder()
{
return mRemote;
}
.....
}
看這個(gè)跟IDE自動(dòng)生成的代碼是一樣的。
我們接著上面的分析，在ContextImpl中ActivityManagerNative.getDefault()，實(shí)際上是一由一個(gè)自己封裝Singleton單例對(duì)象。在get()的時(shí)候如果是第一次則會(huì)調(diào)用create().
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;
}
};
Singleton.java
public abstract class Singleton<T> {
private T mInstance;
protected abstract T create();
public final T get() {
synchronized (this) {
if (mInstance == null) {
mInstance = create();
}
return mInstance;
}
}
}
在這里將獲取的IBinder轉(zhuǎn)成IActivityManager 對(duì)象。ActivityManagerNative.getDefault().startActivity()實(shí)際上是調(diào)用IActivityManager.startActivity(). 由上面分析的Binder，我們可以知道IActivityManager.startActivity()就是從客戶端調(diào)用startActivity，也就是在Proxy里面調(diào)用startActivity()。
ActivityManagerProxy.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 {
...
mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);
reply.readException();
int result = reply.readInt();
reply.recycle();
data.recycle();
return result;
}
參數(shù)一大堆，看我們關(guān)心的mRemote.transact()方法，回調(diào)到AMN的onTransact方法里。
@Override
public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
throws RemoteException {
switch (code) {
case START_ACTIVITY_TRANSACTION:
{
data.enforceInterface(IActivityManager.descriptor);
IBinder b = data.readStrongBinder();
IApplicationThread app = ApplicationThreadNative.asInterface(b);
String callingPackage = data.readString();
Intent intent = Intent.CREATOR.createFromParcel(data);
String resolvedType = data.readString();
IBinder resultTo = data.readStrongBinder();
String resultWho = data.readString();
int requestCode = data.readInt();
int startFlags = data.readInt();
ProfilerInfo profilerInfo = data.readInt() != 0
? ProfilerInfo.CREATOR.createFromParcel(data) : null;
Bundle options = data.readInt() != 0
? Bundle.CREATOR.createFromParcel(data) : null;
int result = startActivity(app, callingPackage, intent, resolvedType,
resultTo, resultWho, requestCode, startFlags, profilerInfo, options);
reply.writeNoException();
reply.writeInt(result);
return true;
}
}
}
這里調(diào)的startActivity實(shí)際上是調(diào)用ActivityManagerService中的startActivity，AMS是ActivityManagerNative的具體實(shí)現(xiàn)類。
@Override
public final int startActivity(IApplicationThread caller, String callingPackage,
Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
int startFlags, ProfilerInfo profilerInfo, Bundle options) {
return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
resultWho, requestCode, startFlags, profilerInfo, options,
UserHandle.getCallingUserId());
}
內(nèi)部接著調(diào)用startActivityAsUser()。
@Override
public final int startActivityAsUser(IApplicationThread caller, String callingPackage,
Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
int startFlags, ProfilerInfo profilerInfo, Bundle options, int userId) {
enforceNotIsolatedCaller("startActivity");
userId = handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(), userId,
false, ALLOW_FULL_ONLY, "startActivity", null);
// TODO: Switch to user app stacks here.
return mStackSupervisor.startActivityMayWait(caller, -1, callingPackage, intent,
resolvedType, null, null, resultTo, resultWho, requestCode, startFlags,
profilerInfo, null, null, options, false, userId, null, null);
}
這邊重點(diǎn)看mStackSupervisor.startActivityMayWait()這個(gè)方法。ActivityStackSupervisor 這個(gè)類有點(diǎn)像工具類，封裝Activity的各種操作?？匆幌聅tartActivityMayWait這個(gè)方法做了什么。
final int startActivityMayWait(...){
...
// Collect information about the target of the Intent.
//收集目標(biāo)Activity的信息.
ActivityInfo aInfo =
resolveActivity(intent, resolvedType, startFlags, profilerInfo, userId);
...
synchronized (mService) {
...
//啟動(dòng)Activity
int res = startActivityLocked(caller, intent, resolvedType, aInfo,
voiceSession, voiceInteractor, resultTo, resultWho,
requestCode, callingPid, callingUid, callingPackage,
realCallingPid, realCallingUid, startFlags, options, ignoreTargetSecurity,
componentSpecified, null, container, inTask);
Binder.restoreCallingIdentity(origId);
...
}
...
}
這個(gè)方法也是一大堆參數(shù)。先不去管他，看具體的實(shí)現(xiàn)，首先是收集目標(biāo)Activity的信息，然后接著調(diào)用startActivityLocked。
final int startActivityLocked(...){
...
if (err != ActivityManager.START_SUCCESS) {
if (resultRecord != null) {
//這個(gè)干嗎？最后回調(diào)onActivityResult，就是說startActivity最后還是會(huì)調(diào)用startActivityForResult
resultStack.sendActivityResultLocked(-1,
resultRecord, resultWho, requestCode,
Activity.RESULT_CANCELED, null);
}
ActivityOptions.abort(options);
return err;
}
...
//也是調(diào)用startActivityUncheckedLocked方法.
doPendingActivityLaunchesLocked(false);
// 從這進(jìn)去
err = startActivityUncheckedLocked(r, sourceRecord, voiceSession, voiceInteractor,
startFlags, true, options, inTask);
...
}
startActivityLocked這個(gè)方法很長，重點(diǎn)看著幾個(gè)，這里面有好幾次調(diào)用到resultStack.sendActivityResultLocked，而這個(gè)方法最終回調(diào)onActivityResult。
往下看這里最后調(diào)startActivityUncheckedLocked方法。
startActivityUncheckedLocked 也是一個(gè)大方法，最后是調(diào)用resumeTopActivitiesLocked(targetStack, null, options);過程就不看，代碼太多太復(fù)雜。
boolean resumeTopActivitiesLocked(ActivityStack targetStack, ActivityRecord target,
Bundle targetOptions) {
...
boolean result = false;
if (isFrontStack(targetStack)) {
result = targetStack.resumeTopActivityLocked(target, targetOptions);
}
...
}
回調(diào)到ActivityStack的resumeTopActivityLocked。
final boolean resumeTopActivityLocked(ActivityRecord prev, Bundle options) {
...
try{
...
result = resumeTopActivityInnerLocked(prev, options);
}
...
}
回調(diào)resumeTopActivityInnerLocked，這個(gè)方法也是一個(gè)大方法，代碼很多，在這里面進(jìn)行一系列判斷操作后調(diào)用mStackSupervisor.startSpecificActivityLocked又回到ActivityStackSupervisor中去了。
而在startSpecificActivityLocked方法中調(diào)用realStartActivityLocked這個(gè)方法
final boolean realStartActivityLocked(ActivityRecord r,
ProcessRecord app, boolean andResume, boolean checkConfig)
throws RemoteException {
...
//啟動(dòng)Activity
app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,
System.identityHashCode(r), r.info, new Configuration(mService.mConfiguration),
new Configuration(stack.mOverrideConfig), r.compat, r.launchedFromPackage,
task.voiceInteractor, app.repProcState, r.icicle, r.persistentState, results,
newIntents, !andResume, mService.isNextTransitionForward(), profilerInfo);
...
}
這邊開始調(diào)用app.thread.scheduleLaunchActivity,這個(gè)是回到應(yīng)用進(jìn)程中去。這里的app.thread是IApplicationThread。而在ActivityManagerNative里的START_SERVICE_TRANSACTION有這句： IApplicationThread app = ApplicationThreadNative.asInterface(b); 我們的這個(gè)app.thread也是ApplicationThreadNative里的Binder。這邊又是一個(gè)Binder對(duì)象。
同樣ApplicationThreadNative也是一個(gè)Stub，里面的ApplicationThreadProxy是一個(gè)Proxy。所以這里app.thread.scheduleLaunchActivity()實(shí)際是ApplicationThreadNative.scheduleLaunchActivity().
public final void scheduleLaunchActivity(...){
...
mRemote.transact(SCHEDULE_LAUNCH_ACTIVITY_TRANSACTION, data, null,
IBinder.FLAG_ONEWAY);
data.recycle();
}
回調(diào)到ApplicationThreadNative 的onTransact中：
case SCHEDULE_LAUNCH_ACTIVITY_TRANSACTION:
{
...
scheduleLaunchActivity(intent, b, ident, info, curConfig, overrideConfig, compatInfo,
referrer, voiceInteractor, procState, state, persistentState, ri, pi,
notResumed, isForward, profilerInfo);
return true;
}
scheduleLaunchActivity的具體實(shí)現(xiàn)是在applicationThread中：
@Override
public final void scheduleLaunchActivity(...){
...
sendMessage(H.LAUNCH_ACTIVITY, r);
}
這邊通過sendMessage()發(fā)送消息，由H來處理，H是系統(tǒng)的Handler。
public void handleMessage(Message msg) {
switch (msg.what) {
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);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
} break;
}
}
調(diào)用handleLaunchActivity，在handleLaunchActivity里面是：
private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent) {
...
//準(zhǔn)備啟動(dòng)Activity
Activity a = performLaunchActivity(r, customIntent);
if (a != null) {
...
//處理onResume方法
handleResumeActivity(r.token, false, r.isForward,
!r.activity.mFinished && !r.startsNotResumed);
}
}
performLaunchActivity 準(zhǔn)備啟動(dòng)。
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
//獲取待啟動(dòng)的Activity的信息.
ActivityInfo aInfo = r.activityInfo;
...
//通過newActivity方式使用類加載器創(chuàng)建Activity對(duì)象.
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) {
if (!mInstrumentation.onException(activity, e)) {
throw new RuntimeException(
"Unable to instantiate activity " + component
+ ": " + e.toString(), e);
}
}
//通過makeApplication方法創(chuàng)建Application.
try {
Application app = r.packageInfo.makeApplication(false, mInstrumentation);
...
if (r.isPersistable()) {
//回調(diào)onCreate()
mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
} else {
mInstrumentation.callActivityOnCreate(activity, r.state);
}
...
if (!r.activity.mFinished) {
//回調(diào)onStart。
activity.performStart();
r.stopped = false;
}
...
}
...
}
又回到 Instrumentation 中調(diào)用callActivityOnCreate;
public void callActivityOnCreate(Activity activity, Bundle icicle,
PersistableBundle persistentState) {
prePerformCreate(activity);
activity.performCreate(icicle, persistentState);
postPerformCreate(activity);
}
activity.performCreate 調(diào)用Activity的performCreate。
final void performCreate(Bundle icicle, PersistableBundle persistentState) {
restoreHasCurrentPermissionRequest(icicle);
onCreate(icicle, persistentState);
mActivityTransitionState.readState(icicle);
performCreateCommon();
}
至此Activity啟動(dòng)成功并調(diào)用onCreate().
那Activity生命周期里接下去調(diào)用onStart()方法。我們看performLaunchActivity在callActivityOnCreate后面還調(diào)用了performStart()，就是回調(diào)onStart()方法。
onResume()方法在哪里回調(diào)，我們看handleLaunchActivity方法里面在調(diào)用performLaunchActivity之后還調(diào)用了handleResumeActivity()，這個(gè)就是回調(diào)onResume()的方法。其他的生命周期方法也是一樣的模式。至此Activity啟動(dòng)源碼閱讀結(jié)束
