系列文章索引
Android系统启动流程
LayoutInflater源码详解
更新
录播回放已上传，请戳链接食用：【Android/源码/面试】LayoutInflater源码详解
前言
这篇文章会从源码的角度分析，LayoutInflater将xml文件实例化为一个view对象的流程
我们会发现，其中有两个部分是耗时的主要来源
- XmlResourseParser对xml的遍历
- 反射创建View对象导致的耗时
这两点，又跟Xml的复杂程度成正相关，Xml越复杂，则递归调用所消耗的时间就越长，就产生了我们所说的，卡顿问题
整体流程概览
彩蛋：BlinkLayout
BlinkLayout是LayoutInflater中的一个内部类，它本身是是FrameLayout的子类,如果当前标签为TAG_1995，则创建一个隔0.5秒闪烁一次的BlinkLayout来承载它的布局内容
源码注释也很有意思，写了Let's party like it's 1995!, 据说是为了庆祝1995年的复活节
LayoutInflater
public final View tryCreateView(@Nullable View parent, @NonNull String name,
@NonNull Context context,
@NonNull AttributeSet attrs) {
if (name.equals(TAG_1995)) {
// Let's party like it's 1995!
return new BlinkLayout(context, attrs);
}
...
return view;
}
具体使用也很简单
<blink
android:layout_below="@id/iv_qr_code"
android:layout_centerHorizontal="true"
android:layout_width="wrap_content"
android:layout_height="wrap_content">
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Android研习社"
android:textColor="#157686"
android:textSize="55sp"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintLeft_toLeftOf="parent"
app:layout_constraintRight_toRightOf="parent"
app:layout_constraintTop_toTopOf="parent" />
</blink>
效果如下，这种效果也适合来做EditText中光标的闪烁效果
扫描上方二维码关注「Android研习社」公众号，获取更多学习资料！
ps: 想深入学习的都关注了，还不赶快关注一波？
LayoutInflater的创建
概览
LayoutInflater是一个抽象类，它的创建，并不是交由App层处理的，而是调用了from()的静态函数，经由系统服务LAYOUT_INFLATER_SERVICE，最终创建了一个LayoutInflater的子类对象--PhoneLayoutInflater
重要函数解析
LayoutInflater.from(cxt)
这个函数比较简单，就是根据传递过来的Context对象，调用getSystemService()来获取对应的系统服务，并赋值给LayoutInflater
public static LayoutInflater from(Context context) {
LayoutInflater LayoutInflater = //LayoutInflate是一个系统服务，最终返回的是`PhoneLahyoutInflater`
(LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
if (LayoutInflater == null) {
throw new AssertionError("LayoutInflater not found.");
}
return LayoutInflater;
}
而Context本身是一个抽象类，它真正的实例化对象，是ContextImpl, 在这个类的getSystemService()函数中，真正执行获取系统服务的类，是SystemServiceRegistry，其中又封装了一个ServiceFetcher来获取真正的系统服务，所有的系统服务，都是存储在一个map集合--SYSTEM_SERVICE_FETCHERS当中，这里其实是一个get方法，是从这个map集合中取出对应的系统服务
LayoutInflater
@Override
public Object getSystemService(String name) {
return SystemServiceRegistry.getSystemService(this, name);
}
SystemServiceRegistry
/**
* Gets a system service from a given context.
*/
public static Object getSystemService(ContextImpl ctx, String name) {
ServiceFetcher<?> fetcher = SYSTEM_SERVICE_FETCHERS.get(name);
return fetcher != null ? fetcher.getService(ctx) : null;
}
关于对应的服务的添加，也就是调用了SYSTEM_SERVICE_FETCHERS的put函数，这个动作是交由registerService()来完成的
/**
* Statically registers a system service with the context.
* This method must be called during static initialization only.
*/
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);
}
SystemServiceRegistry这个类中有一个静态代码块，是用来完成所有服务的注册的，这里我们只关心LAYOUT_INFLATER_SERVICE对应的服务是如何注册的
static{
...
registerService(Context.LAYOUT_INFLATER_SERVICE, LayoutInflater.class,
new CachedServiceFetcher<LayoutInflater>() {
@Override
public LayoutInflater createService(ContextImpl ctx) {
return new PhoneLayoutInflater(ctx.getOuterContext());
}});
...
}
正如我们之前所说，这里最终是创建了一个PhoneLayoutInflater并返回的，到这里LayoutInflater的创建流程就分析完了
思考
为什么要交由系统服务来做，而不是直接创建一个PhoneLayoutInflater的实例对象？
LayoutInflater布局的实例化
整体流程
实例化的调用流程我们都很熟悉了，调用layoutInflater的inflater()函数，传入一个xml的resId参数就可以了
重要函数解析
inflate
这个函数就是我们把Xml布局文件实例化为一个View对象的入口了
LayoutInflater
public View inflate(@LayoutRes int resource, @Nullable ViewGroup root, boolean attachToRoot) {
final Resources res = getContext().getResources();
if (DEBUG) {
Log.d(TAG, "INFLATING from resource: \"" + res.getResourceName(resource) + "\" ("
+ Integer.toHexString(resource) + ")");
}
View view = tryInflatePrecompiled(resource, res, root, attachToRoot); //这段代码其实是必然返回null的，因为当前版本写死了预编译的Enable为false
if (view != null) {
return view;
}
XmlResourceParser parser = res.getLayout(resource); //获取XmlBlock.Parser对象
try {
return inflate(parser, root, attachToRoot);
} finally {
parser.close();
}
}
此处又调用了inflate(parser, root, attachToRoot)这个函数，来对Xml布局进行解析
这里看到对一些熟悉的标签，比如include,merge，的处理，具体细节请看下面的源码及注释
public View inflate(XmlPullParser parser, @Nullable ViewGroup root, boolean attachToRoot) {//XmlPullParser是一个接口
//此函数是真正执行将xml解析为视图view的过程，此处的parser为根据xml布局获取到的parser对象
synchronized (mConstructorArgs) {
Trace.traceBegin(Trace.TRACE_TAG_VIEW, "inflate");
final Context inflaterContext = mContext;
final inflateAttributeSet attrs = Xml.asAttributeSet(parser);
Context lastContext = (Context) mConstructorArgs[0];
mConstructorArgs[0] = inflaterContext;
View result = root; //需要返回的view对象
try {
advanceToRootNode(parser); //对START_TAG和END_TAG进行判断和处理
final String name = parser.getName(); //获取当前标签
if (DEBUG) {
System.out.println("**************************");
System.out.println("Creating root view: "
+ name);
System.out.println("**************************");
}
if (TAG_MERGE.equals(name)) { //如果使用merge标签
if (root == null || !attachToRoot) { //使用merge标签必须有父布局，且依赖于父布局加载，否则就会抛出异常
throw new InflateException("<merge /> can be used only with a valid "
+ "ViewGroup root and attachToRoot=true");
}
rInflate(parser, root, inflaterContext, attrs, false);//递归（Recursive）生成布局视图
} else { //如果不使用merge标签，创建tmp 作为临时的根节点，并最终赋值给result返回
// Temp is the root view that was found in the xml
final View temp = createViewFromTag(root, name, inflaterContext, attrs); ////根据标签名创建一个view
ViewGroup.LayoutParams params = null;
if (root != null) { //如果rootView不为空
if (DEBUG) {
System.out.println("Creating params from root: " +
root);
}
// Create layout params that match root, if supplied
params = root.generateLayoutParams(attrs); //根据rootView生成layoutparams
if (!attachToRoot) { //如果attachToRoot为false
// Set the layout params for temp if we are not
// attaching. (If we are, we use addView, below)
temp.setLayoutParams(params); //设置一个临时的params
}
}
if (DEBUG) {
System.out.println("-----> start inflating children");
}
// Inflate all children under temp against its context.
rInflateChildren(parser, temp, attrs, true);
if (DEBUG) {
System.out.println("-----> done inflating children");
}
// We are supposed to attach all the views we found (int temp)
// to root. Do that now.
if (root != null && attachToRoot) { //如果root不为空，且attachToRoot为true
root.addView(temp, params); //把temp添加到到rootview中
}
// Decide whether to return the root that was passed in or the
// top view found in xml.
if (root == null || !attachToRoot) { // 如果root为空且attachToRoot为false
result = temp; //将temp，也就是根结点的View赋值给result
}
}
}
...
return result; //返回结果
}
}
rInflate
从上面的代码中我们也可以看到，不管是merge标签，还是非merge标签，最终都会调用到rInflate()这个函数，这个是用于递归向下遍历xml布局，最终调用createViewFromTag()函数来反射创建View对象
具体细节请看下面的源码及注释
void rInflate(XmlPullParser parser, View parent, Context context,
AttributeSet attrs, boolean finishInflate) throws XmlPullParserException, IOException {
final int depth = parser.getDepth();
int type;
boolean pendingRequestFocus = false;
while (((type = parser.next()) != XmlPullParser.END_TAG ||
parser.getDepth() > depth) && type != XmlPullParser.END_DOCUMENT) {
if (type != XmlPullParser.START_TAG) {
continue;
}
final String name = parser.getName();
if (TAG_REQUEST_FOCUS.equals(name)) { //如果需REQUEST_FOCUS标签
pendingRequestFocus = true;
consumeChildElements(parser);
} else if (TAG_TAG.equals(name)) { //如果是“tag”标签
parseViewTag(parser, parent, attrs);
} else if (TAG_INCLUDE.equals(name)) { //如果是 Include标签
if (parser.getDepth() == 0) {
throw new InflateException("<include /> cannot be the root element");
}
parseInclude(parser, context, parent, attrs); //对 include标签进行解析
} else if (TAG_MERGE.equals(name)) { //如果是merge标签
throw new InflateException("<merge /> must be the root element"); //直接抛出异常
} else { //其他标签
final View view = createViewFromTag(parent, name, context, attrs); //根据Tag创建view，反射创建View
final ViewGroup viewGroup = (ViewGroup) parent;
final ViewGroup.LayoutParams params = viewGroup.generateLayoutParams(attrs);
rInflateChildren(parser, view, attrs, true); //递归调用rInflate函数
viewGroup.addView(view, params);
}
}
if (pendingRequestFocus) {
parent.restoreDefaultFocus();
}
if (finishInflate) {
parent.onFinishInflate();
}
}
createViewFromTag()
终于到了我们的重头戏，也是真正根据解析到的Tag标签去反射创建View的函数
LayoutInflater
View createViewFromTag(View parent, String name, Context context, AttributeSet attrs,
boolean ignoreThemeAttr) {
if (name.equals("view")) {
name = attrs.getAttributeValue(null, "class");
}
// Apply a theme wrapper, if allowed and one is specified.
if (!ignoreThemeAttr) {
final TypedArray ta = context.obtainStyledAttributes(attrs, ATTRS_THEME);
final int themeResId = ta.getResourceId(0, 0);
if (themeResId != 0) {
context = new ContextThemeWrapper(context, themeResId);
}
ta.recycle();
}
try {
View view = tryCreateView(parent, name, context, attrs); //尝试使用Factory来闯将View对象
if (view == null) { //如果tryCreateView返回null
final Object lastContext = mConstructorArgs[0];
mConstructorArgs[0] = context;
try {
//sample：com.aiwinn.base.widget.CameraSurfaceView
if (-1 == name.indexOf('.')) { //如果当前Tag含有“.”
view = onCreateView(context, parent, name, attrs);
} else {
view = createView(context, name, null, attrs);
}
} finally {
mConstructorArgs[0] = lastContext;
}
}
return view;
}
...
}
在这个函数中会首先调用tryCreateView()来获取View对象，如果为null，则进一步调用createView()函数来创建View对象
public final View createView(@NonNull Context viewContext, @NonNull String name,
@Nullable String prefix, @Nullable AttributeSet attrs)
throws ClassNotFoundException, InflateException {
//根据Tag反射创建view
Objects.requireNonNull(viewContext);
Objects.requireNonNull(name);
Constructor<? extends View> constructor = sConstructorMap.get(name);
if (constructor != null && !verifyClassLoader(constructor)) {
constructor = null;
sConstructorMap.remove(name);
}
Class<? extends View> clazz = null;
try {
Trace.traceBegin(Trace.TRACE_TAG_VIEW, name);
if (constructor == null) {
// Class not found in the cache, see if it's real, and try to add it
clazz = Class.forName(prefix != null ? (prefix + name) : name, false,
mContext.getClassLoader()).asSubclass(View.class);//把prefix和name进行拼接，获取到对应的Class对象
if (mFilter != null && clazz != null) {
boolean allowed = mFilter.onLoadClass(clazz);
if (!allowed) {
failNotAllowed(name, prefix, viewContext, attrs);
}
}
constructor = clazz.getConstructor(mConstructorSignature);//获取构构造器对象
constructor.setAccessible(true);
sConstructorMap.put(name, constructor);
} else {
...
}
Object lastContext = mConstructorArgs[0];
mConstructorArgs[0] = viewContext;
Object[] args = mConstructorArgs;
args[1] = attrs;
try {
final View view = constructor.newInstance(args); //根据获取到的构造器创建一个View的实例化对象
if (view instanceof ViewStub) {
// Use the same context when inflating ViewStub later.
final ViewStub viewStub = (ViewStub) view;
viewStub.setLayoutInflater(cloneInContext((Context) args[0]));
}
return view;
} finally {
mConstructorArgs[0] = lastContext;
}catch{
...
}
}
}
这里的代码其实在耗时上算是比较重量级了，因为是使用反射来创建的，一般的说法是，反射比直接创建对象要慢3倍，iReader的x2c框架就是基于这一点去做的优化
加餐
Resources的创建和获取
这里先获取到Resources对象--mResources，这个对象的创建是由createResources()来完成的,这里最终是交由ResourcesManager这个类来获取对应的resources
ContextImpl
private static Resources createResources(IBinder activityToken, LoadedApk pi, String splitName,
int displayId, Configuration overrideConfig, CompatibilityInfo compatInfo) {
final String[] splitResDirs;
final ClassLoader classLoader;
try {
splitResDirs = pi.getSplitPaths(splitName);
classLoader = pi.getSplitClassLoader(splitName);
} catch (NameNotFoundException e) {
throw new RuntimeException(e);
}
return ResourcesManager.getInstance().getResources(activityToken,
pi.getResDir(),
splitResDirs,
pi.getOverlayDirs(),
pi.getApplicationInfo().sharedLibraryFiles,
displayId,
overrideConfig,
compatInfo,
classLoader);
}
ResourcesManager
public @Nullable Resources getResources(@Nullable IBinder activityToken,
@Nullable String resDir,
@Nullable String[] splitResDirs,
@Nullable String[] overlayDirs,
@Nullable String[] libDirs,
int displayId,
@Nullable Configuration overrideConfig,
@NonNull CompatibilityInfo compatInfo,
@Nullable ClassLoader classLoader) {
try {
Trace.traceBegin(Trace.TRACE_TAG_RESOURCES, "ResourcesManager#getResources");
final ResourcesKey key = new ResourcesKey(
resDir,
splitResDirs,
overlayDirs,
libDirs,
displayId,
overrideConfig != null ? new Configuration(overrideConfig) : null, // Copy
compatInfo);
classLoader = classLoader != null ? classLoader : ClassLoader.getSystemClassLoader();
return getOrCreateResources(activityToken, key, classLoader);
} finally {
Trace.traceEnd(Trace.TRACE_TAG_RESOURCES);
}
}
ContextImpl
@Override
public Resources getResources() {
return mResources;
}
由这里我们也可以推断，LayoutInflater交由服务来创建来创建，是因为其需要获取系统服务才能获取的某些资源
XmlBlock
inflate()函数里还涉及到一个重要的类, XmlResourceParser，这个类是负责对xml的标签进行遍历解析的，它的真正的实现类是XmlBlock的内部类XmlBlock.Parser，而真正完成xml的遍历操作的函数都是由XmlBlock来实现的，为了提升效率，该函数都是通过JNI调用native的函数来做的，对应的native层是android_util_XmlBlock.cpp
XmlBlock.java
@FastNative
/*package*/ static final native int nativeNext(long state);
@FastNative
private static final native int nativeGetNamespace(long state);
@FastNative
/*package*/ static final native int nativeGetName(long state);
@FastNative
private static final native int nativeGetText(long state);
@FastNative
private static final native int nativeGetLineNumber(long state);
...
``android_util_XmlBlock.cpp`
static jint android_content_XmlBlock_nativeNext(JNIEnv* env, jobject clazz,
jlong token)
{
ResXMLParser* st = reinterpret_cast<ResXMLParser*>(token);
if (st == NULL) {
return ResXMLParser::END_DOCUMENT;
}
do {
ResXMLParser::event_code_t code = st->next();
switch (code) {
case ResXMLParser::START_TAG:
return 2;
case ResXMLParser::END_TAG:
return 3;
case ResXMLParser::TEXT:
return 4;
case ResXMLParser::START_DOCUMENT:
return 0;
case ResXMLParser::END_DOCUMENT:
return 1;
case ResXMLParser::BAD_DOCUMENT:
goto bad;
default:
break;
}
} while (true);
bad:
jniThrowException(env, "org/xmlpull/v1/XmlPullParserException",
"Corrupt XML binary file");
return ResXMLParser::BAD_DOCUMENT;
}
tryInflatePrecompiled
这个函数是Android10的源码里面新增的一个函数，是用来根据xml预编译生成的dex，通过反射来生成对应的View，从而减少XmlPullParser解析Xml的时间 -- 放到编译期来进行-- 的一个优化 ，而反射获取对应的View时可以直接获取到预编译的View对象，而不需要递归调用rInflate
这里基本上就是真正彻底解决了复杂布局导致的卡顿问题
View tryInflatePrecompiled(@LayoutRes int resource, Resources res, @Nullable ViewGroup root,
boolean attachToRoot) {
if (!mUseCompiledView) {
return null;
}
Trace.traceBegin(Trace.TRACE_TAG_VIEW, "inflate (precompiled)");
// Try to inflate using a precompiled layout.
String pkg = res.getResourcePackageName(resource);
String layout = res.getResourceEntryName(resource);
//依然是通过反射的方式，根据已经创建的mPrecompiledClassLoader来反射生成view对象
try {
Class clazz = Class.forName("" + pkg + ".CompiledView", false, mPrecompiledClassLoader); //获取到预编译生成的view对象的Class类
Method inflater = clazz.getMethod(layout, Context.class, int.class);
View view = (View) inflater.invoke(null, mContext, resource);
if (view != null && root != null) {
// We were able to use the precompiled inflater, but now we need to do some work to
// attach the view to the root correctly.
XmlResourceParser parser = res.getLayout(resource);
try {
AttributeSet attrs = Xml.asAttributeSet(parser);
advanceToRootNode(parser);
ViewGroup.LayoutParams params = root.generateLayoutParams(attrs);
if (attachToRoot) {
root.addView(view, params);
} else {
view.setLayoutParams(params);
}
} finally {
parser.close();
}
}
return view;
} catch (Throwable e) {
if (DEBUG) {
Log.e(TAG, "Failed to use precompiled view", e);
}
} finally {
Trace.traceEnd(Trace.TRACE_TAG_VIEW);
}
return null;
}
写在最后
下一篇文章，我们会提出一些优化方案，来解决（或者说）减缓复杂布局产生的卡顿问题，敬请期待！
参考文章：
1. https://www.reddit.com/r/androiddev/comments/3sekn8/lets_party_like_its_1995_from_the_layoutinflater/
2. https://www.cnblogs.com/liyilin-jack/p/10282385.html
3. https://blog.csdn.net/axi295309066/article/details/60128009
4. https://github.com/RTFSC-Android/RTFSC/blob/master/BlinkLayout.md
5. https://juejin.cn/post/6844903785219751944
郑重声明
本文版权归Android研习社所有，未经允许禁止转载，侵权必究！
