上一篇文章: setContentView源码分析
在上一篇文章到最后加载我们自己的xml布局文件到父布局中:
LayoutInflater.from(this.mContext).inflate(resId, contentParent);
那么LayoutInflater是如何加载xml布局文件的呢?
以下源码基于android28
1. LayoutInflater.from(Context)
我们先来看一下 LayoutInflater.from(Context) 拿到的是什么。
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;
}
返回的是这个 context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
那我们就要去Context里面去找
public abstract class Context {
......
public abstract @Nullable Object getSystemService(@ServiceName @NonNull String name);
......
}
✍我们可以看到Context是个抽象类,getSystemService也是一个抽象方法,那这个方法的具体实现在哪里呢?
这个我们就要去看ContextImp,它是Context的具体实现类
ps: Activity ,Service 和 Application都是Context的间接实现类:
Context
⇣
ContextWrapper
⇣
一些中间类
⇣
Activity或Service或Application
它们和ContextImp没有直接关系,它们都继承了ContextWrapper,而ContextWrapper中有一个mBase
就是ContextImp对象,所以它们都是它们是通过ContextWrapper使用mBase进行进行操作
class ContextImpl extends Context {
@Override
public Object getSystemService(String name) {
return SystemServiceRegistry.getSystemService(this, name);
}
}
接着去看SystemServiceRegistry类
final class SystemServiceRegistry {
private static final HashMap<String, ServiceFetcher<?>> SYSTEM_SERVICE_FETCHERS =
new HashMap<String, ServiceFetcher<?>>();
✍静态代码块 类加载就会被初始化
就是把(LAYOUT_INFLATER_SERVICE,CachedServiceFetcher)键值对保存到SYSTEM_SERVICE_FETCHERS中
{
...
registerService(Context.LAYOUT_INFLATER_SERVICE, LayoutInflater.class,
new CachedServiceFetcher<LayoutInflater>() {
@Override
public LayoutInflater createService(ContextImpl ctx) {
return new PhoneLayoutInflater(ctx.getOuterContext());
}});
...
}
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);
}
public static Object getSystemService(ContextImpl ctx, String name) {
✍ fetcher就是初始化时保存的CachedServiceFetcher
ServiceFetcher<?> fetcher = SYSTEM_SERVICE_FETCHERS.get(name);
return fetcher != null ? fetcher.getService(ctx) : null;
}
✍ 接着我们就去找CachedServiceFetcher#getService
CachedServiceFetcher是SystemServiceRegistry的静态内部类
static abstract class CachedServiceFetcher<T> implements ServiceFetcher<T> {
@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) {
// Return it if we already have a cached instance.
✍如果我们已经有缓存的对象直接返回
T service = (T) cache[mCacheIndex];
if (service != null || gates[mCacheIndex] == ContextImpl.STATE_NOT_FOUND) {
return service;
}
}
if (doInitialize) {
// Only the first thread gets here.
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;
}
✍createService怎么是个抽象方法,具体实现在哪呢?
public abstract T createService(ContextImpl ctx) throws ServiceNotFoundException;
}
}
}
}
✍还记得上面呢静态代码块中我们registerService的代码么:
registerService(Context.LAYOUT_INFLATER_SERVICE, LayoutInflater.class,
new CachedServiceFetcher<LayoutInflater>() {
@Override
public LayoutInflater createService(ContextImpl ctx) {
return new PhoneLayoutInflater(ctx.getOuterContext());
}
}
);
createService()方法是在这里实现的,返回一个PhoneLayoutInflater对象。
我们来看一下PhoneLayoutInflater类
public class PhoneLayoutInflater extends LayoutInflater {
✍我们xm布局中的控件就存在这三个包中
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 ✍<<重写了LayoutInflater的onCreateView方法>>
protected View onCreateView(String name, AttributeSet attrs) throws ClassNotFoundException {
for (String prefix : sClassPrefixList) {
try {
✍这里就是把prefix即包名前缀和name一起调用父类LayoutInflater里面的
createView方法。
View view = createView(name, prefix, attrs);
if (view != null) {
✍ view不为空即匹配到正确的包名,结束for循环
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);
}
}
看了之后,就这?里面也没啥。
2. inflate(resId, contentParent)
LayoutInflater.from(Context) 最终得到PhoneLayoutInflater对象,但是我们上面看到PhoneLayoutInflater里面也没干啥,所以 PhoneLayoutInflater.inflate(resId, contentParent)
还是要看去看其父类LayoutInflater是如何实现的。
public abstract class LayoutInflater {
public View inflate(@LayoutRes int resource, @Nullable ViewGroup root) {
return inflate(resource, root, root != null);
}
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) + ")");
}
final XmlResourceParser parser = res.getLayout(resource);
try {
return inflate(parser, root, attachToRoot);
} finally {
parser.close();
}
}
✍ 最终调用这个方法
public View inflate(XmlPullParser parser, @Nullable ViewGroup root, boolean attachToRoot) {
synchronized (mConstructorArgs) {
Trace.traceBegin(Trace.TRACE_TAG_VIEW, "inflate");
final Context inflaterContext = mContext;
final AttributeSet attrs = Xml.asAttributeSet(parser);
Context lastContext = (Context) mConstructorArgs[0];
mConstructorArgs[0] = inflaterContext;
View result = root;
try {
// Look for the root node.
int type;
while ((type = parser.next()) != XmlPullParser.START_TAG &&
type != XmlPullParser.END_DOCUMENT) {
// Empty
}
final String name = parser.getName();
if (TAG_MERGE.equals(name)) {
if (root == null || !attachToRoot) {
throw new InflateException("<merge /> can be used only with a valid "
+ "ViewGroup root and attachToRoot=true");
}
rInflate(parser, root, inflaterContext, attrs, false);
} else {
// Temp is the root view that was found in the xml
✍创建我们xml布局文件的根布局View,就是最外层View
final View temp = createViewFromTag(root, name, inflaterContext, attrs);
// Inflate all children under temp against its context.
✍ 核心代码 把xml布局文件中所有view逐层添加到上面创建的根布局View中
rInflateChildren(parser, temp, attrs, true);
✍如果我们LayoutInflater.from().inflate()传入root布局不为null
且是否添加到root布局的boolean值为true,就把我们的xml布局添加到根布局中
if (root != null && attachToRoot) {
root.addView(temp, params);
}
✍如果root布局为null,或者是否添加到root中的开关boolean值为false,
就把我们的xml布局添赋值给result,到最后return返回
if (root == null || !attachToRoot) {
result = temp;
}
}
} catch (XmlPullParserException e) {
......
}
return result;
}
✍ 记住这个 rInflateChildren 方法,它其实是调用了 rInflate 方法
final void rInflateChildren(XmlPullParser parser, View parent, AttributeSet attrs,
boolean finishInflate) throws XmlPullParserException, IOException {
rInflate(parser, parent, parent.getContext(), attrs, finishInflate);
} ↓
↓
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循环逐层获取我们的View标签
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)) {
pendingRequestFocus = true;
consumeChildElements(parser);
} else if (TAG_TAG.equals(name)) {
parseViewTag(parser, parent, attrs);
} else if (TAG_INCLUDE.equals(name)) {
if (parser.getDepth() == 0) {
throw new InflateException("<include /> cannot be the root element");
}
parseInclude(parser, context, parent, attrs);
} else if (TAG_MERGE.equals(name)) {
throw new InflateException("<merge /> must be the root element");
} else {
✍前面几种都是我们常见的include、merge等情况的处理,我们主要看下面普通布局
final View view = createViewFromTag(parent, name, context, attrs);
final ViewGroup viewGroup = (ViewGroup) parent;
final ViewGroup.LayoutParams params = viewGroup.generateLayoutParams(attrs);
✍这个不就是上面的那个rInflateChildren方法么,他又会调用rInflate,就是这样的循环添加
直到最里层while结束,然后逐层返回添加到其上一层布局中
rInflateChildren(parser, view, attrs, true);
✍这里有一个很重要的点,文章最后会说
viewGroup.addView(view, params);
}
}
}
}
我们来看一下createViewFromTag
private View createViewFromTag(View parent, String name, Context context, AttributeSet attrs) {
return createViewFromTag(parent, name, context, attrs, false);
}
View createViewFromTag(View parent, String name, Context context, AttributeSet attrs,
boolean ignoreThemeAttr) {
if (name.equals("view")) {
name = attrs.getAttributeValue(null, "class");
}
。。。。。。。
try {
View view;
。。。。。。。
if (view == null) {
final Object lastContext = mConstructorArgs[0];
mConstructorArgs[0] = context;
try {
if (-1 == name.indexOf('.')) {
✍ 如果name不包含 '.' 就像<Button></Button>
此时会调用PhoneLayoutInflater重载的onCreateView方法
就是去加上一个前缀包名,然后再去调用LayoutInflater#createView
view = onCreateView(parent, name, attrs);
} else {
✍如果name包含'.' 就直接调用LayoutInflater#createView
view = createView(name, null, attrs);
}
} finally {
mConstructorArgs[0] = lastContext;
}
}
return view;
} catch (InflateException e) {
throw e;
} catch (ClassNotFoundException e) {
。。。
} catch (Exception e) {
。。。
}
}
那我们就去看看LayoutInflater#createView方法是如何实现的
public final View createView(String name, String prefix, AttributeSet attrs)
throws ClassNotFoundException, InflateException {
✍先读取是否有已保存的对应对象
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
✍ 根据前缀prefix是否为null,拼接完整类所在路径,创建Class
clazz = mContext.getClassLoader().loadClass(
prefix != null ? (prefix + name) : name).asSubclass(View.class);
if (mFilter != null && clazz != null) {
boolean allowed = mFilter.onLoadClass(clazz);
if (!allowed) {
failNotAllowed(name, prefix, attrs);
}
}
constructor = clazz.getConstructor(mConstructorSignature);
constructor.setAccessible(true);
✍把新建的对象保存到sConstructorMap中缓存下来
sConstructorMap.put(name, constructor);
} else {
// If we have a filter, apply it to cached constructor
if (mFilter != null) {
// Have we seen this name before?
Boolean allowedState = mFilterMap.get(name);
if (allowedState == null) {
// New class -- remember whether it is allowed
clazz = mContext.getClassLoader().loadClass(
prefix != null ? (prefix + name) : name).asSubclass(View.class);
boolean allowed = clazz != null && mFilter.onLoadClass(clazz);
mFilterMap.put(name, allowed);
if (!allowed) {
failNotAllowed(name, prefix, attrs);
}
} else if (allowedState.equals(Boolean.FALSE)) {
failNotAllowed(name, prefix, attrs);
}
}
}
Object lastContext = mConstructorArgs[0];
if (mConstructorArgs[0] == null) {
// Fill in the context if not already within inflation.
mConstructorArgs[0] = mContext;
}
Object[] args = mConstructorArgs;
args[1] = attrs;
✍通过反射创建对象
final View view = constructor.newInstance(args);
if (view instanceof ViewStub) {
// Use the same context when inflating ViewStub later.
final ViewStub viewStub = (ViewStub) view;
viewStub.setLayoutInflater(cloneInContext((Context) args[0]));
}
mConstructorArgs[0] = lastContext;
return view;
} catch (NoSuchMethodException e) {
...
} catch (ClassCastException e) {
...
} catch (ClassNotFoundException e) {
...
} catch (Exception e) {
...
} finally {
Trace.traceEnd(Trace.TRACE_TAG_VIEW);
}
}
这样循环读取标签,然后通过反射创建对象;
通过rInflateChildren循环添加到整个View树中。
这样整个xml文件就加载完成。
3. 附
viewGroup.addView(view, params);
我们来看一下这个将View添加到其外一层布局控件中的代码:
@Override
public void addView(View child, LayoutParams params) {
addView(child, -1, params);
}
public void addView(View child, int index, LayoutParams params) {
.......
// addViewInner() will call child.requestLayout() when setting the new LayoutParams
// therefore, we call requestLayout() on ourselves before, so that the child's request
// will be blocked at our level
requestLayout();
invalidate(true);
addViewInner(child, index, params, false);
}
private void addViewInner(View child, int index, LayoutParams params,
boolean preventRequestLayout) {
// tell our children
if (preventRequestLayout) {
child.assignParent(this);
} else {
✍添加其下一层时会把自己赋值给其mParent
child.mParent = this;
}
}
这样里层都持有了其外一层的对象。
这个 mParent其实是位于View中,而ViewGroup继承View
public class View implements ...{
protected ViewParent mParent;
void assignParent(ViewParent parent) {
if (mParent == null) {
mParent = parent;
} else if (parent == null) {
mParent = null;
} else {
throw new RuntimeException("view " + this + " being added, but"
+ " it already has a parent");
}
}
public void invalidate(boolean invalidateCache) {
invalidateInternal(0, 0, mRight - mLeft, mBottom - mTop, invalidateCache, true);
}
void invalidateInternal(int l, int t, int r, int b, boolean invalidateCache,
boolean fullInvalidate) {
.....
final ViewParent p = mParent;
if (p != null && ai != null && l < r && t < b) {
final Rect damage = ai.mTmpInvalRect;
damage.set(l, t, r, b);
✍当这p就是mParent
p.invalidateChild(this, damage);
}
......
}
}
✍而mParent是在哪初始化的
if (preventRequestLayout) {
✍通过assignParent方法赋值
child.assignParent(this);
} else {
✍直接赋值
child.mParent = this;
}
就是在我们添加xml布局ViewGroup.addView的时候初始化的
这个mParent在requestLayout;invalidate等更新布局逐层向上传递时有重要作用!