activity、service和Application都继承于ContextWrapper，所以当我们startActivity的时候就会走到ContextWrapper的startActivity，进ContextWrapper里面的startActivity我们很容易看出来是mBase.startActivity(intent);之前我们已经说过了这里的mBase其实就是ContextImpl的实例，ContextImpl与ContextWrapper一样都继承于Context。所以我们就去ContextImpl中看看
@Override
public void startActivity(Intent intent) {
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);
}
我们可以看到execStartActivity传进去6个参数，我们关注一下第4个参数是activity就行了，由于今天主要讲流程，其他的不关心。我们进到Instrumentation个类里面可以看到里面有两个execStartActivity，他们的区别就是第4个参数一个是activity另一个是Fragment，今天我们就看是activity的那个execStartActivity
try {
intent.setAllowFds(false);
int result = ActivityManagerNative.getDefault()
.startActivity(whoThread, intent,
intent.resolveTypeIfNeeded(who.getContentResolver()),
null, 0, token, target != null ? target.mEmbeddedID : null,
requestCode, false, false, null, null, false);
checkStartActivityResult(result, intent);
} catch (RemoteException e) {
}
我们去看看ActivityManagerNative.getDefault()
/**
* Retrieve the system's default/global activity manager.
*/
static public IActivityManager getDefault() {
return gDefault.get();
}
得到一个IActivityManager，我们再看看gDefault
private static final Singleton
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;
}
};
最终是从asInterface(b)得到IActivityManager
static public IActivityManager asInterface(IBinder obj) {
if (obj == null) {
return null;
}
IActivityManager in =
(IActivityManager)obj.queryLocalInterface(descriptor);
if (
in != null) {
return in;
}
return new ActivityManagerProxy(obj);
}
这下可以明白了我们需要的IActivityManager其实就是ActivityManagerProxy，所以ActivityManagerNative.getDefault().startActivity就变成了ActivityManagerProxy.startActivity
public int startActivity(IApplicationThread caller, Intent intent,
String resolvedType, Uri[] grantedUriPermissions, int grantedMode,
IBinder resultTo, String resultWho,
int requestCode, boolean onlyIfNeeded,
boolean debug, String profileFile, ParcelFileDescriptor profileFd,
boolean autoStopProfiler) throws RemoteException {
Parcel data = Parcel.obtain();
Parcel reply = Parcel.obtain();
data.writeInterfaceToken(IActivityManager.descriptor);
data.writeStrongBinder(caller != null ? caller.asBinder() : null);
intent.writeToParcel(data, 0);
data.writeString(resolvedType);
data.writeTypedArray(grantedUriPermissions, 0);
data.writeInt(grantedMode);
data.writeStrongBinder(resultTo);
data.writeString(resultWho);
data.writeInt(requestCode);
data.writeInt(onlyIfNeeded ? 1 : 0);
data.writeInt(debug ? 1 : 0);
data.writeString(profileFile);
if (profileFd != null) {
data.writeInt(1);
profileFd.writeToParcel(data, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
} else {
data.writeInt(0);
}
data.writeInt(autoStopProfiler ? 1 : 0);
mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);
reply.readException();
int result = reply.readInt();
reply.recycle();
data.recycle();
return result;
}
很明显了，这是binder的事情了，这个以后会讲到，这里不多说，只看START_ACTIVITY_TRANSACTION最终去了哪里，也就是我们的ActivityManagerNative的onTransact中
case START_ACTIVITY_TRANSACTION:
{
data.enforceInterface(IActivityManager.descriptor);
IBinder b = data.readStrongBinder();
IApplicationThread app = ApplicationThreadNative.asInterface(b);
Intent intent = Intent.CREATOR.createFromParcel(data);
String resolvedType = data.readString();
Uri[] grantedUriPermissions = data.createTypedArray(Uri.CREATOR);
int grantedMode = data.readInt();
IBinder resultTo = data.readStrongBinder();
String resultWho = data.readString();
int requestCode = data.readInt();
boolean onlyIfNeeded = data.readInt() != 0;
boolean debug = data.readInt() == 1;
String profileFile = data.readString();
ParcelFileDescriptor profileFd = data.readInt() != 0
? data.readFileDescriptor() : null;
boolean autoStopProfiler = data.re
adInt() != 0;
int result = startActivity(app, intent, resolvedType,
grantedUriPermissions, grantedMode, resultTo, resultWho,
requestCode, onlyIfNeeded, debug, profileFile, profileFd, autoStopProfiler);
reply.writeNoException();
reply.writeInt(result);
return true;
}
而这里的startActivity又是哪里的？这个在ActivityManagerService中
public final int startActivity(IApplicationThread caller,
Intent intent, String resolvedType, Uri[] grantedUriPermissions,
int grantedMode, IBinder resultTo,
String resultWho, int requestCode, boolean onlyIfNeeded, boolean debug,
String profileFile, ParcelFileDescriptor profileFd, boolean autoStopProfiler) {
return mMainStack.startActivityMayWait(caller, -1, intent, resolvedType,
grantedUriPermissions, grantedMode, resultTo, resultWho,
requestCode, onlyIfNeeded, debug, profileFile, profileFd, autoStopProfiler,
null, null);
}
很明显，我们智能去ActivityStack中，看看startActivityMayWait这里是一堆代码，我们还是只找我们关心
int res = startActivityLocked(caller, intent, resolvedType,
grantedUriPermissions, grantedMode, aInfo,
resultTo, resultWho, requestCode, callingPid, callingUid,
onlyIfNeeded, componentSpecified, null);
就是这个了，我们接着看startActivityLocked这里还是一堆代码，在startActivityLocked里面我们可以发现
ActivityRecord r = new ActivityRecord(mService, this, callerApp, callingUid,
intent, resolvedType, aInfo, mService.mConfiguration,
resultRecord, resultWho, requestCode, componentSpecified);
对了，我们activity的ActivityRecord就是在这里创建的。ActivityRecord记录了应用进程中Activity子类的实例，我们称之为外特性空间的Activity。这些Activity类实例是放在应用程序端进行实际交互的Activity。不再多做解释接着看
err = startActivityUncheckedLocked(r, sourceRecord,
grantedUriPermissions, grantedMode, onlyIfNeeded, true);
这地方把我们的ActivityRecord实例传递了进去，而在startActivityUncheckedLocked中还是一堆代码，我们只看我们activity正常启动的部分
startActivityLocked(r, newTask, doResume, keepCurTransition);
这里的doResume是true，我们可以从上面的参数中看出来，我们到startActivityLocked里面看看，选取主要的，其它的我们有机会会在讲解WindowManagerService的时候讲解
if (doResume) {
resumeTopActivityLocked(null);
}
而在resumeTopActivityLocked中我们最终会走进
startSpecificActivityLocked(next, true, true);
里面，我们去看看
private final void startSpecificA
ctivityLocked(ActivityRecord r,
boolean andResume, boolean checkConfig) {
// Is this activity's application already running?
ProcessRecord app = mService.getProcessRecordLocked(r.processName,
https://www.doczj.com/doc/c84459377.html,.applicationInfo.uid);
if (https://www.doczj.com/doc/c84459377.html,unchTime == 0) {
https://www.doczj.com/doc/c84459377.html,unchTime = SystemClock.uptimeMillis();
if (mInitialStartTime == 0) {
mInitialStartTime = https://www.doczj.com/doc/c84459377.html,unchTime;
}
} else if (mInitialStartTime == 0) {
mInitialStartTime = SystemClock.uptimeMillis();
}
if (app != null && app.thread != null) {
try {
app.addPackage(https://www.doczj.com/doc/c84459377.html,.packageName);
realStartActivityLocked(r, app, andResume, checkConfig);
return;
} catch (RemoteException e) {
Slog.w(TAG, "Exception when starting activity "
+ r.intent.getComponent().flattenToShortString(), e);
}
// If a dead object exception was thrown -- fall through to
// restart the application.
}
mService.startProcessLocked(r.processName, https://www.doczj.com/doc/c84459377.html,.applicationInfo, true, 0,
"activity", r.intent.getComponent(), false);
}
这里的关键就是
realStartActivityLocked(r, app, andResume, checkConfig);
了，别的不做多的解释，照样截取我们需要的代码
app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,
System.identityHashCode(r), https://www.doczj.com/doc/c84459377.html,,
new Configuration(mService.mConfiguration),
https://www.doczj.com/doc/c84459377.html,pat, r.icicle, results, newIntents, !andResume,
mService.isNextTransitionForward(), profileFile, profileFd,
profileAutoStop);
这里app是ProcessRecord，app.thread是IApplicationThread，app.thread.scheduleLaunchActivity就是ApplicationThread.scheduleLaunchActivity是ActivityThread的内部类
public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,
ActivityInfo info, Configuration curConfig, CompatibilityInfo compatInfo,
Bundle state, List
List
String profileName, ParcelFileDescriptor profileFd, boolean autoStopProfiler) {
ActivityClientRecord r = new ActivityClientRecord();
r.token = token;
r.ident = ident;
r.intent = intent;
r.activityInfo = info;
https://www.doczj.com/doc/c84459377.html,patInfo = compatInfo;
r.state = state;
r.pendingResults = pendingResults;
r.pendingIntents = pendingNewIntents;
r.startsNotResumed = notResumed;
r.isForward = isForward;
r.profileFile = profileName;
r.profileFd = pro
fileFd;
r.autoStopProfiler = autoStopProfiler;
updatePendingConfiguration(curConfig);
queueOrSendMessage(https://www.doczj.com/doc/c84459377.html,UNCH_ACTIVITY, r);
}
很明显，最终把需要的参数通过发https://www.doczj.com/doc/c84459377.html,UNCH_ACTIVITY消息来传送了
public void handleMessage(Message msg) {
if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + msg.what);
switch (msg.what) {
case LAUNCH_ACTIVITY: {
ActivityClientRecord r = (ActivityClientRecord)msg.obj;
r.packageInfo = getPackageInfoNoCheck(
r.activityInfo.applicationInfo, https://www.doczj.com/doc/c84459377.html,patInfo);
handleLaunchActivity(r, null);
} break;
终于我们熟悉的activity要出现了，也就是
handleLaunchActivity(r, null);
所以我们接着看
private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent) {
// If we are getting ready to gc after going to the background, well
// we are back active so skip it.
unscheduleGcIdler();
if (r.profileFd != null) {
mProfiler.setProfiler(r.profileFile, r.profileFd);
mProfiler.startProfiling();
mProfiler.autoStopProfiler = r.autoStopProfiler;
}
// Make sure we are running with the most recent config.
handleConfigurationChanged(null, null);
if (localLOGV) Slog.v(
TAG, "Handling launch of " + r);
Activity a = performLaunchActivity(r, customIntent);
if (a != null) {
r.createdConfig = new Configuration(mConfiguration);
Bundle oldState = r.state;
handleResumeActivity(r.token, false, r.isForward);
if (!r.activity.mFinished && r.startsNotResumed) {
// The activity manager actually wants this one to start out
// paused, because it needs to be visible but isn't in the
// foreground. We accomplish this by going through the
// normal startup (because activities expect to go through
// onResume() the first time they run, before their window
// is displayed), and then pausing it. However, in this case
// we do -not- need to do the full pause cycle (of freezing
// and such) because the activity manager assumes it can just
// retain the current state it has.
try {
r.activity.mCalled = false;
mInstrumentation.callActivityOnPause(r.activity);
// We need to keep around the original state, in case
// we need to be created again.
r.state = oldState;
if (!r.activity.mCalled) {
throw new SuperNotCalledException(
"Activity " + r.intent.getComp
onent().toShortString() +
" did not call through to super.onPause()");
}
} catch (SuperNotCalledException e) {
throw e;
} catch (Exception e) {
if (!mInstrumentation.onException(r.activity, e)) {
throw new RuntimeException(
"Unable to pause activity "
+ r.intent.getComponent().toShortString()
+ ": " + e.toString(), e);
}
}
r.paused = true;
}
} else {
// If there was an error, for any reason, tell the activity
// manager to stop us.
try {
ActivityManagerNative.getDefault()
.finishActivity(r.token, Activity.RESULT_CANCELED, null);
} catch (RemoteException ex) {
// Ignore
}
}
}
我把这个代码全部贴出来，是因为这个很关键，首先我们看
Activity a = performLaunchActivity(r, customIntent);
申请了一个activity，这个performLaunchActivity里面代码过长就不全部粘贴了
Activity activity = null;
try {
https://www.doczj.com/doc/c84459377.html,ng.ClassLoader cl = r.packageInfo.getClassLoader();
activity = mInstrumentation.newActivity(
cl, component.getClassName(), r.intent);
StrictMode.incrementExpectedActivityCount(activity.getClass());
r.intent.setExtrasClassLoader(cl);
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);
}
}
我们可以发现先去获取了一个activity对象，然后
Application app = r.packageInfo.makeApplication(false, mInstrumentation);
创建我们的Application，接着
ContextImpl appContext = new ContextImpl();
appContext.init(r.packageInfo, r.token, this);
appContext.setOuterContext(activity);
CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
和
activity.attach(appContext, this, getInstrumentation(), r.token,
r.ident, app, r.intent, r.activityInfo, title, r.parent,
r.embeddedID, https://www.doczj.com/doc/c84459377.html,stNonConfigurationInstances, config);
这里就是我们最开始提到的ContextImpl，也就是我们当时为什么说ContextWrapper里面的mBase是ContextImpl的一个实例，也就是这样的，不行的可以去activity.attach里面看看，这里不再解释。接着
int theme = r.activityInfo.getThemeResource();
if (theme != 0) {
activity.setT
heme(theme);
}
就是设置我们的主题了，接下来就是我们的重点了
mInstrumentation.callActivityOnCreate(activity, r.state);
我们进去看看
public void callActivityOnCreate(Activity activity, Bundle icicle) {
if (mWaitingActivities != null) {
synchronized (mSync) {
final int N = mWaitingActivities.size();
for (int i=0; i
final Intent intent = aw.intent;
if (intent.filterEquals(activity.getIntent())) {
aw.activity = activity;
mMessageQueue.addIdleHandler(new ActivityGoing(aw));
}
}
}
}
activity.performCreate(icicle);
if (mActivityMonitors != null) {
synchronized (mSync) {
final int N = mActivityMonitors.size();
for (int i=0; i
am.match(activity, activity, activity.getIntent());
}
}
}
}
看到这里我们大致可以知道，我们创建activity的时候啥时候走我们的OnCreate了，也就是这里了，接着我们进去Activity中看看
final void performCreate(Bundle icicle) {
bringUpThreadPriority();
onCreate(icicle);
mVisibleFromClient = !mWindow.getWindowStyle().getBoolean(
com.android.internal.R.styleable.Window_windowNoDisplay, false);
mFragments.dispatchActivityCreated();
}
这里就是onCreate调用的地方，当我们继承了Activity的时候，走的就是我们Activity的onCreate。现在，我们回到ActivityThread的performLaunchActivity中，接着个callActivityOnCreate往下看
if (!r.activity.mFinished) {
activity.performStart();
r.stopped = false;
}
很明显了，我们去activity中看看performStart
final void performStart() {
bringUpThreadPriority();
mFragments.noteStateNotSaved();
mCalled = false;
mFragments.execPendingActions();
mInstrumentation.callActivityOnStart(this);
if (!mCalled) {
throw new SuperNotCalledException(
"Activity " + mComponent.toShortString() +
" did not call through to super.onStart()");
}
mFragments.dispatchStart();
if (mAllLoaderManagers != null) {
for (int i=mAllLoaderManagers.size()-1; i>=0; i--) {
LoaderManagerImpl lm = mAllLoaderManagers.valueAt(i);
lm.finishRetain();
lm.doReportStart();
}
}
}
也就是mInstrumentation.callActivityOnStart(this);我们进去看看
public void callActivit
yOnStart(Activity activity) {
activity.onStart();
}
这里就是我们onStart的调用的地方那个了，当我们走过onCreate之后就是onStart，也就是我们这里，当我们继承了activity的时候，走的就是我们的onStart。现在，我们回到ActivityThread的handleLaunchActivity中，刚才我们说了performLaunchActivity，现在接着看
if (a != null) {
r.createdConfig = new Configuration(mConfiguration);
Bundle oldState = r.state;
handleResumeActivity(r.token, false, r.isForward);
现在我们看看handleResumeActivity，同样我们还截取我们关心的部分
ActivityClientRecord r;
try {
r = performResumeActivity(token, clearHide);
} catch (Exception e) {
Log.e(TAG, "Exception in performResumeActivity: " + e.getMessage() + ", finish it!");
e.printStackTrace();
r = null;
}
我们看看performResumeActivity
public final ActivityClientRecord performResumeActivity(IBinder token,
boolean clearHide) {
ActivityClientRecord r = mActivities.get(token);
if (localLOGV) Slog.v(TAG, "Performing resume of " + r
+ " finished=" + r.activity.mFinished);
if (r != null && !r.activity.mFinished) {
if (clearHide) {
r.hideForNow = false;
r.activity.mStartedActivity = false;
}
try {
if (r.pendingIntents != null) {
deliverNewIntents(r, r.pendingIntents);
r.pendingIntents = null;
}
if (r.pendingResults != null) {
deliverResults(r, r.pendingResults);
r.pendingResults = null;
}
r.activity.performResume();
EventLog.writeEvent(LOG_ON_RESUME_CALLED,
r.activity.getComponentName().getClassName());
r.paused = false;
r.stopped = false;
r.state = null;
} catch (Exception e) {
if (!mInstrumentation.onException(r.activity, e)) {
throw new RuntimeException(
"Unable to resume activity "
+ r.intent.getComponent().toShortString()
+ ": " + e.toString(), e);
}
}
}
return r;
}
这里没也就是r.activity.performResume();句话了，r是ActivityClientRecord，r.activity就是Activity，r.activity.performResume就是Activity.performResume，我们进去看看
final void performResume() {
performRestart();
mFragments.execPendingActions();
mLastNonConfigurationInstances = null;
mCalled = false;
// mResumed is set by the instrumentation
mInstrumentation.callActivityOnResume(this);
if (!mCalled) {
throw new SuperNotCalledException(
"Activity " + mComponent.toShortString() +
" did not call through to super.onResume()");
}
// Now really resume, and install the current status bar and menu.
mCalled = false;
mFragments.dispatchResume();
mFragments.execPendingActions();
onPostResume();
if (!mCalled) {
throw new SuperNotCalledException(
"Activity " + mComponent.toShortString() +
" did not call through to super.onPostResume()");
}
}
这里面就是mInstrumentation.callActivityOnResume(this);了，mInstrumentation就是Instrumentation，mInstrumentation.callActivityOnResume就是
public void callActivityOnResume(Activity activity) {
activity.mResumed = true;
activity.onResume();
if (mActivityMonitors != null) {
synchronized (mSync) {
final int N = mActivityMonitors.size();
for (int i=0; i
am.match(activity, activity, activity.getIntent());
}
}
}
}
很明显了，这里就是activity.onResume();我们们onResume的调用的地方了，如果继承了Activity就是走我们子类的onResume。我们还回到ActivityThread的handleLaunchActivity中，我们刚才说了handleResumeActivity，我们接看看会发现，下面是做了一些保护了，不再赘述。
至此，activity的前半生已经讲解完毕，至于后半生，等以后有机会再做讲解，还是那句话，这些文章给大师做取乐，给后来者抛砖引玉，不要再背后骂我，就谢天谢地了。