安卓源码分析——LayoutInflater(上)
安卓源码分析——LayoutInflater(下)
前言
LayoutInflater是安卓开发中举足轻重的一个类，通过该类对象我们可以动态加载res/layout/下的xml布局文件，并且实例化。此外，在最近的学习中发现许多文章对于LayoutInflater的解析还是旧版sdk的源码分析，由于源码发生了一些改动，因此根据android-28的源码重新分析LayoutInflater。
第一部分 LayoutInflater基础
1 获取LayoutInflater对象
获取LayoutInflater有三种方式：
LayoutInflater inflater = LayoutInflater.from(context)
LayoutInflater inflater = (LayoutInflater) context.getSystemService(LAYOUT_INFLATER_SERVICE);
LayoutInflater inflater = getLayoutInflater();
2 加载布局文件
调用inflate()方法加载布局文件
public View inflate(@LayoutRes int resource, @Nullable ViewGroup root) {
return inflate(resource, root, root != null);
}
| 参数 | 含义 |
|---|---|
| resource | res/layout/下的xml布局文件，例如R.layout.layout_warn |
| root | 待加载布局的父布局，一般不需要父布局可以设置为null |
可以看出LayoutInflater的使用十分简单，只需以上两个步骤即可实现自定义布局的动态加载。那么布局加载背后的实现过程又是什么样的，接下来我们将进行一步步的详细分析。
第二部分 源码分析
1 LayoutInflater.from()方法
首先我们查看LayoutInflater的源代码：
//源文件 LayoutInflater.Java
public abstract class LayoutInflater {
private static final String TAG = LayoutInflater.class.getSimpleName();
private static final boolean DEBUG = false;
protected LayoutInflater(Context context) {
mContext = context;
}
protected LayoutInflater(LayoutInflater original, Context newContext) {
mContext = newContext;
mFactory = original.mFactory;
mFactory2 = original.mFactory2;
mPrivateFactory = original.mPrivateFactory;
setFilter(original.mFilter);
}
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;
}
}
注意LayoutInflater的构造函数为protected属性，使得客户程序不能随意创建LayoutInflater对象，但是又能保证子类以及包内类可以访问。
通过源码可以发现LayoutInflater.from()方法是使用context.getSystemService()方法实现的。
2 context.getSystemService() 方法
//源文件 Context.Java
public abstract class Context {
@StringDef({
POWER_SERVICE,
WINDOW_SERVICE,
LAYOUT_INFLATER_SERVICE,
//Context中定义的各类服务字符串名称
...
SHORTCUT_SERVICE,
//@hide: CONTEXTHUB_SERVICE,
SYSTEM_HEALTH_SERVICE,
//@hide: INCIDENT_SERVICE
})
...
public abstract @Nullable Object getSystemService(@ServiceName @NonNull String name);
...
}
Context是一个抽象类，其中定义了抽象方法getSystemService(),那么我们就需要找到Context的实现类。安卓源码中Context的实现类是ContextImpl类。
3 ContextImpl类
//源文件ContextImpl.Java
class ContextImpl extends Context {
...
@Override
public Object getSystemService(String name) {
return SystemServiceRegistry.getSystemService(this, name);
}
...
}
ContextImpl类中调用了SystemServiceRegistry类的静态方法getSystemService()。传递的参数this为Context引用，name值为Context.LAYOUT_INFLATER_SERVICE。
4 SystemServiceRegistry类
//源文件 SystemServiceRegistry.Java
//final类，不可继承
final class SystemServiceRegistry {
...
// 根据类类型获取名称的HasMap容器
private static final HashMap<Class<?>, String> SYSTEM_SERVICE_NAMES =
new HashMap<Class<?>, String>();
// 根据服务名称获取具体服务的HashMap容器
private static final HashMap<String, ServiceFetcher<?>> SYSTEM_SERVICE_FETCHERS =
new HashMap<String, ServiceFetcher<?>>();
private static int sServiceCacheSize;
//构造函数私有，不可创建实例
private SystemServiceRegistry() { }
//获取系统服务对象方法
public static Object getSystemService(ContextImpl ctx, String name) {
// 根据服务名称获取对应的ServiceFetcher对象
ServiceFetcher<?> fetcher = SYSTEM_SERVICE_FETCHERS.get(name);
// 获取到ServiceFetcher对象，则调用getService获取具体服务
return fetcher != null ? fetcher.getService(ctx) : null;
}
...
ServiceFetcher是SystemServiceRegistry类中定义的的一个内部接口，其定义为：
//源文件 SystemServiceRegistry.Java
static abstract interface ServiceFetcher<T> {
T getService(ContextImpl ctx);
}
SYSTEM_SERVICE_FETCHERS是一个HashMap容器，键的类型为String类型,即服务的名称，存储的对象类型为ServiceFetcher，当调用ServiceFetcher<?> fetcher = SYSTEM_SERVICE_FETCHERS.get(name);时，会根据name的值来获取服务的ServiceFetcher对象，ServiceFetcher对象中的getService()方法即可获取相应的服务类。
既然有get获取对象的方法，那就有put方法将不同服务的对象放在HashMap容器中，那么各类服务是什么时候注册的呢？可以发SystemServiceRegistry.Java中有如下一段静态代码块：
//源文件 SystemServiceRegistry.Java
static {
//注册辅助功能服务
registerService(Context.ACCESSIBILITY_SERVICE, AccessibilityManager.class,
new CachedServiceFetcher<AccessibilityManager>() {
@Override
public AccessibilityManager createService(ContextImpl ctx) {
return AccessibilityManager.getInstance(ctx);
}});
//获取Activity管理服务
registerService(Context.ACTIVITY_SERVICE, ActivityManager.class,
new CachedServiceFetcher<ActivityManager>() {
@Override
public ActivityManager createService(ContextImpl ctx) {
return new ActivityManager(ctx.getOuterContext(), ctx.mMainThread.getHandler());
}});
...
//加载布局的服务
registerService(Context.LAYOUT_INFLATER_SERVICE, LayoutInflater.class,
new CachedServiceFetcher<LayoutInflater>() {
@Override
public LayoutInflater createService(ContextImpl ctx) {
// 最终创建的是PhoneLayoutInflater对象
return new PhoneLayoutInflater(ctx.getOuterContext());
}});
...
}
静态代码块会在类加载时执行，也就是说当程序加载了SystemServiceRegistery类时，就会执行各类服务的注册过程。
注册服务的registerService()方法
//源文件 SystemServiceRegistry.Java
private static <T> void registerService(String serviceName, Class<T> serviceClass,
ServiceFetcher<T> serviceFetcher) {
SYSTEM_SERVICE_NAMES.put(serviceClass, serviceName);
SYSTEM_SERVICE_FETCHERS.put(serviceName, serviceFetcher);
}
registerService()方法中，SYSTEM_SERVICE_NAMES容器将类类型作为键，将服务类型的名称作为值存储。SYSTEM_SERVICE_FETCHERS容器中将服务名称serviceName作为键，将服务对应的服务获取对象serviceFetcher作为值存储。
再看有关LayoutInflater的注册方法。
//源文件 SystemServiceRegistry.Java
registerService(Context.LAYOUT_INFLATER_SERVICE, LayoutInflater.class,
new CachedServiceFetcher<LayoutInflater>() {
@Override
public LayoutInflater createService(ContextImpl ctx) {
//创建的具体对象为PhoneLayoutInflater
return new PhoneLayoutInflater(ctx.getOuterContext());
}});
服务名称serviceName为Context.LAYOUT_INFLATER_SERVICE，serviceClass的类型为LayoutInflater.class，以及ServiceFetcher的实现对象为CachedServiceFetcher。
CachedServiceFetcher是ServiceFetcher的实现类，其实现了getService()方法，并定义了createService()抽象方法。
接下来查看CachedServiceFetcher代码：
//源文件 SystemServiceRegistry.Java
static abstract class CachedServiceFetcher<T> implements ServiceFetcher<T> {
private final int mCacheIndex;
CachedServiceFetcher() {
mCacheIndex = sServiceCacheSize++;
}
@Override
@SuppressWarnings("unchecked")
public final T getService(ContextImpl ctx) {
final Object[] cache = ctx.mServiceCache;
final int[] gates = ctx.mServiceInitializationStateArray;
for (;;) {
boolean doInitialize = false;
synchronized (cache) {
T service = (T) cache[mCacheIndex];
if (service != null || gates[mCacheIndex] == ContextImpl.STATE_NOT_FOUND) {
return service;
}
//判断状态
if (gates[mCacheIndex] == ContextImpl.STATE_READY) {
gates[mCacheIndex] = ContextImpl.STATE_UNINITIALIZED;
}
if (gates[mCacheIndex] == ContextImpl.STATE_UNINITIALIZED) {
doInitialize = true;
gates[mCacheIndex] = ContextImpl.STATE_INITIALIZING;
}
}
if (doInitialize) {
T service = null;
@ServiceInitializationState int newState = ContextImpl.STATE_NOT_FOUND;
try {
//调用createService方法创建具体的服务类对象
service = createService(ctx);
newState = ContextImpl.STATE_READY;
} catch (ServiceNotFoundException e) {
onServiceNotFound(e);
} finally {
synchronized (cache) {
cache[mCacheIndex] = service;
gates[mCacheIndex] = newState;
cache.notifyAll();
}
}
return service;
}
...
}
}
//抽象方法，创建服务
public abstract T createService(ContextImpl ctx) throws ServiceNotFoundException;
}
CachedServiceFetcher类中实现了getService()方法，并且getService()中又调用了createService()方法。在调用registerService()方法时重写了createService()方法，因此通过getService()方法获取到的对象就是经过具体化处理的对象，对于获取名为Context.LAYOUT_INFLATER_SERVICE的服务对象，返回的实体对象就是PhoneLayoutInflater对象。
到这里，前两种方法获取LayoutInflater对象以及分析完毕，那么我们再看第三种获取方式getLayoutInflater()。
第三部分 getLayoutInflater()方法
getLayoutInflater()可以在Activity中调用，貌似其调用过程与Context无关。那么其实现过程是怎样的呢？
我们首先查看Activity的源码：
//源文件Activity.Java
public class Activity extends ContextThemeWrapper
implements LayoutInflater.Factory2,
Window.Callback, KeyEvent.Callback,
OnCreateContextMenuListener, ComponentCallbacks2,
Window.OnWindowDismissedCallback, WindowControllerCallback,
AutofillManager.AutofillClient {
...
private Window mWindow;
@NonNull
public LayoutInflater getLayoutInflater() {
return getWindow().getLayoutInflater();
}
public Window getWindow() {
return mWindow;
}
final void attach(Context context, ActivityThread aThread,
Instrumentation instr, IBinder token, int ident,
Application application, Intent intent, ActivityInfo info,
CharSequence title, Activity parent, String id,
NonConfigurationInstances lastNonConfigurationInstances,
Configuration config, String referrer, IVoiceInteractor voiceInteractor,
Window window, ActivityConfigCallback activityConfigCallback) {
attachBaseContext(context);
mFragments.attachHost(null /*parent*/);
//mWindow的实现最终是PhoneWindow
mWindow = new PhoneWindow(this, window, activityConfigCallback);
mWindow.setWindowControllerCallback(this);
mWindow.setCallback(this);
mWindow.setOnWindowDismissedCallback(this);
mWindow.getLayoutInflater().setPrivateFactory(this);
if (info.softInputMode != WindowManager.LayoutParams.SOFT_INPUT_STATE_UNSPECIFIED) {
mWindow.setSoftInputMode(info.softInputMode);
}
if (info.uiOptions != 0) {
mWindow.setUiOptions(info.uiOptions);
}
}
}
Activity中提供了getLayoutInflater()方法，其最终实现是由PhoneWindow实现的。那么我们再看PhoneWindow的源码：
//源文件PhoneWindow.Java
public class PhoneWindow extends Window implements MenuBuilder.Callback {
private final static String TAG = "PhoneWindow";
...
private LayoutInflater mLayoutInflater;
//构造函数
public PhoneWindow(Context context) {
super(context);
mLayoutInflater = LayoutInflater.from(context);
}
@Override
public LayoutInflater getLayoutInflater() {
return mLayoutInflater;
}
...
}
通过PhoneWindow的源码可以看出其内部同样是使用LayoutInflater.from(context)方式获取LayoutInflater。
小结
通过上述一步步分析，我们总结获取LayoutInflater的大致过程如下：
首先，当系统加载SystemServiceRegistry类时会执行其中的静态代码块，服务的注册过程即是向HashMap容器中添加键值对的过程。键设置为Context中定义的服务名称，值为CachedServiceFetcher对象。CachedServiceFetcher实现了抽象方法getService()，将服务的获取过程抽象出来。CachedServiceFetcher中又定义的抽象方法createService()，将创建不同服务类对象的过程分离，根据不同名称创建不同服务。这样即实现了根据名称获取服务的过程。
本篇讲述了LayoutInflater对象的获取过程，下一篇我们将进一步分析LayoutInflater是如何加载布局的。希望大家多多关注，觉得文章有用就请点赞支持一下。
