正文

Android应用开发中View绘制的一些优化点解析

︶ㄣSDDLL学院 メ
SDDLL学院V管理员 / 阅读
0710
这篇文章主要介绍了Android应用开发中View绘制的一些优化点解析,包括Layout布局和硬件加速等方面,需要的朋友可以参考下

这篇文章主要介绍了Android应用开发中View绘制的一些优化点解析,包括Layout布局和硬件加速等方面,需要的朋友可以参考下

 一个通常的错误观念就是使用基本的布局结构(例如：linearlayout、framelayout等)能够在大多数情况下
   产生高效率 的布局。 显然，你的应用程序里添加的每一个控件和每一个布局都需要初始化、布局(layout)、
   绘制 (drawing)。举例来说：嵌入一个linearlayout会产生一个太深的布局层次。更严重的是，嵌入几个使
   用 layout_weight属性的linearlayout 将会导致大量的开销，因为每个子视图都需要被测量两次。这是反复解析
   布局文件时重要的一点，例如在listview或者gridview中使用时。

 观察你的布局
 
     android sdk 工具箱包括一个称作“ hierarchy viewer”的工具，它允许你去在你的应用程序运行时分析
  布局。通过使用这个工具，能帮助你发现你的布局效率上的瓶颈问题。
 
     “ hierarchy viewer”工具允许你在已连接的设备或模拟器中选择正在运行的进程，然后呈现出布局层次树
   (layout tree)。每个正方块下的交通灯(见下图) --- 红绿蓝表现出了在测量(measure)、布局(layout)、以及绘制
   (draw)过程中的效率值，这能帮助你定位潜在的问题。
 
        假设listview 中的一项item 存在如下(见图 1)布局 ：

Android应用开发中View绘制的一些优化点解析

 “hierarchy viewer”工具可以在 <sdk>/tools路径下找到。当打开它时，“ hierarchy viewer”工具显示了
   所有可用的设备以及运行在这些设备上的进程。点击”load view hierarchy”来显示某个你选择的组件的ui布局
  层次。举例来说，图2展现了图1的布局层次树。

Android应用开发中View绘制的一些优化点解析

  在图2中，你可以直观看到这个三层的布局结构是存在一些问题的。点击项体现出了在每个测量(measure)、
    布局(layout)、以及绘制(draw)过程中的时间消耗(见图3)。很明显，该项(linearlayout)花费了最长的时间去
    测量、布局、绘制，你应该花点精力去优化它们。

Android应用开发中View绘制的一些优化点解析

 完成该布局文件渲染的时间分别为：
                测量过程：0.977ms
                布局过程： 0.167ms
                绘制过程：2.717ms
 
 修改布局文件
 
       由于上图中布局效率的低下是因为一个内嵌的 linearlayout控件，通过扁平化布局文件----让布局变得
  更浅更宽，而不是变得更窄更深层次 ，这样就能提升效率了。 一个relativelayout 作为根节点也能提供如上
  的布局效果(即图1)。 因此，  使用relativelayout 改变布局的设计，你可以看到现在我们的布局层次只有2层了。
  新的布局层次树如下：

Android应用开发中View绘制的一些优化点解析

  现在，完成该布局文件渲染的时间分别为：
                      测量过程：0.977ms
                      布局过程：0.167ms
                      绘制过程：2.717ms
  
      也许它只是一点点微小的改进，但这次它会被多次调用，因为是listview会布局所有的item，累积起来，
 改进后效果还是非常可观地。

      大部分的时间差异是由于使用了带有layout_weight 属性的linearlayout ，它能减缓测量过程的速度。这仅仅
 是一个例子，即每个布局都应该合适地被使用以及你应该认真考虑是否有必要采用“layout_weight" 属性。
 
 使用lint工具 

        一个好的实践就是在你的布局文件中使用lint工具去寻求可能优化布局层次的方法。lint已经取代了layoutopt
  工具并且它提供了更强大的功能。一些lint规则如下：

  1、使用组合控件 --- 包含了一个  imageview 以及一个 textview 控件的 linearlayout 如果能够作为一个
     组合控件将会被更有效的处理。
 2、合并作为根节点的帧布局(framelayout)  ----如果一个帧布局时布局文件中的根节点，而且它没有背景图片
  或者padding等，更有效的方式是使用<merge />标签替换该< framelayout />标签 。

                                        
 3、无用的叶子节点----- 通常来说如果一个布局控件没有子视图或者背景图片，那么该布局控件时可以被移除
       (由于它处于 invisible状态)。
 
 4、无用的父节点 -----  如果一个父视图即有子视图，但没有兄弟视图节点，该视图不是scrollview控件或者
    根节点，并且它没有背景图片，也是可以被移除的，移除之后，该父视图的所有子视图都直接迁移至之前父视图
    的布局层次。同样能够使解析布局以及布局层次更有效。
 
 5、过深的布局层次  ----内嵌过多的布局总是低效率地。考虑使用一些扁平的布局控件，例如 relativelayout、
      gridlayout ，来改善布局过程。默认最大的布局深度为10 。
 
 
     当使用eclipse环境开发时，lint能够自动解决一些问题，提供一些建议以及直接跳转到出错的代码中去核查。
  如果你没有使用eclipse，lint也可以通过命令行的方式运行。
  
  使用<include />标签复用布局文件
       尽管android通过内置了各种各样的控件提供了微小、可复用的交互性元素，也许你需要复用较大的
     组件 ---- 某些特定布局文件 。为了更有效率复用的布局文件，你可以使用<include />以及<merge />
     标签将其他的布局文件加入到当前的布局文件中。

          复用布局文件是一种特别强大的方法，它允许你创建可复用性的布局文件。例如，一个包含“yse”or“no”的
     button面版，或者是带有文字说明的 progressbar。复用布局文件同样意味着你应用程序里的任何元素都能从
     繁杂的布局文件提取出来进行单独管理，接着你需要做的只是加入这些独立的布局文件(因为他们都是可复用地)。
     因此，当你通过自定义view创建独立的ui组件时，你可以复用布局文件让事情变得更简单。

 1、创建一个可复用性的布局文件

        如果你已经知道复用布局的”面貌”，那么创建、定义布局文件( 命名以”.xml”为后缀)。例如，这里是一个来自
 g- kenya codelab 的布局文件，定义了在每个activity中都要使用的一个自定义标题 (titlebar.xml):由于这些
  可复用性布局被添加至其他布局文件中，因此，它的每个根视图(root view)最好是精确(exactly)的。

?
1
2
3
4
5
6
7
8
9
<framelayout xmlns:android="http://schemas.android.com/apk/res/android"
 android:layout_width=”match_parent”
 android:layout_height="wrap_content"
 android:background="@color/titlebar_bg">
 
 <imageview android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:src="@drawable/gafricalogo" />
</framelayout>


 2、使用<include />标签

          在需要添加这些布局的地方，使用<include />标签 。 例如，下面是一个来自g-kenya codelab的布局文件，
  它复用了上面列出的“title bar”文件， 该布局文件如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<linearlayout xmlns:android="http://schemas.android.com/apk/res/android"
 android:orientation="vertical"
 android:layout_width=”match_parent”
 android:layout_height=”match_parent”
 android:background="@color/app_bg"
 android:gravity="center_horizontal">
 
 <include layout="@layout/titlebar"/>
 
 <textview android:layout_width=”match_parent”
    android:layout_height="wrap_content"
    android:text="@string/hello"
    android:padding="10dp" />
 
 ...
 
</linearlayout>

       
          你也可以在<include />节点中为被添加的布局文件的root view定义特别标识，重写所有layout参数即可(任何
  以“android：layout_”为前缀的属性)。例如：

?
1
2
3
4
<include android:id=”@+id/news_title”
   android:layout_width=”match_parent”
   android:layout_height=”match_parent”
   layout=”@layout/title”/>

 3、使用<merge />标签

        当在布局文件中复用另外的布局时， <merge />标签能够在布局层次消除多余的视图元素。例如，如果你的
   主布局文件是一个垂直地包含两个view的linearlayout，该布局能够复用在其他布局中，而对任意包含两个view的
   布局文件都需要一个root view(否则， 编译器会提示错误)。然而，在该可复用性布局中添加一个linearlayout
   作为root view，将会导致一个垂直的linearlayout包含另外的垂直linearlayout。内嵌地linearlayout只能减缓
   ui效率，其他毫无用处可言。
            该复用性布局利用.xml呈现如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<linearlayout xmlns:android="http://schemas.android.com/apk/res/android"
  android:orientation="vertical"
  android:layout_width=”match_parent”
  android:layout_height=”match_parent”
  android:background="@color/app_bg"
  android:gravity="horizontal">
 
 <button
  android:layout_width="fill_parent"
  android:layout_height="wrap_content"
  android:text="@string/add"/>
 
 <button
  android:layout_width="fill_parent"
  android:layout_height="wrap_content"
  android:text="@string/delete"/>
</linearlayout>


      为了避免冗余的布局元素，你可以使用<merge />作为复用性布局文件地root view 。例如：
           使用<merge />标签的布局文件：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
<merge xmlns:android="http://schemas.android.com/apk/res/android">
 
 <button
  android:layout_width="fill_parent"
  android:layout_height="wrap_content"
  android:text="@string/add"/>
 
 <button
  android:layout_width="fill_parent"
  android:layout_height="wrap_content"
  android:text="@string/delete"/>
 
</merge>


         现在，当你添加该布局文件时(使用<include />标签)，系统忽略< merge />节点并且直接添加两个button去
  取代<include />节点。
  
   越少越好

        为了加速视图，从那些调用频繁的活动中减少不必要的代码。在ondraw()方法中开始绘制，它会给你最大的
   效益。特别低，你也应该减少在ondraw()方法中的内存分配，因为任何内存分配都可能导致内存回收，这将会
   引起不连贯。 在初始化或者动画之间分配对象。绝不要在动画运行时分配内存。


        另一方面需要减少ondraw()方法中的开销，只在需要时才调用ondraw()方法。通常invalidate()方法会调用
  ondraw()方法，因此减少对invalidate()的不必要调用。如果可能，调用它的重载版本即带有参数的invalidate()
  方法而不是无参的invalidate()方法。该带参数的方法invalidate()能使draw过程更有效，以及减少对落在该矩形
  区域(参数指定的区域)外视图的不必要重绘 。

       注，invalidate()的三个重载版本为：
            1 、public void invalidate (rect dirty)
            2、public void invalidate (int l, int t, int r, int b)
            3、public void invalidate ()


        另外的一个高代价的操作是布局过程(layout)。 任何时刻对view调用requestlayout()方法，android ui 框架
  都需要遍历整个view树，确定每个视图它们所占用的大小。如果在measure过程中有任何冲突，可能会多次遍历
  view树。ui设计人员有时为了实现某些效果，创建了较深层次的viewgroup。但这些深层次view树会引发效率
  问题。确保你的view树层次尽可能浅。


        如果你有的ui设计是复杂地，你应该考虑设计一个自定义viewgroup来实现layout过程。不同于内置view控件，
  自定义view能够假定它的每个子view的大小以及形状，同时能够避免为每个子view进行measure过程。 piechart
  展示了如何继承viewgroup类。 piechart带有子view，但它从来没有measure它们。相反，它根据自己的布局算法
  去直接设置每个子view的大小。
         
       如下代码所示：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
/**
 * custom view that shows a pie chart and, optionally, a label.
 */
public class piechart extends viewgroup {
 ...
 //
 // measurement functions. this example uses a simple heuristic: it assumes that
 // the pie chart should be at least as wide as its label.
 //
 @override
 protected int getsuggestedminimumwidth() {
  return (int) mtextwidth * 2;
 }
 @override
 protected int getsuggestedminimumheight() {
  return (int) mtextwidth;
 }
 
 @override
 protected void onmeasure(int widthmeasurespec, int heightmeasurespec) {
  // try for a width based on our minimum
  int minw = getpaddingleft() + getpaddingright() + getsuggestedminimumwidth();
 
  int w = math.max(minw, measurespec.getsize(widthmeasurespec));
 
  // whatever the width ends up being, ask for a height that would let the pie
  // get as big as it can
  int minh = (w - (int) mtextwidth) + getpaddingbottom() + getpaddingtop();
  int h = math.min(measurespec.getsize(heightmeasurespec), minh);
 
  setmeasureddimension(w, h);
 }
 
 @override
 protected void onlayout(boolean changed, int l, int t, int r, int b) {
  // do nothing. do not call the superclass method--that would start a layout pass
  // on this view's children. piechart lays out its children in onsizechanged().
 }
  
 @override
 protected void onsizechanged(int w, int h, int oldw, int oldh) {
  super.onsizechanged(w, h, oldw, oldh);
 
  //
  // set dimensions for text, pie chart, etc
  //
  // account for padding
 
  ...
 
  // lay out the child view that actually draws the pie.
  mpieview.layout((int) mpiebounds.left,
    (int) mpiebounds.top,
    (int) mpiebounds.right,
    (int) mpiebounds.bottom);
  mpieview.setpivot(mpiebounds.width() / 2, mpiebounds.height() / 2);
 
  mpointerview.layout(0, 0, w, h);
  ondatachanged();
 }
 
}


使用硬件加速

          android 3.0版本后，android 2d图形库能在大多数android设备上使用gpu(图形处理单元)加速。gpu硬件
  加速可以极大的优化多数应用程序，但它并不是每个应用程序的最优选择。android框架给予你是否在应用程序中
  使用硬件加速的控制力。

值得注意的是，我们必须手动在配置文件中设置应用程序api级别为11或者更高级别，即在 androidmanifest.xml进行如下配置：
 

?
1
<uses-sdk android:targetsdkversion="11"/>

         一旦你开启了硬件加速，你可能看不到效率的提升。mobile gpus 善于处理特定的任务，例如：伸缩、旋转、
   平移图片。它也有一些不擅长处理的任务，例如：绘制直线或曲线。常言道物尽其用，扬长避短，尽可能让gpu
   处理它擅长的任务，减少让其处理弱势任务的。


         在piechart 示例中，例如，相对来说绘制一个圆形是比较耗费资源的。每次旋转引起的重绘导致ui的迟缓。
   解决办法就是让view来呈现该圆形，并且设置该view的layer type属性为 layer_type_hardware,因此gpu
   能够缓存静态图片。示例中该view作为 piechart类的内部类存在，减少了为了实现这个方法的代码开销。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
private class pieview extends view {
 
 public pieview(context context) {
  super(context);
  if (!isineditmode()) {
   setlayertype(view.layer_type_hardware, null);
  }
 }
  
 @override
 protected void ondraw(canvas canvas) {
  super.ondraw(canvas);
 
  for (item it : mdata) {
   mpiepaint.setshader(it.mshader);
   canvas.drawarc(mbounds,
     360 - it.mendangle,
     it.mendangle - it.mstartangle,
     true, mpiepaint);
  }
 }
 
 @override
 protected void onsizechanged(int w, int h, int oldw, int oldh) {
  mbounds = new rectf(0, 0, w, h);
 }
 
 rectf mbounds;
}


          改变之后，只有view第一次显示的时候才会调用piechart.pieview.ondraw()方法。在应用程序的其他
   时间，绘制的图像将会作为图片缓存，重绘时gpu将任意旋转图像。


         然而这只是一个折中手段。缓存图片作为硬件层导致 video memory开销，video memory却是一种受限制的
 资源。 出于这个原因，在piechart.pieview的最终版本上，只有在用户滑动时才设置它的layer type属性为
  layer_type_hardware。在其他时间，仅仅设置它的layer type属性为 layer_type_hardware，这
  允许gpu停止缓存图片。


        最后，不要忘记分析你的代码。在一个view上做的优化技术可能会在其他view上产生不好的影响。