本文共 13164 字，大约阅读时间需要 43 分钟。

美女镇楼，辟邪！

源码，是一个程序猿前进路上一个大的而又不得不去翻越障碍，我讨厌源码，看着一大堆。5000多行，要看完得啥时候去了啊。不过做安卓的总有这一天，自从踏上这条不归路，我就认命了。好吧，我慢慢来啃。先从Activity的启动流程开始，一个app启动的底层源码流程。那么我们该去哪里找源码呢，源码其实就在sdk的包里，并不遥远，只是平时我们很少去关注。（从应用层的入口开始，FrameWork层目前我还没那水平，看不明白），如果想从FrameWork层开始的童鞋，这里给个链接，去看看吧。，还有老罗讲Activity启动的更详细步骤，可以参考阅读：

首先找到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 = 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) {          // 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
   
     results = null;            List
    
      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
   
     pendingResults,              List
    
      pendingNewIntents, boolean notResumed, boolean isForward)              throws RemoteException {          Parcel data = 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);          }            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的生命周期，当然中间也省略了一些不太重要的步骤。最后附一张流程图。