序入口函数，ActivityThread的main()函数
public static void main(String[] args) {
//此处省略N行.......
//创建Lopper,主线程Looper
Looper.prepareMainLooper();
//创建ActivityThread对象
ActivityThread thread = new ActivityThread();
//false,首次启动，需要初始化
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
if (false) {
Looper.myLooper().setMessageLogging(new
LogPrinter(Log.DEBUG, "ActivityThread"));
}
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
// 主线程looper，开启死循环，不断处理按键、触摸等消息，activity的生命周期也由其处理
//若在activity的某个生命周期执行耗时操作，那么其他的消息无法及时执行，那么整个loop循环会卡顿
//时间一长，就会触发抛出ANR
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
attach()分析
private void attach(boolean system) {
sCurrentActivityThread = this;
mSystemThread = system;
//main入口传入的fasle
if (!system) {
//先走该分支代码
//先获取ActivityManagerService对象，调用ActivityManagerService的attachApplication()
final IActivityManager mgr = ActivityManagerNative.getDefault();
try {
// ======= 展开分析1 ========
mgr.attachApplication(mAppThread);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
//此处省略N行代码
} else {
try {
//Instrumentation类会在应用的任何代码执行前被实列化，用来监控系统与应用的交互
//另一个重要作用是提供Android组件单元测试。
mInstrumentation = new Instrumentation();
//应用进程conext创建 ====== 展开分析2 =======
ContextImpl context = ContextImpl.createAppContext(
this, getSystemContext().mPackageInfo);
、 //创建mInitialApplication ===== 展开分析3 ========
mInitialApplication = context.mPackageInfo.makeApplication(true, null);
mInitialApplication.onCreate();
} catch (Exception e) {
throw new RuntimeException(
"Unable to instantiate Application():" + e.toString(), e);
}
}
DropBox.setReporter(new DropBoxReporter());
ViewRootImpl.addConfigCallback(new ComponentCallbacks2() {
@Override
public void onConfigurationChanged(Configuration newConfig) {
synchronized (mResourcesManager) {
//立即将此更改应用于资源，因为在返回时，将查看视图层次结构。
if (mResourcesManager.applyConfigurationToResourcesLocked(newConfig, null)) {
updateLocaleListFromAppContext(mInitialApplication.getApplicationContext(),
mResourcesManager.getConfiguration().getLocales());
//资源被更改，发送消息通知
if (mPendingConfiguration == null ||
mPendingConfiguration.isOtherSeqNewer(newConfig)) {
mPendingConfiguration = newConfig;
sendMessage(H.CONFIGURATION_CHANGED, newConfig);
}
}
}
}
@Override
public void onLowMemory() {
}
@Override
public void onTrimMemory(int level) {
}
});
====展开分析1 ======
ActivityManagerNative，抽象类，一个Binder通信类
检索系统的默认/全局活动管理器。
static public IActivityManager getDefault() {
//这里返回的是ActivityManagerService，继承自ActivityManagerService
return gDefault.get();
}
最终调用ActivityManagerService内的attachAppliocation()
@Override
public final void attachApplication(IApplicationThread thread) {
synchronized (this) {
int callingPid = Binder.getCallingPid();
final long origId = Binder.clearCallingIdentity();
attachApplicationLocked(thread, callingPid);
Binder.restoreCallingIdentity(origId);
}
}
进入attachAoolicationLockede()
boolean attachApplicationLocked(ProcessRecord app) throws RemoteException {
final String processName = app.processName;
boolean didSomething = false;
//遍历activity栈，找到栈顶的Activity
for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
ArrayList stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
final ActivityStack stack = stacks.get(stackNdx);
if (!isFrontStack(stack)) {
continue;
}
//解锁
ActivityRecord hr = stack.topRunningActivityLocked(null);
if (hr != null) {
if (hr.app == null && app.uid == hr.info.applicationInfo.uid
&& processName.equals(hr.processName)) {
try {
//找到符合条件的Activity，真正启动Activity
if (realStartActivityLocked(hr, app, true, true)) {
didSomething = true;
}
} catch (RemoteException e) {
//此处省略N行......
}
}
}
}
}
//此处省略N行......
return didSomething;
}
realStartActivityLocked()内调用了ActivityThread的scheduleLaunchActivity()
此处给Activity赋值了各种信息，如token，在Android的Window机制中，添加Dailog、View会校验token，因此这边也会将token信息携带下去。
（如："Unable to add window -- token " + attrs.token + " is not valid; is your activity running?这类token异常。关于这块可以去了解一下窗口机制）
此段代码最重要的是最后面的sendMessage。这里发送了一个消息，交给一个名为H的handler处理。H这个handler几乎处理所有Activity的生命周期的方法。
public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,
ActivityInfo info, Configuration curConfig, Configuration overrideConfig,
CompatibilityInfo compatInfo, String referrer, IVoiceInteractor voiceInteractor,
int procState, Bundle state, PersistableBundle persistentState,
List pendingResults, List pendingNewIntents,
boolean notResumed, boolean isForward, ProfilerInfo profilerInfo) {
updateProcessState(procState, false);
ActivityClientRecord r = new ActivityClientRecord();
//赋值各类信息信息
r.token = token;
r.ident = ident;
r.intent = intent;
r.referrer = referrer;
r.voiceInteractor = voiceInteractor;
r.activityInfo = info;
r.compatInfo = compatInfo;
r.state = state;
r.persistentState = persistentState;
r.pendingResults = pendingResults;
r.pendingIntents = pendingNewIntents;
r.startsNotResumed = notResumed;
r.isForward = isForward;
r.profilerInfo = profilerInfo;
r.overrideConfig = overrideConfig;
updatePendingConfiguration(curConfig);
//发送启动Activity的消息，使用内部继承Handelr的H，在ActivityThread创建时初始化
sendMessage(H.LAUNCH_ACTIVITY, r);
}
来看一下H的处理
handleMessage内调用handleLaunchActivity()
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);
} bre
private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {
unscheduleGcIdler();
//此处省略N行.........
//初始化WindowManagerGlobal
WindowManagerGlobal.initialize();
// ======== performLaunchActivity()内部 ============
//1.加载Activity的class类，执行其attach()
//2.调用mInstrumentation.callActivityOnCreate，最终调用Activity的onCreate()
//3.调用Activity的start()方法
Activity a = performLaunchActivity(r, customIntent);
if (a != null) {
r.createdConfig = new Configuration(mConfiguration);
reportSizeConfigurations(r);
Bundle oldState = r.state;
// ========= handleResumeActivity（）内部 ==============
//1.获取window，创建DecorView对象
//2.获取windowManager，将DecorView添加到wm，此时开启view的测量，布局，绘制等等
//3.使Activity可见
handleResumeActivity(r.token, false, r.isForward,
!r.activity.mFinished && !r.startsNotResumed, r.lastProcessedSeq, reason);
if (!r.activity.mFinished && r.startsNotResumed) {
performPauseActivityIfNeeded(r, reason);
if (r.isPreHoneycomb()) {
r.state = oldState;
}
}
} else {
try {
ActivityManagerNative.getDefault()
.finishActivity(r.token, Activity.RESULT_CANCELED, null,
Activity.DONT_FINISH_TASK_WITH_ACTIVITY);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
}
}
====展开分析2 ======
ContextImpl（继承自Context）的构造方法，所以返回的是Context
简要看下一源码，针对Context的分析，后续会展开一篇文章，有兴趣的话，可以关注我~~
static ContextImpl createAppContext(ActivityThread mainThread, LoadedApk packageInfo) {
if (packageInfo == null) throw new IllegalArgumentException("packageInfo");
return new ContextImpl(null, mainThread,
packageInfo, null, null, 0, null, null, Display.INVALID_DISPLAY);
}
private ContextImpl(ContextImpl container, ActivityThread mainThread,
LoadedApk packageInfo, IBinder activityToken, UserHandle user, int flags,
Display display, Configuration overrideConfiguration, int createDisplayWithId) {
mOuterContext = this;
//如果创建者没有指定使用哪个存储，则使用默认的应用程序位置。
if ((flags & (Context.CONTEXT_CREDENTIAL_PROTECTED_STORAGE
| Context.CONTEXT_DEVICE_PROTECTED_STORAGE)) == 0) {
//此处省略N行代码
}
//传入ActvityThread
mMainThread = mainThread;
//传入activityToken
mActivityToken = activityToken;
mFlags = flags;
if (user == null) {
user = Process.myUserHandle();
}
mUser = user;
mPackageInfo = packageInfo;
//初始化ResourcesManager实例，用以获取资源文件
mResourcesManager = ResourcesManager.getInstance();
///此处省略N行代码...........
}
======展开分析3 =========
LoadApk类,调用makeApplication(）入参（true，null）。
public Application makeApplication(boolean forceDefaultAppClass,
Instrumentation instrumentation) {
//此处省略N行............
try {
java.lang.ClassLoader cl = getClassLoader();
//此处省略N行............
ContextImpl appContext = ContextImpl.createAppContext(mActivityThread, this);
//通过mInstrumentation创建Application
//
======= 展开分析4 =========
app = mActivityThread.mInstrumentation.newApplication(
cl, appClass, appContext);
appContext.setOuterContext(app);
} catch (Exception e) {
//此处省略N行............
}
mActivityThread.mAllApplications.add(app);
mApplication = app;
if (instrumentation != null) {
try {
instrumentation.callApplicationOnCreate(app);
} catch (Exception e) {
//此处省略N行............
}
//此处省略N行............
return app;
}
=======展开分析4=======
Instrumetation类，创建Application，调用attach(context)
public Application newApplication(ClassLoader cl, String className, Context context)
throws InstantiationException, IllegalAccessException,
ClassNotFoundException {
return newApplication(cl.loadClass(className), context);
}
static public Application newApplication(Class clazz, Context context)
throws InstantiationException, IllegalAccessException,
ClassNotFoundException {
Application app = (Application)clazz.newInstance();
app.attach(context);
return app;
}