美女镇楼，辟邪！
源码，是一个程序猿前进路上一个大的而又不得不去翻越障碍，我讨厌源码，看着一大堆。5000多行，要看完得啥时候去了啊。不过做安卓的总有这一天，自从踏上这条不归路，我就认命了。好吧，我慢慢来啃。先从Activity的启动流程开始，一个app启动的底层源码流程。那么我们该去哪里找源码呢，源码其实就在sdk的包里，并不遥远，只是平时我们很少去关注。（从应用层的入口开始，FrameWork层目前我还没那水平，看不明白），如果想从FrameWork层开始的童鞋，这里给个链接，去看看吧。http://www.jianshu.com/p/6037f6fda285，还有老罗讲Activity启动的更详细步骤，可以参考阅读：http://blog.csdn.net/luoshengyang/article/details/6689748
首先找到sdk文件夹目录，打开source文件夹，我选的是android-21目录，在继续打开android文件夹，继续打开app文件夹，找到ActivityThread.java文件，这就是我们平时所说的UI线程（主线程）。
图 1
在打开Android Studio,直接把这个文件用鼠标拖入Studio界面即可。那么开始我们探索源码之路了。
首先，找到整个java文件的入口，不用问大家都知道，main函数，是所有java文件的入口。直接ctrl+F,搜索main，找到入口。开始怼他！
图2
这里不对每句代码进行详细解释，我们只撸对Activity启动有作用的代码。用过Handler的童鞋都知道，Handler是线程之间通讯的工具。第5205行代码，Looper.prepareMianLooper();就是为UI线程绑定Looper和MessageQueue，一个线程中只能有一个Looper和一个MessageQueue，可以有多个Handler这也是为什么我们平时在Activity的住线程中使用Handler传送消息时，只需要创建Handler不需要管Looper和MessageQueue的原因。
我们只需关心主线程做了哪些操作，其他的先不管。第5207行代码创建了ActivityThread的对象，同时调用了一个attach传入一个false。那么找到attach方法。
图3
初始化传入的是false，那么只看if（！system）里的代码，继续寻找和Activity有关的代码，看到5054行代码，创建了一个ActivityManager，这是Activity的管理器，那么我们在看看ActivityManagerNative这个类的getDefault()这个方法，默认返回的ActivityManager里有什么样的配置。找到源码包，搜索ActivityManagerNative，拖入Studio。
图4
这里通过gDefault对象的get()返回IActivityManager，那么看看gDefault又是什么呢。
图5
这里采用IBinder机制，通过ServiceManager获得activity的服务，调用asInterface(IBinder)方法，获得IActivityManager。再看看asInterface（）方法。
图6
这里最后返回的是一个ActivityManagerProxy对象，通过代理设计模式来创建实现了IActivityManager接口的类的对象。
再回到图3ActivityThread中，获得了ActivityManager之后，第5056行调用attachApplication()，传入applicationThread类型的Binder对象。那么看一下ActivityManagerProxy的源码。
class ActivityManagerProxy implements IActivityManager
{
...... public void attachApplication(IApplicationThread app) throws RemoteException
{
Parcel data = http://blog.csdn.net/sw5131899/article/details/Parcel.obtain();
Parcel reply = Parcel.obtain();
data.writeInterfaceToken(IActivityManager.descriptor);
data.writeStrongBinder(app.asBinder());
mRemote.transact(ATTACH_APPLICATION_TRANSACTION, data, reply, 0);
reply.readException();
data.recycle();
reply.recycle();
} ...... }
这里通过Binder驱动程序，最后进入ActivityManagerService的attachApplication函数中。那么我们看看ActivityManagerService中的attachApplication函数。
图7
在这个方法中调用了attachApplicationLocked()方法，这里将操作转发给attachApplicationLocked函数。
public final class ActivityManagerService extends ActivityManagerNative
implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback { ...... private final boolean attachApplicationLocked(IApplicationThread thread,
int pid) { http://www.90168.org/
// Find the application record that is being attached... either via
// the pid if we are running in multiple processes, or just pull the
// next app record if we are emulating process with anonymous threads.
ProcessRecord app;
if (pid != MY_PID && pid >= 0) {
synchronized (mPidsSelfLocked) {
app = mPidsSelfLocked.get(pid);
}
} else if (mStartingProcesses.size() > 0) {
......
} else {
......
} if (app == null) {
......
return false;
} ...... String processName = app.processName;
try {
thread.asBinder().linkToDeath(new AppDeathRecipient(
app, pid, thread), 0);
} catch (RemoteException e) {
......
return false;
} ...... app.thread = thread;
app.curAdj = app.setAdj = -100;
app.curSchedGroup = Process.THREAD_GROUP_DEFAULT;
app.setSchedGroup = Process.THREAD_GROUP_BG_NONINTERACTIVE;
app.forcingToForeground = null;
app.foregroundServices = false;
app.debugging = false; ...... boolean normalMode = mProcessesReady || isAllowedWhileBooting(app.info); ...... boolean badApp = false;
boolean didSomething = false; // See if the top visible activity is waiting to run in this process...
ActivityRecord hr = mMainStack.topRunningActivityLocked(null);
if (hr != null && normalMode) {
if (hr.app == null && app.info.uid == hr.info.applicationInfo.uid
&& processName.equals(hr.processName)) {
try {
if (mStackSupervisor.realStartActivityLocked(hr, app, true, true)) {
didSomething = true;
}
} catch (Exception e) {
......
}
} else {
......
}
} ...... return true;
} ...... }
这里创建了一个ProcessRecord，首先通过pid将它取回来，放在app变量中，然后对app的其它成员进行初始化，最后调用
mStacksupervisor.realStartActivityLocked执行真正的Activity启动操作。这里要启动的Activity通过调用mStacksupervisor.topRunningActivityLocked(null)从堆栈顶端取回来，这时候在堆栈顶端的Activity就是MainActivity了。那么继续来看ActivityStackSupervisor.realStartActivityLocked（）的源码.
final boolean realStartActivityLocked(ActivityRecord r,
ProcessRecord app, boolean andResume, boolean checkConfig)
throws RemoteException { ....
r.app = app;
....
int idx = app.activities.indexOf(r);
if (idx < 0) {
app.activities.add(r);
}
...
try {
if (app.thread == null) {
throw new RemoteException();
}
List<ResultInfo> results = null;
List<Intent> newIntents = null;
...
app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,
System.identityHashCode(r), r.info, new Configuration(mService.mConfiguration),
r.compat, r.task.voiceInteractor, app.repProcState, r.icicle, r.persistentState,
results, newIntents, !andResume, mService.isNextTransitionForward(),
profilerInfo); ..... } catch (RemoteException e) {
..
} ... return true;
}
这里最终通过app.thread进入到ApplicationThreadProxy的scheduleLaunchActivity函数中，注意，这里的第二个参数r，是一个ActivityRecord类型的Binder对象，用来作来这个Activity的token值。app.thread.scheduleLaunchActivity调用的是ApplicationThreadProxy的方法，那么再看看ApplicationThreadProxy。
class ApplicationThreadProxy implements IApplicationThread {
......
public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,
ActivityInfo info, Bundle state, List<ResultInfo> pendingResults,
List<Intent> pendingNewIntents, boolean notResumed, boolean isForward)
throws RemoteException { www.90168.org
Parcel data = http://blog.csdn.net/sw5131899/article/details/Parcel.obtain();
data.writeInterfaceToken(IApplicationThread.descriptor);
intent.writeToParcel(data, 0);
data.writeStrongBinder(token);
data.writeInt(ident);
info.writeToParcel(data, 0);
data.writeBundle(state);
data.writeTypedList(pendingResults);
data.writeTypedList(pendingNewIntents);
data.writeInt(notResumed ? 1 : 0);
data.writeInt(isForward ? 1 : 0);
mRemote.transact(SCHEDULE_LAUNCH_ACTIVITY_TRANSACTION, data, null,
IBinder.FLAG_ONEWAY);
data.recycle();
}
......
}
函数首先创建一个ActivityClientRecord实例，并且初始化它的成员变量，然后调用ActivityThread类的queueOrSendMessage函数进一步处理。那么再来看看ActivityThread源码的queueOrSendMessage。
public final class ActivityThread {
......
private final class ApplicationThread extends ApplicationThreadNative {
......
// if the thread hasn't started yet, we don't have the handler, so just
// save the messages until we're ready.
private final void queueOrSendMessage(int what, Object obj) {
queueOrSendMessage(what, obj, 0, 0);
}
......
private final void queueOrSendMessage(int what, Object obj, int arg1, int arg2) {
synchronized (this) {
......
Message msg = Message.obtain();
msg.what = what;
msg.obj = obj;
msg.arg1 = arg1;
msg.arg2 = arg2;
mH.sendMessage(msg);
}
}
......
}
......
}
函数把消息内容放在msg中，然后通过mH把消息分发出去，这里的成员变量mH我们在前面已经见过，消息分发出去后，最后会调用H类的handleMessage函数。 这里最后调用ActivityThread类的handleLaunchActivity函数进一步处理。再看看handleLaunchActivity();
public final class ActivityThread {
......
private final void handleLaunchActivity(ActivityClientRecord r, Intent customIntent) {
......
Activity a = performLaunchActivity(r, customIntent);
if (a != null) {
r.createdConfig = new Configuration(mConfiguration);
Bundle oldState = r.state;
handleResumeActivity(r.token, false, r.isForward);
......
} else {
......
}
}
......
}
这里首先调用performLaunchActivity函数来加载这个Activity类，即activity.MainActivity，然后调用它的onCreate函数，最后回到handleLaunchActivity函数时，再调用handleResumeActivity函数来使这个Activity进入Resumed状态，即会调用这个Activity的onResume函数，这是遵循Activity的生命周期的。再看performLaunchActivity的源码。
public final class ActivityThread {
......
private final Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
ActivityInfo aInfo = r.activityInfo;
if (r.packageInfo == null) {
r.packageInfo = getPackageInfo(aInfo.applicationInfo,
Context.CONTEXT_INCLUDE_CODE);
} http://www.90168.org/
ComponentName component = r.intent.getComponent();
if (component == null) {
component = r.intent.resolveActivity(
mInitialApplication.getPackageManager());
r.intent.setComponent(component);
}
if (r.activityInfo.targetActivity != null) {
component = new ComponentName(r.activityInfo.packageName,
r.activityInfo.targetActivity);
}
Activity activity = null;
try {
java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
activity = mInstrumentation.newActivity(
cl, component.getClassName(), r.intent);
r.intent.setExtrasClassLoader(cl);
if (r.state != null) {
r.state.setClassLoader(cl);
}
} catch (Exception e) {
......
}
try {
Application app = r.packageInfo.makeApplication(false, mInstrumentation);
......
if (activity != null) {
ContextImpl appContext = new ContextImpl();
appContext.init(r.packageInfo, r.token, this);
appContext.setOuterContext(activity);
CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
Configuration config = new Configuration(mConfiguration);
......
activity.attach(appContext, this, getInstrumentation(), r.token,
r.ident, app, r.intent, r.activityInfo, title, r.parent,
r.embeddedID, r.lastNonConfigurationInstance,
r.lastNonConfigurationChildInstances, config);
if (customIntent != null) {
activity.mIntent = customIntent;
}
r.lastNonConfigurationInstance = null;
r.lastNonConfigurationChildInstances = null;
activity.mStartedActivity = false;
int theme = r.activityInfo.getThemeResource();
if (theme != 0) {
activity.setTheme(theme);
}
activity.mCalled = false;
mInstrumentation.callActivityOnCreate(activity, r.state);
......
r.activity = activity;
r.stopped = true;
if (!r.activity.mFinished) {
activity.performStart();
r.stopped = false;
}
if (!r.activity.mFinished) {
if (r.state != null) {
mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);
}
}
if (!r.activity.mFinished) {
activity.mCalled = false;
mInstrumentation.callActivityOnPostCreate(activity, r.state);
if (!activity.mCalled) {
throw new SuperNotCalledException(
"Activity " + r.intent.getComponent().toShortString() +
" did not call through to super.onPostCreate()");
}
}
}
r.paused = true;
mActivities.put(r.token, r);
} catch (SuperNotCalledException e) {
......
} catch (Exception e) {
......
}
return activity;
}
......
}
从上面可以看到，mInrumentation.callActivityOncreate()，那么在这里进正式进入了Activity的onCreate()方法了。之后会依次调用Activity的生命周期方法。调用生命周期方法的类都是Intrumentation。
到这里就差不多了，应用层从入口到Activity启动调用Activity的生命周期，当然中间也省略了一些不太重要的步骤。最后附一张流程图。