android布局优化的一些实用建议

前言

android的绘制优化其实可以分为两个部分，即布局(ui)优化和卡顿优化，而布局优化的核心问题就是要解决因布局渲染性能不佳而导致应用卡顿的问题，所以它可以认为是卡顿优化的一个子集。

本文主要包括以下内容

1. 为什么要进行布局优化及android绘制，布局加载原理
2. 获取布局文件加载耗时的方法
3. 介绍一些布局优化的手段与方法
4. 一些常规优化手段
   

为什么要进行布局优化？

为什么要进行布局优化？答案是显而易见的，如果布局嵌套过深，或者其他原因导致布局渲染性能不佳，可能会导致应用卡顿 那么布局到底是如何导致渲染性能不佳的呢？首先我们应该了解下android绘制原理与布局加载原理

android绘制原理

android的屏幕刷新中涉及到最重要的三个概念（为便于理解，这里先做简单介绍）

• cpu：执行应用层的measure、layout、draw等操作，绘制完成后将数据提交给gpu
• gpu：进一步处理数据，并将数据缓存起来
• 屏幕：由一个个像素点组成，以固定的频率（16.6ms，即1秒60帧）从缓冲区中取出数据来填充像素点
  

总结一句话就是：cpu 绘制后提交数据、gpu 进一步处理和缓存数据、最后屏幕从缓冲区中读取数据并显示

双缓冲机制

看完上面的流程图，我们很容易想到一个问题，屏幕是以16.6ms的固定频率进行刷新的，但是我们应用层触发绘制的时机是完全随机的（比如我们随时都可以触摸屏幕触发绘制）. 如果在gpu向缓冲区写入数据的同时，屏幕也在向缓冲区读取数据，会发生什么情况呢？有可能屏幕上就会出现一部分是前一帧的画面，一部分是另一帧的画面，这显然是无法接受的，那怎么解决这个问题呢？

所以，在屏幕刷新中，android系统引入了双缓冲机制

gpu只向back buffer中写入绘制数据，且gpu会定期交换back buffer和frame buffer，交换的频率也是60次/秒，这就与屏幕的刷新频率保持了同步。

虽然我们引入了双缓冲机制，但是我们知道，当布局比较复杂，或设备性能较差的时候，cpu并不能保证在16.6ms内就完成绘制数据的计算，所以这里系统又做了一个处理。当你的应用正在往back buffer中填充数据时，系统会将back buffer锁定。如果到了gpu交换两个buffer的时间点，你的应用还在往back buffer中填充数据，gpu会发现back buffer被锁定了，它会放弃这次交换。

这样做的后果就是手机屏幕仍然显示原先的图像，这就是我们常常说的掉帧

布局加载原理

由上面可知，导致掉帧的原因是cpu无法在16.6ms内完成绘制数据的计算。而之所以布局加载可能会导致掉帧，正是因为它在主线程上进行了耗时操作，可能导致cpu无法按时完成数据计算

布局加载主要通过setcontentview来实现，我们就不在这里贴源码了，一起来看看它的时序图

我们可以看到，在setcontentview中主要有两个耗时操作

• 解析xml,获取xmlresourceparser,这是io过程
• 通过createviewfromtag,创建view对象，用到了反射
  

以上两点就是布局加载可能导致卡顿的原因，也是布局的性能瓶颈

获取布局文件加载耗时的方法

我们如果需要优化布局卡顿问题，首先最重要的就是：确定定量标准 所以我们首先介绍几种获取布局文件加载耗时的方法

常规获取

首先介绍一下常规方法

val start = system.currenttimemillis()
setcontentview(r.layout.activity_layout_optimize)
val inflatetime = system.currenttimemillis() - start

这种方法很简单，因为setcontentview是同步方法，如果想要计算耗时，直接将前后时间计算相减即可得到结果了

aop(aspectj,asm)

上面的方式虽然简单，但是却不够优雅，同时代码有侵入性，如果要对所有activity测量时，就需要在基类中复写相关方法了，比较麻烦了 下面介绍一种aop的方式计算耗时

    @around("execution(* android.app.activity.setcontentview(..))")
    public void getsetcontentviewtime(proceedingjoinpoint joinpoint) {
        signature signature = joinpoint.getsignature();
        string name = signature.toshortstring();
        long time = system.currenttimemillis();
        try {
            joinpoint.proceed();
        } catch (throwable throwable) {
            throwable.printstacktrace();
        }
        log.i("aop inflate",name + " cost " + (system.currenttimemillis() - time));
    }

上面用的aspectj，比较简单，上面的注解的意思是在setcontentview方法执行内部去调用我们写好的getsetcontentviewtime方法 这样就可以获取相应的耗时 我们可以看下打印的日志

i/aop inflate: appcompatactivity.setcontentview(..) cost 69
i/aop inflate: appcompatactivity.setcontentview(..) cost 25

这样就可以实现无侵入的监控每个页面布局加载的耗时 具体源码可见文末

获取任一控件耗时

有时为了更精确的知道到底是哪个控件加载耗时，比如我们新添加了自定义view,需要监控它的性能 我们可以利用setfactory2来监听每个控件的加载耗时 首先我们来回顾下setcontentview方法

    public final view trycreateview(@nullable view parent, @nonnull string name,
        ...
        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;
        }
        ...
        return view;
    }

在真正进行反射实例化xml结点前，会调用mfactory2的oncreateview方法 这样如果我们重写oncreateview方法，在其前后加上耗时统计，即可获取每个控件的加载耗时

    private fun inititeminflatelistener(){
        layoutinflatercompat.setfactory2(layoutinflater, object : factory2 {
            override fun oncreateview(
                parent: view?,
                name: string,
                context: context,
                attrs: attributeset
            ): view? {
                val time = system.currenttimemillis()
                val view = delegate.createview(parent, name, context, attrs)
                log.i("inflate item",name + " cost " + (system.currenttimemillis() - time))
                return view
            }

            override fun oncreateview(name: string, context: context, attrs: attributeset): view? {
                return null
            }
        })
    }

如上所示：真正的创建view的方法，仍然是调用delegate.createview,我们只是其之前与之后做了埋点 注意，inititeminflatelistener需要在oncreate之前调用 这样就可以比较方便地实现监听每个控件的加载耗时

布局加载优化的一些方法介绍

布局加载慢的主要原因有两个,一个是io,一个是反射 所以我们的优化思路一般有两个

1. 侧面缓解(异步加载)
2. 根本解决(不需要io,反射过程,如x2c,anko,compose等)
   

asynclayoutinflater方案

asynclayoutinflater 是来帮助做异步加载 layout 的，inflate(int, viewgroup, oninflatefinishedlistener) 方法运行结束之后 oninflatefinishedlistener 会在主线程回调返回 view；这样做旨在 ui 的懒加载或者对用户操作的高响应。

简单的说我们知道默认情况下 setcontentview 函数是在 ui 线程执行的，其中有一系列的耗时动作：xml的解析、view的反射创建等过程同样是在ui线程执行的，asynclayoutinflater 就是来帮我们把这些过程以异步的方式执行，保持ui线程的高响应。

使用如下:

    @override
    protected void oncreate(@nullable bundle savedinstancestate) {
        super.oncreate(savedinstancestate);
        new asynclayoutinflater(asynclayoutactivity.this)
                .inflate(r.layout.async_layout, null, new asynclayoutinflater.oninflatefinishedlistener() {
                    @override
                    public void oninflatefinished(view view, int resid, viewgroup parent) {
                        setcontentview(view);
                    }
                });
        // 别的操作
    }

这样做的优点在于将ui加载过程迁移到了子线程，保证了ui线程的高响应 缺点在于牺牲了易用性，同时如果在初始化过程中调用了ui可能会导致崩溃

x2c方案

x2c是掌阅开源的一套布局加载框架 它的主要是思路是在编译期，将需要翻译的layout翻译生成对应的java文件，这样对于开发人员来说写布局还是写原来的xml，但对于程序来说，运行时加载的是对应的java文件。这就将运行时的开销转移到了编译时 如下所示,原始xml文件：

<?xml version="1.0" encoding="utf-8"?>
<relativelayout xmlns:android="http://schemas.android.com/apk/res/android"
  xmlns:app="http://schemas.android.com/apk/res-auto"
  xmlns:tools="http://schemas.android.com/tools"
  android:layout_width="match_parent"
  android:layout_height="match_parent"
  android:paddingleft="10dp">

  <include
      android:id="@+id/head"
      layout="@layout/head"
      android:layout_width="wrap_content"
      android:layout_height="wrap_content"
      android:layout_centerhorizontal="true" />

  <imageview
      android:id="@+id/ccc"
      style="@style/bb"
      android:layout_below="@id/head" />
</relativelayout>

x2c 生成的 java 文件

public class x2c_2131296281_activity_main implements iviewcreator {
  @override
  public view createview(context ctx, int layoutid) {
        resources res = ctx.getresources();

        relativelayout relativelayout0 = new relativelayout(ctx);
        relativelayout0.setpadding((int)(typedvalue.applydimension(typedvalue.complex_unit_dip,10,res.getdisplaymetrics())),0,0,0);

        view view1 =(view) new x2c_2131296283_head().createview(ctx,0);
        relativelayout.layoutparams layoutparam1 = new relativelayout.layoutparams(viewgroup.layoutparams.wrap_content,viewgroup.layoutparams.wrap_content);
        view1.setlayoutparams(layoutparam1);
        relativelayout0.addview(view1);
        view1.setid(r.id.head);
        layoutparam1.addrule(relativelayout.center_horizontal,relativelayout.true);

        imageview imageview2 = new imageview(ctx);
        relativelayout.layoutparams layoutparam2 = new relativelayout.layoutparams(viewgroup.layoutparams.match_parent,(int)(typedvalue.applydimension(typedvalue.complex_unit_dip,1,res.getdisplaymetrics())));
        imageview2.setlayoutparams(layoutparam2);
        relativelayout0.addview(imageview2);
        imageview2.setid(r.id.ccc);
        layoutparam2.addrule(relativelayout.below,r.id.head);

        return relativelayout0;
  }
}

使用时如下所示,使用x2c.setcontentview替代原始的setcontentview即可

// this.setcontentview(r.layout.activity_main);
x2c.setcontentview(this, r.layout.activity_main);

x2c优点

1. 在保留xml的同时，又解决了它带来的性能问题
   
2. 据x2c统计，加载耗时可以缩小到原来的1/3
   

x2c问题

1. 部分属性不能通过代码设置,java不兼容
2. 将加载时间转移到了编译期，增加了编译期耗时
3. 不支持kotlin-android-extensions插件，牺牲了部分易用性
   

anko方案

anko是jetbrains开发的一个强大的库,支持使用kotlin dsl的方式来写ui,如下所示

class myactivity : appcompatactivity() {
    override fun oncreate(savedinstancestate: bundle?, persistentstate: persistablebundle?) {
        super.oncreate(savedinstancestate, persistentstate)
        myactivityui().setcontentview(this)
    }
}

class myactivityui : ankocomponent<myactivity> {
    override fun createview(ui: ankocontext<myactivity>) = with(ui) {
        verticallayout {
            val name = edittext()
            button("say hello") {
                onclick { ctx.toast("hello, ${name.text}!") }
            }
        }
    }
}

如上所示，anko使用kotlin dsl实现布局，它比我们使用java动态创建布局方便很多，主要是更简洁，它和拥有xml创建布局的层级关系，能让我们更容易阅读 同时，它去除了io与反射过程,性能更好，以下是anko与xml的性能对比

不过由于anko已经停止维护了，这里不建议大家使用，了解原理即可 anko建议大家使用jetpack compose来替代使用

compose方案

compose 是 jetpack 中的一个新成员，是 android 团队在2019年i/o大会上公布的新的ui库,目前处于beta阶段 compose使用纯kotlin开发，使用简洁方便，但它并不是像anko一样对viewgroup的封装 compose 并不是对 view 和 viewgroup 这套系统做了个上层包装来让写法更简单，而是完全抛弃了这套系统，自己把整个的渲染机制从里到外做了个全新的。

可以确定的是,compose是取代xml的官方方案

compose的主要优点就在于它的简单好用，具体来说就是两点

1. 它的声明式 ui
2. 去掉了 xml，只使用 kotlin 一种语言
   

由于本文并不是介绍compose的，所以就不继续介绍compose了，总得来说，compose是未来android ui开发的方向,读者可以自行查阅相关资料

一些常规优化手段

上面介绍了一些改动比较大的方案，其实我们在实际开发中也有些常规的方法可以优化布局加载 比如优化布局层级，避免过度绘制等，这些简单的手段可能正是可以应用到项目中的

优化布局层级及复杂度

1. 使用constraintlayout,可以实现完全扁平化的布局，减少层级
2. relativelayout本身尽量不要嵌套使用
3. 嵌套的linearlayout中，尽量不要使用weight，因为weight会重新测量两次
4. 推荐使用merge标签，可以减少一个层级
5. 使用viewstub延迟加载
   

避免过度绘制

1. 去掉多余背景色,减少复杂shape的使用
2. 避免层级叠加
3. 自定义view使用cliprect屏蔽被遮盖view绘制

总结

到此这篇关于android布局优化的一些实用建议的文章就介绍到这了,更多相关android布局优化内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！