文章参考《Android进阶解密》一书
一、概述
Context也就是上下文对象，是Android的常用类，Android四大组件都会涉及到Context，比如我们启动Service会调用ContextWrapper以及ContextImpl的startService方法，ContextWrapper以及ContextImpl就是Context的关联类。
二、Context的关联类
Context意为上下文，是一个应用程序环境信息的接口。在我们使用时一般分为两种：
- 使用Context调用方法，比如启动Activity、访问资源、调用系统级服务等
- 调用方法时传入Context，比如弹出Toast、Dialog等
Activity、Service、Application都间接地继承自Context，因此我们可以计算出一个应用程序的Context数量，等于Activity和Service的数量加1,1指的是Application数量。
Context是一个抽象类，它的内部定义了很多方法以及静态常量，它的具体实现类为ContextImpl。和Context相关联的类，除了ContextImpl,还有ContextWrapper、ContextThemeWrapper和Activity等，如下图：
从上图可以看出ContextWrapper、Context继承自Context，ContextWrapper内部包含Context类型的mBase对象，mBase对象只想ContextImpl.ContextImpl提供了很多功能，ContextWrapper是一个装饰类，对ContextImpl进行包装，ContextWrapper主要是起到了方法传递的功能，ContextWrapper几乎所有的方法都是调用ContextImpl的相应方法实现的。ContextThemeWrapper、Activity、Service都继承自ContextWrapper，这样它们就可以通过mBase使用Context的功能了。Activity有主题的相关设置，所以继承了ContextThemeWrapper里面有设置或者gettheme的方法。<br />Context的关联类采用了装饰模式，主要有以下优点：
- 使用者可以更方便的使用Context
- 如果ContextImpl发生改变，不需要修改其它地方的代码
- ContextImpl的实现不会暴露给使用者，使用者也无需要关心ContextImpl的实现。
- 通过组合而非继承的方式，拓展ContextImpl的功能，在运行时选择不同的装饰类，实现不同的功能。
下面我们来分别讲解一下个Context的创建过程。
三、Application Context的创建过程
调用getApplicationContext来获取全局的Application Context。应用程序启动完成后，应用程序就会有一个全局的Application Context。我们从应用程序的启动过程开始。<br />ActivityThread作为应用程序的主线程管理类，它会调用它的内部类ApplicationThread色scheduleLaunchActivity方法来启动Activity
// we use token to identify this activity without having to send the
// activity itself back to the activity manager. (matters more with ipc)
@Override
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<ResultInfo> pendingResults, List<ReferrerIntent> 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);
sendMessage(H.LAUNCH_ACTIVITY, r);
}
应用启动以后启动Activity会通过Binder跨进程调用ActivityManagerService（AMS）里面，AMS里面持有ApplicationThread的IBinder引用，跨进程调用scheduleLaunchActivity方法，scheduleLaunchActivity最后通过Handler发送H.LAUNCH_ACTIVITY消息，最后调用ActivityThread的handleLaunchActivity方法。
private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {
// If we are getting ready to gc after going to the background, well
// we are back active so skip it.
unscheduleGcIdler();
mSomeActivitiesChanged = true;
if (r.profilerInfo != null) {
mProfiler.setProfiler(r.profilerInfo);
mProfiler.startProfiling();
}
// Make sure we are running with the most recent config.
handleConfigurationChanged(null, null);
if (localLOGV) Slog.v(
TAG, "Handling launch of " + r);
// Initialize before creating the activity
WindowManagerGlobal.initialize();
Activity a = performLaunchActivity(r, customIntent);
if (a != null) {
r.createdConfig = new Configuration(mConfiguration);
reportSizeConfigurations(r);
Bundle oldState = r.state;
handleResumeActivity(r.token, false, r.isForward,
!r.activity.mFinished && !r.startsNotResumed, r.lastProcessedSeq, reason);
............
}
} else {
// If there was an error, for any reason, tell the activity manager to stop us.
try {
ActivityManager.getService()
.finishActivity(r.token, Activity.RESULT_CANCELED, null,
Activity.DONT_FINISH_TASK_WITH_ACTIVITY);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
}
}
然后调用performLaunchActivity方法
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
// System.out.println("##### [" + System.currentTimeMillis() + "] ActivityThread.performLaunchActivity(" + r + ")");
。。。。。。。
try {
Application app = r.packageInfo.makeApplication(false, mInstrumentation);
。。。。。。。
return activity;
}
这里简化了一下代码，最后会调用ActivityClientRecord.packageInfo.makeApplication()
public Application makeApplication(boolean forceDefaultAppClass,
Instrumentation instrumentation) {
if (mApplication != null) {
return mApplication;
}
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "makeApplication");
Application app = null;
String appClass = mApplicationInfo.className;
if (forceDefaultAppClass || (appClass == null)) {
appClass = "android.app.Application";
}
try {
。。。。。。。
ContextImpl appContext = ContextImpl.createAppContext(mActivityThread, this);
app = mActivityThread.mInstrumentation.newApplication(
cl, appClass, appContext);
appContext.setOuterContext(app);
} catch (Exception e) {
。。。。。。。。
}
mActivityThread.mAllApplications.add(app);
mApplication = app;
if (instrumentation != null) {
try {
instrumentation.callApplicationOnCreate(app);
} catch (Exception e) {
。。。。。。。。。。。
}
}
return app;
}
当mApplication不为null时，直接返回mApplication，如果第一次启动程序mApplication为null，通过ContextImpl.createAppContext来创建ContextImpl。mActivityThread.mInstrumentation.newApplication中传入参数ClassLoader和上面的ContextImpl对象创建Application，然后又将app赋值给ContextImpl的mOuterContext，这样COntext也持有Application的引用了，最后将Application赋值给LoadedApk的mApplication，mApplication就是Application类型的对象。下面的代码就是Application的创建方法：
static public Application newApplication(Class<?> clazz, Context context)
throws InstantiationException, IllegalAccessException,
ClassNotFoundException {
Application app = (Application)clazz.newInstance();
app.attach(context);
return app;
}
这里是通过反射来创建Application，并调用了attach方法，将ContextImpl传进去，最后返回该Application。
/**
* @hide
*/
/* package */ final void attach(Context context) {
attachBaseContext(context);
mLoadedApk = ContextImpl.getImpl(context).mPackageInfo;
}
这里调用了attachBaseContext(context)，在Application的父类ContextWrapper里面调用
protected void attachBaseContext(Context base) {
if (mBase != null) {
throw new IllegalStateException("Base context already set");
}
mBase = base;
}
将ContextImpl赋值给mBase,ContextImpl也是Context的实现类，将ContextImpl赋值给ContextWrapper的mBase,这样ContextWrapper就可以用mBase调用Context里面的方法了，而Application继承自ContextWrapper，所以Application也可以调用Context里面的方法了。
四、Activity Context的创建过程
Activity的Context也是在performLaunchActivity方法创建的。
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
// System.out.println("##### [" + System.currentTimeMillis() + "] ActivityThread.performLaunchActivity(" + r + ")");
。。。。。。
ContextImpl appContext = createBaseContextForActivity(r);
Activity activity = null;
try {
java.lang.ClassLoader cl = appContext.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);
}
}
try {
Application app = r.packageInfo.makeApplication(false, mInstrumentation);
if (localLOGV) Slog.v(TAG, "Performing launch of " + r);
if (localLOGV) Slog.v(
TAG, r + ": app=" + app
+ ", appName=" + app.getPackageName()
+ ", pkg=" + r.packageInfo.getPackageName()
+ ", comp=" + r.intent.getComponent().toShortString()
+ ", dir=" + r.packageInfo.getAppDir());
if (activity != null) {
CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
Configuration config = new Configuration(mCompatConfiguration);
if (r.overrideConfig != null) {
config.updateFrom(r.overrideConfig);
}
if (DEBUG_CONFIGURATION) Slog.v(TAG, "Launching activity "
+ r.activityInfo.name + " with config " + config);
Window window = null;
if (r.mPendingRemoveWindow != null && r.mPreserveWindow) {
window = r.mPendingRemoveWindow;
r.mPendingRemoveWindow = null;
r.mPendingRemoveWindowManager = null;
}
appContext.setOuterContext(activity);
activity.attach(appContext, this, getInstrumentation(), r.token,
r.ident, app, r.intent, r.activityInfo, title, r.parent,
r.embeddedID, r.lastNonConfigurationInstances, config,
r.referrer, r.voiceInteractor, window, r.configCallback);
}
}
return activity;
}
首先通过 createBaseContextForActivity(r)创建ContextImpl实例appContext，将创建的Activity设置到ContextImpl的outContext，这样Context里面就可以访问Activity的变量和方法，最后Activity的attach方法，将ContextImpl对象传进去。这后面跟Application差不多，会在Activity的attach方法调用attachBaseContext(context)方法，将ContextImpl复制给ContextWrapper的mBase引用，Activity继承自ContextWrapper，这样Activity就可以调用Context里面的方法了。
五、Service Context的创建过程
Service的Context创建其实跟上面两个差不多，只不过是在Service类里面执行，此处就不过多叙述了。大家自己去看源码就可以了
