LayoutInflater 源码解析

港控/mmm° 2022-11-19 01:27 107阅读 0赞

# 前言 #

`LayoutInflater`有多个如下填充函数：

//LayoutInflater.java
    class LayoutInflater{
        
     	public View inflate(int resource, ViewGroup root)
        public View inflate(XmlPullParser parser, ViewGroup root, boolean attachToRoot) 
        public View inflate(XmlPullParser parser, ViewGroup root)
        public View inflate(int resource, ViewGroup root, boolean attachToRoot)  
    }

但他们最后都会调用到  
`public View inflate(XmlPullParser parser, ViewGroup root, boolean attachToRoot)`

不过我们首先从下面的代码开始分析

LayoutInflater.from(this).inflate(R.layout.activity_main,this,false)

//LayoutInflater.java
     public View inflate(int resource, ViewGroup root, boolean attachToRoot) {
        
            final Resources res = getContext().getResources();
         	//将布局文件转化为一个xml解析器，这里不需要太过于关心
            final XmlResourceParser parser = res.getLayout(resource);
            try {
        
            	//
                return inflate(parser, root, attachToRoot);
            } finally {
        
            	//释放资源
                parser.close();
            }
        }
    
        public View inflate(XmlPullParser parser, ViewGroup root, boolean attachToRoot) {
        
            synchronized (mConstructorArgs) {
        
                
    			//这里得到根布局的属性
    			// <Framelayout
    			//   android:width="wrap_content"
    			//	 ......
    			//             />
    			// 这里得到的就是android:width等
    			// 
    			//
                final AttributeSet attrs = Xml.asAttributeSet(parser);
                
                Context lastContext = (Context)mConstructorArgs[0];
                
                mConstructorArgs[0] = mContext;
                
                View result = root;
    
                    // xml解析操作，这里最要是遍历到xml的根view节点，
                    int type;
                    while ((type = parser.next()) != XmlPullParser.START_TAG &&
                            type != XmlPullParser.END_DOCUMENT) {
        
                        // Empty
                    }
    
                    //得到节点名称，比如framelayout，merge，include等
                    final String name = parser.getName();
                    
                    //如果是merge节点
                    if (TAG_MERGE.equals(name)) {
        
                      //..略
                    } else {
        
                     	//用找到的根节点名称和属性创建一个view
                        final View temp = createViewFromTag(root, name, attrs, false);
    					//布局参数
                        ViewGroup.LayoutParams params = null;
    					//如果传入的父布局不为空
                        if (root != null) {
        
                          
                            // 只要传入的父布局那么不管是否添加到父布局都会生成一个LayoutParams
                            params = root.generateLayoutParams(attrs);
                            if (!attachToRoot) {
        
                             	//如果传入不附加到父布局，那么就给自己设置一个LayoutParams
                             	//如果传入附加到父布局，后面通过addview关联到LayoutParams
                                temp.setLayoutParams(params);
                            }
                        }
    
                       
                        //填充子view
                        rInflate(parser, temp, attrs, true, true);
                       
    
                    	//如果父布局不为空，并且要添加到父布局，那么
                    	//添加父布局的同时将LayoutParams传入
                        if (root != null && attachToRoot) {
        
                            root.addView(temp, params);
                        }
    
                      
                        if (root == null || !attachToRoot) {
        
                            result = temp;
                        }
                    }
    
               
    
                return result;
            }
        }

上面的代码比较简单，我们做下总结：  
`LayoutInflater.inflate`函数使用时，如果传入的父布局参数，那么不管是否添加到布局中，都会生成一个布局参数给填充的`view`。

我们最后再看`createViewFromTag`函数的实现

//LayoutInflater.java
    
        View createViewFromTag(View parent, String name, AttributeSet attrs, boolean inheritContext) {
        
        	
        	//
        	//发现一个新的语法
        	 // <view
            // 		app:layout_constraintTop_toTopOf="parent"
            // 		app:layout_constraintLeft_toLeftOf="parent"
            // 		android:layout_width="300dp"
            //		class="com.example.example.MyView"
            // 		android:layout_height="300dp"/>
          	// 如果是view有一个class字段属性那么会构造class字段的view
        	//
            if (name.equals("view")) {
        
                name = attrs.getAttributeValue(null, "class");
            }
    
            Context viewContext;
            //如果父布局不为空，且传入继承上下文的参数
            //那么就是用父布局的上下文
            if (parent != null && inheritContext) {
        
                viewContext = parent.getContext();
            } else {
        
                viewContext = mContext;
            }
    
            // 获取这个view里面一个theme字段，并且如果找到就利用ContextThemeWrapper进行
            // 传入
            final TypedArray ta = viewContext.obtainStyledAttributes(attrs, ATTRS_THEME);
            final int themeResId = ta.getResourceId(0, 0);
            
            if (themeResId != 0) {
        
                viewContext = new ContextThemeWrapper(viewContext, themeResId);
            }
            ta.recycle();
            
    		//如果你节点名称是TAG_1995 （blink），会构建一个BlinkLayout，这个view，会一直闪烁，
    		//个人感觉没啥用，有兴趣的同学可以试试
    		//<blink
            // 	app:layout_constraintTop_toTopOf="parent"
            // 	app:layout_constraintLeft_toLeftOf="parent"
            // 	android:layout_width="300dp"
            //	android:layout_height="300dp"/>
            //                                       
        	//	<View
         	//   	android:layout_width="2"
         	//   	android:background="#f1f"
         	//   	android:layout_height="300dp"/>
      		//</blink>
    		//
    		//
            if (name.equals(TAG_1995)) {
        
                return new BlinkLayout(viewContext, attrs);
            }
    
    
             View view;
             //mFactory2是一个Factory2对象，一般情况下都为空
             //一些换肤框架通过构造一个mFactory2给activity的layoutinflate进行一个替换操作
             if (mFactory2 != null) {
        
                 view = mFactory2.onCreateView(parent, name, viewContext, attrs);
             } else if (mFactory != null) {
        
             	//使用mFactory来加载 后文在详解
                 view = mFactory.onCreateView(name, viewContext, attrs);
             } else {
        
                 view = null;
             }
    		 //mPrivateFactory是在构造函数被传入的，从构造函数的上下文获取
             if (view == null && mPrivateFactory != null) {
        
                 view = mPrivateFactory.onCreateView(parent, name, viewContext, attrs);
             }
    		//如果所有的生成view的factorty都是null那么调用默认的函数
             if (view == null) {
        
                 final Object lastContext = mConstructorArgs[0];
                 mConstructorArgs[0] = viewContext;
                 try {
        
                 	 //如果名字里面不存在.这个分割符号，直接给名字添加前缀android.view.
                     if (-1 == name.indexOf('.')) {
        
                         //我们分析下onCreateView函数
                         view = onCreateView(parent, name, attrs);
                     } else {
        
                         view = createView(name, null, attrs);
                     }
                 } finally {
        
                     mConstructorArgs[0] = lastContext;
                 }
             }
    
             
             return view;
    
            
        }
        
        protected View onCreateView(String name, AttributeSet attrs)
                throws ClassNotFoundException {
        
            //添加默认前缀    
            return createView(name, "android.view.", attrs);
        }
    
    
        public final View createView(String name, String prefix, AttributeSet attrs)
                throws ClassNotFoundException, InflateException {
        
                
            Constructor<? extends View> constructor = sConstructorMap.get(name);
            Class<? extends View> clazz = null;
    
    
            if (constructor == null) {
        
              //略 大概就是寻找构造函数的一些代码，由于没有太多的深入理解的地方这里可以先跳过
            }
    
            Object[] args = mConstructorArgs;
            args[1] = attrs;
    
            constructor.setAccessible(true);
            //反射构造
            final View view = constructor.newInstance(args);
           
            return view;
    
            
        }

最后分析下三个`mPrivateFactory`,`mFactory`,`mFactory2`相关代码，上面我们发现他们的优先级分别为:  
1 `mFactory2`  
2 `mFactory`  
3 `mPrivateFactory`

其内部声明如下

//LayoutInflater.java
    class c{
        
        private Factory mFactory;
        private Factory2 mFactory2;
        private Factory2 mPrivateFactory;
    }

我们看到有两个不同的类分别是`Factory`.`Factory2`其类声明如下：

//LayoutInflater.java
      public interface Factory {
        
            public View onCreateView(String name, Context context, AttributeSet attrs);
        }

//LayoutInflater.java
        public interface Factory2 extends Factory {
        
          
            public View onCreateView(View parent, String name, Context context, AttributeSet attrs);
        }

`Factorty2`比`Factory`在`onCreateView`函数中多一个`parent`参数，所以能做的事情可能更多。

最后我们看下他们在哪里赋值：

//LayoutInflater.java
    class LayoutInflater{
        
    	//构造函数赋值，这里由于我们没法直接new所以对我们作用不大
    	 protected LayoutInflater(LayoutInflater original, Context newContext) {
        
    	        mContext = newContext;
    	        mFactory = original.mFactory;
    	        mFactory2 = original.mFactory2;
    	        mPrivateFactory = original.mPrivateFactory;
    	        setFilter(original.mFilter);
    	}
    	 //设置mFactory属性，请注意mFactorySet标志变量
    	 //可见setFactory仅能调用一次
    	 public void setFactory(Factory factory) {
        
            if (mFactorySet) {
        
                throw new IllegalStateException("A factory has already been set on this LayoutInflater");
            }
            if (factory == null) {
        
                throw new NullPointerException("Given factory can not be null");
            }
            mFactorySet = true;
            if (mFactory == null) {
        
                mFactory = factory;
            } else {
        
                mFactory = new FactoryMerger(factory, null, mFactory, mFactory2);
            }
        }
         //设置setFactory2属性，请注意mFactorySet标志变量
    	 //可见setFactory仅能调用一次
           public void setFactory2(Factory2 factory) {
        
            if (mFactorySet) {
        
                throw new IllegalStateException("A factory has already been set on this LayoutInflater");
            }
            if (factory == null) {
        
                throw new NullPointerException("Given factory can not be null");
            }
            mFactorySet = true;
            if (mFactory == null) {
        
                mFactory = mFactory2 = factory;
            } else {
        
                mFactory = mFactory2 = new FactoryMerger(factory, factory, mFactory, mFactory2);
            }
        }
    	 //mPrivateFactory可以多次设置
    	  public void setPrivateFactory(Factory2 factory) {
        
            if (mPrivateFactory == null) {
        
                mPrivateFactory = factory;
            } else {
        
                mPrivateFactory = new FactoryMerger(factory, factory, mPrivateFactory, mPrivateFactory);
            }
        }
    }