「性能优化1.0」启动分类及启动时间的测量
 「性能优化1.1」计算方法的执行时间
 「性能优化1.2」异步优化
 「性能优化1.3」延迟加载方案
 「性能优化2.0」布局加载原理
 「性能优化2.1」LayoutInflater Hook控件加载耗时

一、绘制原理

CPU 负责计算需要展示的数据，而 GPU 负责将数据绘制到屏幕上。

屏幕绘制过程中涉及到两个基本概念：

屏幕刷新率：

屏幕刷新率代表屏幕在一秒内刷新屏幕的次数，这个值用赫兹来表示，取决于硬件的固定参数。这个值一般是60Hz,即每16.66ms系统发出一个 VSYNC 信号来通知刷新一次屏幕。

帧速率：

帧速率代表了GPU在一秒内绘制操作的帧数，比如30fps/60fps。

如果 GPU 无法在 16.6ms 完成一帧数据的绘制，对应的就是屏幕刷新率比帧速率快，屏幕会在两帧中显示同一个画面，这样给用户的直接感受就是卡顿，因为绘制速率跟不上屏幕的刷新速率。

二、布局加载原理

我在上一篇博客中描述了布局的加载流程「性能优化4」布局加载原理。在布局的加载中主要是分为两个过程，第一通过 IO 从磁盘中加载资源文件并封装为 XmlPullParser 对象，第二通过 XML 解析器解析 XML 并通过反射创建 View 对象。

如果 View 层级嵌套过深会导致：

加长 IO 读取时间。
加长反射时间。
导致 GPU 绘制不能及时完成，出现卡顿现象。

三、LayoutInflater

3.1、LayoutInflater 大致介绍

这里拷贝了源码的注释，从注释来看，它负责将 xml 的布局文件加载为一个 View 这样的一个功能。

这个过程会涉及两个步骤：

通过 IO 读取 xml 文件。
通过反射来创建对应的 View。

/**
 * Instantiates a layout XML file into its corresponding {@link android.view.View}
 */
@SystemService(Context.LAYOUT_INFLATER_SERVICE)
public abstract class LayoutInflater {...}

3.2、LayoutInflater.Factory

这个接口是干嘛用的呢？我们在上一节「性能优化4」布局加载原理分析提到，在创建 View 对象时，LayoutInflater#createViewFromTag中首先回去判断是否设置了 ①Factory2 或者 ②Factory，它会将 View 的创建工作交给这两个工厂类的其中一个去实现。

//LayoutInflater.java
View createViewFromTag(View parent, String name, Context context, AttributeSet attrs,
        boolean ignoreThemeAttr) {
    ...    
    try {
        View view;
        if (mFactory2 != null) {
            //①
            view = mFactory2.onCreateView(parent, name, context, attrs);
        } else if (mFactory != null) {
            //②
            view = mFactory.onCreateView(name, context, attrs);
        } else {
            view = null;
        }
       
        if (view == null) {
            final Object lastContext = mConstructorArgs[0];
            mConstructorArgs[0] = context;
            try {
                //③
                if (-1 == name.indexOf('.')) {
                    view = onCreateView(parent, name, attrs);
                } else {
                    view = createView(name, null, attrs);
                }
            } finally {
                mConstructorArgs[0] = lastContext;
            }
        }
        return view;
    } catch (InflateException e) {
        ...
    }   
}

看完上面的源码再来看看这个简易的操作图解：

LayoutInflater.Factory

下面我贴出来 Factory 的源码，我们从这个接口的注释也可以了解到它大致的作用，这是一个 Hook 操作，因此我们可以在这里做我们想做的事。

public interface Factory {
    /**
     * Hook you can supply that is called when inflating from a LayoutInflater.
     * You can use this to customize the tag names available in your XML
     * layout files.
     *
     * <p>
     * Note that it is good practice to prefix these custom names with your
     * package (i.e., com.coolcompany.apps) to avoid conflicts with system
     * names.
     *
     * @param name Tag name to be inflated.
     * @param context The context the view is being created in.
     * @param attrs Inflation attributes as specified in XML file.
     *
     * @return View Newly created view. Return null for the default
     *         behavior.
     */
    public View onCreateView(String name, Context context, AttributeSet attrs);
}

那么们可以通过 Factory 可以做啥事呢？

例如：可以全局修改 TextView 的颜色，字体等，这里推荐一篇张鸿洋的博文Android 探究 LayoutInflater setFactory里面介绍了 Factory 的一些使用方式。

3.3、Hook控件的加载耗时

LayoutInflaterCompat 是 support-v4 兼容包下的一个类，通过 setFactoty2 方法给对应的 getLayoutInflater() 设置一个 Factory工厂，其内部就是给 LayoutInflater 的 mFactory2 赋值。我们知道布局的加载是通过 LayoutInflater 布局加载器去加载的，因此这里设置的 Factory2 可以在 LayoutInflater 加载每一个控件时进行hook操作，具体的实现如下：

//MainActivity extends AppCompatActivity
@Override
protected void onCreate(Bundle savedInstanceState) {
    //Hook 每一个控件加载耗时
    LayoutInflaterCompat.setFactory2(getLayoutInflater(), new LayoutInflater.Factory2() {
        @Override
        public View onCreateView(View parent, String name, Context context, AttributeSet attrs) {
            //①
            long startTime = System.currentTimeMillis();
            //②
            View view = getDelegate().createView(parent, name, context, attrs);
            //③
            long cost = System.currentTimeMillis() - startTime;
            Log.d(TAG, "加载控件：" + name + "耗时：" + cost);
            return view;
        }
        @Override
        public View onCreateView(String name, Context context, AttributeSet attrs) {
            return null;
        }
    });
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
}

在①处打点开始时间
②处执行加载布局的工作，
③位置结束点，输出对应的时间差即是该控件的加载时间。

关于②处使用了 getDalegate().createView(...) 这个方法是在 support-v7兼容包下的 AppCompatActivity 中定义的。而如果项目中 BaseActivity 没有继承至 AppCompatActivity 那么②处就不能getDalegate().createView(...)这样写了。

有些项目的 BaseActivity 是直接继承至 FragmentActivity ，那么这时我们该怎么去操作呢？

我们再次回到 LayoutInflater#createViewFromTag源码：

//LayoutInflater.java
if (view == null) {
    final Object lastContext = mConstructorArgs[0];
    mConstructorArgs[0] = context;
    try {
        //①
        if (-1 == name.indexOf('.')) {
            view = onCreateView(parent, name, attrs);
        } else {
            view = createView(name, null, attrs);
        }
    } finally {
        mConstructorArgs[0] = lastContext;
    }
}

当没有设置 Factory2 ，Factory 或者 Factory#onCreateView，Factory2#onCreateView 返回 null 的情况，那么创建 View 的工作就交给 ①onCreateView方法。也就是说如果我们的 Activity 不是直接继承至 AppCompatActivity的话，那么就可以使用 LayoutInflater#createView(name, null, attrs)加载指定的控件。

//MainActivity extends FragmentActivity
@Override
protected void onCreate(Bundle savedInstanceState) {
    LayoutInflaterCompat.setFactory(getLayoutInflater(), new LayoutInflaterFactory() {
        @Override
        public View onCreateView(View parent, String name, Context context, AttributeSet attrs) {
            long startTime = System.currentTimeMillis();
            View view = null;
            try {
                view = getLayoutInflater().createView(name, null, attrs);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            long cost = System.currentTimeMillis() - startTime;
            map.put(parent,new Hodler(parent,view,name,cost));
            Log.d("=========", "加载布局：" + name + "耗时：" + cost);
            return view;
        }
    });
    super.onCreate(savedInstanceState);
}

总结：对于 LayoutInflater.Factory 的 hook 机制，我们以低侵入式的方式获取到每一个控件的加载耗时。

四、总结

好了，本小节主要简单地介绍了Android绘制原理，了解 GPU 绘制频率和屏幕刷新频率之间的关系。紧接着分享了布局加载加载原理，并且通过分析布局的加载过程我们知道可以通过 LayoutInflater.Factory 来 hook 控件的创建过程。并且最后通过LayoutInflater.Factory 实战来获取每一个控件的加载时间。通过分析这个时间，我们就可以初步判断哪些控件是比较耗时的，然后再做进一步的优化。

记录于 2019年3月20日