通常情况下我们使用LayoutInflater较为常见的地方是ListView的getView中：
View view = LayoutInflater.from(context).inflate(R.layout.xxx, null);
通常情况下我们使用LayoutInflater.from(context)来获取LayoutInflater服务，我们来看看LayoutInflater服务是如何实现的。
public static LayoutInflater from(Context context) {
LayoutInflater LayoutInflater =
(LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
if (LayoutInflater == null) {
throw new AssertionError("LayoutInflater not found.");
}
return LayoutInflater;
}
可以看到from(context)是通过context.getSystemService(Context.LAYOUT_INFLATER_SERVICE)方法，继续跟踪之后，得知Context类是个抽象类。
而getView中使用的context的实现类是什么呢？
在每个Activity、Service、Application中都存在一个Context对象，所以Context对象的总个数为Activity+Service+1。而ListView通常情况下出现在Activity中，所以我们以Activity的Context对象来分析。
一个Activity的入口是ActivityThread的main函数，在main函数中创建ActivityThread对象，并且启动Handler，创建新的Activity、新的Context对象，并将该对象传递给Activity
public static void main(String[] args) {
Process.setArgV0("<pre-initialized>");
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
if (false) {
Looper.myLooper().setMessageLogging(new
LogPrinter(Log.DEBUG, "ActivityThread"));
}
// End of event ActivityThreadMain.
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
Looper.loop();
}
在main函数中，创建并调用了attach方法传递false(非系统应用)
private void attach(boolean system) {
sCurrentActivityThread = this;
mSystemThread = system;
if (!system) {
ViewRootImpl.addFirstDrawHandler(new Runnable() {
@Override
public void run() {
ensureJitEnabled();
}
});
android.ddm.DdmHandleAppName.setAppName("<pre-initialized>",
UserHandle.myUserId());
RuntimeInit.setApplicationObject(mAppThread.asBinder());
final IActivityManager mgr = ActivityManagerNative.getDefault();
try {
mgr.attachApplication(mAppThread);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
}
}
在attach方法中通过Binder机制和ActivityManagerService通信，最终调用handleLaunchActivity方法
private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {
Activity a = performLaunchActivity(r, customIntent);
}
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
Activity activity = null;
try {
java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
// 创建activity
activity = mInstrumentation.newActivity(
cl, component.getClassName(), r.intent);
} catch (Exception e) {
if (!mInstrumentation.onException(activity, e)) {
throw new RuntimeException(
"Unable to instantiate activity " + component
+ ": " + e.toString(), e);
}
}
try {
// 创建Application
Application app = r.packageInfo.makeApplication(false, mInstrumentation);
if (activity != null) {
// 创建Context
Context appContext = createBaseContextForActivity(r, activity);
CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
Configuration config = new Configuration(mCompatConfiguration);
// 将相关对象attach到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);
// 调用onCreate方法
if (r.isPersistable()) {
mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
} else {
mInstrumentation.callActivityOnCreate(activity, r.state);
}
}
r.paused = true;
mActivities.put(r.token, r);
} catch (SuperNotCalledException e) {
throw e;
}
return activity;
}
private Context createBaseContextForActivity(ActivityClientRecord r, final Activity activity) {
// 创建Context对象
ContextImpl appContext = ContextImpl.createActivityContext(
this, r.packageInfo, r.token, displayId, r.overrideConfig);
return baseContext;
}
最终我们可以发现创建的Context对象的实现类是ContextImpl。我们继续观察ContextImpl：
// The system service cache for the system services that are cached per-ContextImpl.
// 获取系统服务
final Object[] mServiceCache = SystemServiceRegistry.createServiceCache();
在SystemServiceRegistry中：
// service容器
private static final HashMap<String, ServiceFetcher<?>> SYSTEM_SERVICE_FETCHERS = new HashMap<String, ServiceFetcher<?>>();
// 注册服务器
private static <T> void registerService(String serviceName, Class<T> serviceClass,
ServiceFetcher<T> serviceFetcher) {
SYSTEM_SERVICE_NAMES.put(serviceClass, serviceName);
// 将服务放到service容器中
SYSTEM_SERVICE_FETCHERS.put(serviceName, serviceFetcher);
}
// 静态代码块，当第一次加载该类的时候就将执行将服务创建出来
static {
registerService(Context.ACCESSIBILITY_SERVICE, AccessibilityManager.class,
new CachedServiceFetcher<AccessibilityManager>() {
@Override
public AccessibilityManager createService(ContextImpl ctx) {
return AccessibilityManager.getInstance(ctx);
}});
...
}
// 获取系统服务
public static Object getSystemService(ContextImpl ctx, String name) {
ServiceFetcher<?> fetcher = SYSTEM_SERVICE_FETCHERS.get(name);
return fetcher != null ? fetcher.getService(ctx) : null;
}
在ContextImpl中，当虚拟机第一次加载的时候就会注册各种服务，其中就包含LayoutInflater Service，将这些服务以键值对的形式存储在map中，当使用的时候只要通过key就可以获取对应的服务对象。
在静态代码块中，我们终于找到了LayoutInflater注册的代码：
registerService(Context.LAYOUT_INFLATER_SERVICE, LayoutInflater.class,
new CachedServiceFetcher<LayoutInflater>() {
@Override
public LayoutInflater createService(ContextImpl ctx) {
return new PhoneLayoutInflater(ctx.getOuterContext());
}});
原来LayoutInflater是通过PhoneLayoutInflater创建出来的，我们再找到PhoneLayoutInflater类：
public class PhoneLayoutInflater extends LayoutInflater {
private static final String[] sClassPrefixList = {
"android.widget.",
"android.webkit.",
"android.app."
};
public PhoneLayoutInflater(Context context) {
super(context);
}
protected PhoneLayoutInflater(LayoutInflater original, Context newContext) {
super(original, newContext);
}
/** Override onCreateView to instantiate names that correspond to the
widgets known to the Widget factory. If we don't find a match,
call through to our super class.
*/
@Override protected View onCreateView(String name, AttributeSet attrs) throws ClassNotFoundException {
for (String prefix : sClassPrefixList) {
try {
View view = createView(name, prefix, attrs);
if (view != null) {
return view;
}
} catch (ClassNotFoundException e) {
// In this case we want to let the base class take a crack
// at it.
}
}
return super.onCreateView(name, attrs);
}
public LayoutInflater cloneInContext(Context newContext) {
return new PhoneLayoutInflater(this, newContext);
}
}
核心方法就是onCreateView方法，该方法通过将传递过来的View前面加上"android.widget.","android.webkit.","android.app."用来得到该内置View对象的完整路径，最后根据路径来创建出对应的View。
