AndroidView绘制流程分析及自定义View、ViewGroup进阶

最新推荐文章于 2024-10-10 10:13:12 发布

amengpyj

最新推荐文章于 2024-10-10 10:13:12 发布

阅读量779

点赞数 3

CC 4.0 BY-SA版权

分类专栏： android开发文章标签： android开发 view自定义 view绘制流程 layout

本文链接：https://blog.youkuaiyun.com/u011631275/article/details/47752481

android开发专栏收录该内容

4 篇文章

订阅专栏

本文将通过三种不同的实现方式讲解如何自定义一个View来实现跑马灯效果，包括重写onLayout、仅重写draw、以及利用动画实现。详细分析了每种方法的优缺点和实现原理，旨在帮助读者理解和掌握自定义滚动视图的技巧。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

这里将通过一个需求的几种不同的实现来给大家分析View的自定义。

源代码下载地址
[http://download.youkuaiyun.com/detail/u011631275/9019625]

这里写图片描述

我们先来看看最后要实现的效果。这类似一个跑马灯，一行文字，“11111 22222 33333 44444 55555 66666 77777 88888 99999” 不断滚动，99999之后又是11111。

实现这个需求有很多方法，网上可能也有很多开源的demo，关键是我们要知道哪种方法是最适合的，最优秀最有艺术感的。下面我将用几种方式实现它，有的方法并不好，有很多缺点，但是为了大家能理解自定义View，我觉得是有必要讲的。

一、第一种实现通过重写onlayout实现
缺点：当滚动速度调快时，会有些卡顿
目标：掌握onLayout的用法

    onLayout函数的作用：重新布局所有子View在当前ViewGroup中的位置。
    我的思路就是外部是一个水平方向的Linearlayout，内部是9个TextView。通过重写LinearLayout的onLayout来调整内部9个TextView的位置。然后通过不断的执行onLayout来达到这种滚动的效果。

    我们来看代码

  package com.pui.view;


import android.content.Context;
import android.os.Handler;
import android.os.Message;
import android.util.AttributeSet;
import android.view.View;
import android.view.animation.AnimationUtils;
import android.widget.LinearLayout;


public class MarqueeLinearLayout1 extends LinearLayout {

 // 跑马灯的状态 是否正在滚动
 private boolean MARQUEE_IS_RUNNING = false;
 // 是否已经初始化跑马灯滚动所需的数据
 private boolean IS_INIT = false;

 private int childCount;

 // private int[] childWidths;

 // 滚动步长 单位时间内滚动的距离
 private final int step = 2;
 // 多长时间layout一次 单位 毫秒
 private long Interval_Time = 20;

 //记录开始滚动的时间
 private long START_RUNNING_TIME = -1;

 private final int INIT_DATA = 0;

 private int oldDistance = 0;

 private final int REQUEST_LAYOUT = 1;

 private Handler handler = new Handler() {

  @Override
  public void handleMessage(Message msg) {
   // TODO Auto-generated method stub
   super.handleMessage(msg);
   switch (msg.what) {
   case INIT_DATA:
    initData();
    requestLayout();
    break;
   case REQUEST_LAYOUT:
    requestLayout();
    break;
   default:
    ;
   }
  }

 };

 public MarqueeLinearLayout1(Context context, AttributeSet attrs) {
  super(context, attrs);
  // TODO Auto-generated constructor stub

 }

 public MarqueeLinearLayout1(Context context) {
  super(context);
  // TODO Auto-generated constructor stub

 }

 @Override
 protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
  // TODO Auto-generated method stub
  super.onMeasure(widthMeasureSpec, heightMeasureSpec);
 }

 /**
  * onLayout中注意
  *
  * onLayout中再次requestLayout无效
  *
  */
 @Override
 protected void onLayout(boolean changed, int l, int t, int r, int b) {
  // TODO Auto-generated method stub
  /**
   * 这里我们能不能将else这个分支去掉呢？
   * 不行。我们的目的是每次onlayout都将子View向左移动一小段距离，
   * 但是并不是一开始就这样处理，我们必须先按LinearLayout
   * 默认的方式处理。因为刚开始时，所有的子View都
   * 还没有被布局在当前视图内部，即如果一开始我们调用childView.getLeft()
   * 将等于0
   *
   * 我们在Activity的onCreate中如果调用了某个View的getWidth，
   * 而如果这个View的宽使用wrap_content属性的话，那么获取到的宽度将为0，
   * 这也是一样的道理，因为当onCreate的时候，这个View还没有被被布局到父视图中
   *
   * 所以我们这个视图刚显示时，按一般的LinearLayout处理，等到所有的子视图已经被布局到
   * 相应的位置后再开始我们的滚动，这也是我们的start函数中
   * handler.sendEmptyMessageDelayed(INIT_DATA, 500);延迟500毫秒的原因了
   * 500毫秒足够Linearlayout布局完成了
   *
   * MARQUEE_IS_RUNNING、IS_INIT 这两个值算是开关，当我们将这两个值都改成true
   * 我们的视图才会开始滚动
   * MARQUEE_IS_RUNNING表示我们要开始滚动了，IS_INIT表示我们已经将需要的数据初始化了
   */
  // 如果已经初始化且已经开始跑动
  if (MARQUEE_IS_RUNNING && IS_INIT) {

   //period为从开始滚动到此刻的时间
   long period = AnimationUtils.currentAnimationTimeMillis()
     - START_RUNNING_TIME;
   /**
    * Interval_Time为20毫秒，step为2  意思是我希望滚动的速度为每20毫秒跑2个像素
    * 所以distance就是从开始滚动开始计时到此刻，该滚动多少距离
    */
   int distance = (int) (period / Interval_Time) * step;

   //下面这个可以省略，主要是如果移动距离还不到2个像素 那就忽略这次  等待下一次onLayout再一起滚动
   if (distance < 2) {
    handler.sendEmptyMessage(REQUEST_LAYOUT);
    return;
   }

   /**
    * 关键的来了，childCount为调用start后初始化的数据，代表当前视图的子视图的数量
    * 遍历子视图  
    * childView.getRight()为子视图的右边界在当前视图中的位置
    * oldDistance 为上一次执行onLayout时 distance的值
    *
    * 所以两次执行onLayout之间，滚动的距离为（distance-oldDistance）
    * cright就为子视图将要滚动后的右边界
    * left + oldDistance - distance就为滚动之后的左边界
    * 如果这个这个值小于0，就代表有一个子View已经滚动出界了，这时候就要将它移到最右边那个子
    * View的右边
    *
    * 啥意思呢？就是我们的内容在不断向左滚动，当有一个TextView滚动到窗口外面去了，就得将这个
    * View移到所有子View的最后面，这样才能保证不断循环出现。
    */
   for (int i = 0; i < childCount; i++) {
    View childView = getChildAt(i);
    int left = childView.getLeft();
    int right = childView.getRight();


    int cright = right + oldDistance - distance;
    if (cright < 0) {
     int width = (right - left);
     childView.layout(left + oldDistance - distance + width
       * childCount, t, cright
       + width * childCount, b);
    } else {
     childView.layout(left + oldDistance - distance, t, cright, b);
    }
   }
   //记录这次onLayout的distance到oldDistance
   oldDistance = distance;


   /**
    * onLayout执行完毕，发送异步消息，通知再次执行onLayout
    * 注意：这里不能直接使用requestLayout()请求重新布局，
    *
    * 我们看看requestLayout中的代码，注意下面这句，它会判断父视图是不是处于
    * layoutRequested的状态，我们当前就在onlayout中，所以父视图的
    * isLayoutRequested()必然返回true,所以不会传递到父控件去执行
    *  mParent.requestLayout();
    *  所以我们记住了，不要在onlayout、layout中再去requestLayout
    *  
    *   if (!mParent.isLayoutRequested()) {
    *    mParent.requestLayout();
    *      }
    */
   handler.sendEmptyMessage(REQUEST_LAYOUT);
  } else {
   super.onLayout(changed, l, t, r, b);
  }
 }

 // 开始滚动跑马灯
 public void start() {
  handler.sendEmptyMessageDelayed(INIT_DATA, 500);
 }

 public void initData() {
  MARQUEE_IS_RUNNING = true;
  childCount = getChildCount();
  START_RUNNING_TIME = AnimationUtils.currentAnimationTimeMillis();
  IS_INIT = true;
 }

 public void stop(){
  MARQUEE_IS_RUNNING = false;
 }
}

我们再来看看布局文件main_demo1.xml

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="vertical" >

<com.pui.view.MarqueeLinearLayout1 
    android:id="@+id/marqueeLayout1"
    android:layout_width="wrap_content"
    android:layout_height="50dp"
    android:orientation="horizontal"
    >

    <TextView 
        android:layout_width="100dp"
        android:layout_height="wrap_content"
        android:paddingRight="20dp"
        android:text="11111"/>
    <TextView 
        android:layout_width="100dp"
        android:layout_height="wrap_content"
        android:paddingRight="20dp"
        android:text="22222"/>
    <TextView 
        android:layout_width="100dp"
        android:layout_height="wrap_content"
        android:paddingRight="20dp"
        android:text="33333"/>
    <TextView 
        android:layout_width="100dp"
        android:layout_height="wrap_content"
        android:paddingRight="20dp"
        android:text="44444"/>
    <TextView 
        android:layout_width="100dp"
        android:layout_height="wrap_content"
        android:paddingRight="20dp"
        android:text="55555"/>
    <TextView 
        android:layout_width="100dp"
        android:layout_height="wrap_content"
        android:paddingRight="20dp"
        android:text="66666"/>
    <TextView 
        android:layout_width="100dp"
        android:layout_height="wrap_content"
        android:paddingRight="20dp"
        android:text="77777"/>
    <TextView 
        android:layout_width="100dp"
        android:layout_height="wrap_content"
        android:paddingRight="20dp"
        android:text="88888"/>
    <TextView 
        android:layout_width="100dp"
        android:layout_height="wrap_content"
        android:paddingRight="20dp"
        android:text="99999"/>

</com.pui.view.MarqueeLinearLayout1>
</LinearLayout>

主Activity

package com.example.marqueedemo;
import com.example.putil.PLog;
import com.pui.view.MarqueeLinearLayout1;
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
public class MainActivity extends Activity {
 private MarqueeLinearLayout1 marqueeLay1;
 @Override
 protected void onCreate(Bundle savedInstanceState) {
  // TODO Auto-generated method stub
  super.onCreate(savedInstanceState);
  setContentView(R.layout.main_demo1);
  marqueeLay1 = (MarqueeLinearLayout1) findViewById(R.id.marqueeLayout1);
 }
 @Override
 protected void onResume() {
  // TODO Auto-generated method stub
  super.onResume();
  marqueeLay1.start();
 }
}

运行后我们会发现，当滚动速度比较慢的时候还能满足需求，但是当滚动速度要求比较快时（调整 private long Interval_Time 的值; ），会卡顿。主要有以下几个原因导致卡顿
1.重新layout后还会draw，耗时比较长，而且这个时间我们不可控.
2.onLayout结束后通过一个异步消息让handler再去请求重新布局。而requestLayout最终其实也是通过一个异步消息让主线程去重新布局的，
所以从onLayout结束到下一次onlayout执行主线程至少要处理了两次消息，这还是我们忽略其他消息的前提。
知道了原因，我们就得想怎么优化了。

我们知道View的重绘大概会经历measure layout draw三个过程，draw是最后一步，上面那种方式要经历layout、draw两个过程，我认为比较耗时且不好控制，那能不能只经历draw呢？接下来我们就看下面的方式，通过不断draw来实现。

二、第二种实现
在实现之前，我们先来看看draw流程
1.画当前View的背景
2.判断是否需要画渐变框，如果需要，计算渐变框相关属性
3.调用onDraw画当前视图本身的内容我们设计的View一般会重写这个函数
4.dispatchDraw(canvas); 我们设计的View一般会重写这个函数，主要是画各个子View
5.画渐变框
6.画滚动条

那么我们需要的滚动应该重写哪个函数呢？1,2,5,6显然不是，我们的需求不涉及这些。onDraw()画视图本身，我们可以看看LinearLayout等布局视图的源码，发现它们都不会重写这个函数，都直接使用的View类的onDraw，而View的onDraw函数中没有任何代码。所以我们判断对ViewGroup而言，onDraw()没有任何意义。最后我们只剩下一种选择，4.dispatchDraw。有同学说为什么我们不直接重写draw()函数？我们当然可以这么做，但是draw函数是谷歌提供的，它内部的实现是一套标准的流程，我们为什么要去破坏它呢，比如第一步画View的背景，既然它已经有了，我们为什么还要重写而且还未必能写的比他好。

我们接着来看dispatchDraw的流程

   @Override
    protected void dispatchDraw(Canvas canvas) {
        final int count = mChildrenCount;
        final View[] children = mChildren;
        int flags = mGroupFlags;
        //这部分关于动画   我们暂时不说，后面有一种方式就是利用自定义的动画去实现
        if ((flags & FLAG_RUN_ANIMATION) != 0 && canAnimate()) {
                   ....
            }
        ...
        mPrivateFlags &= ~DRAW_ANIMATION;
        mGroupFlags &= ~FLAG_INVALIDATE_REQUIRED;
        boolean more = false;
        final long drawingTime = getDrawingTime();
      ....
            for (int i = 0; i < count; i++) {
                final View child = children[getChildDrawingOrder(count, i)];
                if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE || child.getAnimation() != null) {
                    more |= drawChild(canvas, child, drawingTime);
                }
            }
      ...
        // mGroupFlags might have been updated by drawChild()
        flags = mGroupFlags;
        if ((flags & FLAG_INVALIDATE_REQUIRED) == FLAG_INVALIDATE_REQUIRED) {
            invalidate(true);
        }
     .....
    }

dispatchDraw的流程除了动画的部分，关键就是遍历子View,并调用drawChild函数。

1.判断是否存在矩阵变换（矩阵变换是动画的知识，我们在下面的方式中详细说）

2.重新计算滚动值

3.根据滚动值为子视图设置canvas坐标原点。

4.根据获取的矩阵重新设置画布

5.生成子视图的剪切图

6.绘制子视图

drawChild函数中我们重点关注下面几句

child.computeScroll(); 计算滚动值这个函数默认是没做任何处理的
final int sx = child.mScrollX;
final int sy = child.mScrollY;

即我们如果实现computeScroll()函数，并在这个函数中改变滚动值，并让它不断重绘。那么我们改变谁的滚动值呢，每个子View的吗？
当然不是，我们改变的是外面的LinearLayout的滚动值，所以我们也不是重写child的computeScroll(),我们重写的是LinearLayout的computeScroll()函数，这个函数在LinearLayout的父视图的drawChild函数中被调用（注意是LinearLayout的父视图）

好了，我们开始我们的第二种实现。

我们前面说了不重新layout 只是重新draw 但是不重新layout 当内容滚出界面后怎么从尾部再次滚出来呢？

来看下面几张图
假设大框为手机屏幕，中间的小块是内容
图1
这里写图片描述

这时候View1在左侧边界上，一直向左侧滚动。
图2
这里写图片描述

一直到View1的右侧滑到边界上，因为我们不想重新布局，所以我们不能将View1移到队列的尾部去，那么怎么才能显示出滚动的效果呢？
我们将往回滑动，滑动到哪个位置呢？滑到View1和图2中View2位置重叠，这时候View2,View3,View4也必然和图2中的View3,View4,View5重叠。
然后让视图继续执行从图1到图2的过程。这样虽然视图一直在滚动，但是还做不到内容的循环，所以得将各个子视图的内容往前移一个视图的位置，在这个过程中我们还得吧View2视图的内容的移到View1视图中，View3视图的内容移到View2视图中，View4视图的内容移到View3中。。。

说的简单点这里将视图和内容区别对待，其实View并没有循环滚动，而是不断的滚一段距离回到原位置然后继续滚一段距离再回到原位置，只不过在回到原位置时将所有子View的内容向前搬动了一个子View ，这样给人一种错觉就是内容在循环滚动。

图3
这里写图片描述

package com.pui.view;
import android.content.Context;
import android.graphics.Canvas;
import android.os.Handler;
import android.os.Message;
import android.util.AttributeSet;
import android.util.Log;
import android.view.animation.AnimationUtils;
import android.widget.LinearLayout;
import android.widget.TextView;
public class MarqueeLinearLayout2 extends LinearLayout {
 // 跑马灯的状态 是否正在滚动
 private boolean MARQUEE_IS_RUNNING = false;
 // 是否已经初始化跑马灯滚动所需的数据
 private boolean IS_INIT = false;
 private int childCount;
 private final int INIT_DATA = 0;
 // 记录开始滚动的时间
 private long START_RUNNING_TIME = -1;
 // 滚动步长 单位时间内滚动的距离
 private final int step = 2;
 // 多长时间layout一次 单位 毫秒
 private long Interval_Time = 5;
 private static int FIRST_ITEM = 0;

 private int itemCount = 0;

 //滚动显示的内容
 private String[] textStrs = { "深证：", "23.345%", "44656.5", "3.567%", "沪证",
   "34.456%", "32324", "5.754%", "沪深300", "36.456%", "366624",
   "9.754%" };

 private Handler handler = new Handler() {
  @Override
  public void handleMessage(Message msg) {
   // TODO Auto-generated method stub
   super.handleMessage(msg);
   switch (msg.what) {
   case INIT_DATA:
    initData();
    requestLayout();
    break;
   default:
    ;
   }
  }
 };
 public MarqueeLinearLayout2(Context context, AttributeSet attrs) {
  super(context, attrs);
  // TODO Auto-generated constructor stub
 }
 public MarqueeLinearLayout2(Context context) {
  super(context);
  // TODO Auto-generated constructor stub
 }

 /**
  * 父视图会调用当前视图的computeScroll()重新计算MarqueeLinearLayout2的滚动值，
  * 然后根据滚动值拖动画布
  * 所以我们要做的就是在computeScroll()中重新设置视图的mScrollX值，而能够改变这个值的
  * 函数只有scrollTo和scrollBy
  *
  *
  */
 public void computeScroll() {

  /**
   * 如果跑马灯已经启动 且数据已经初始化
   */
  if (MARQUEE_IS_RUNNING && IS_INIT) {
   /**
    * 当运行到图1 或者图3的状态时，我们记录一次START_RUNNING_TIME ，这个时刻是视图回到原位置的时间
    *
    *  passTime 记录从恢复原位置到此刻所运行的时间
    */
   int passTime = (int) (AnimationUtils.currentAnimationTimeMillis() - START_RUNNING_TIME);

   /**
    *  我设置的速度为  每Interval_Time毫秒滚动step的像素
    *  所以在passTime时间内 视图滚动了distance距离
    */
   int distance =(int) (step * passTime / Interval_Time);

   //

   //首次运行走else分支
   if (START_RUNNING_TIME != -1) {
    TextView textFirst = (TextView) getChildAt(0);
    /**
     * 获取第一个TextView的宽度，
     * 如果滚动的距离已经大于这个宽度，
     * 即滚动出界面了，就调用scrollTo(0,0)回到原位置
     *
     * FIRST_ITEM是什么？
     * textStrs是内容的数组，FIRST_ITEM表示第一个子视图显示的内容在数组中的下标
     * 知道了这个下标 就方便takeTextToNext()中重新设置内容了
     * 这里将这个下标往后移一个位置，如果已经到了最后就重新移到第一个
     *
     * 最后重新记录下开始时间
     *
     */
    if (distance >= textFirst.getWidth()) {
     scrollTo(0, 0);
     FIRST_ITEM = (++FIRST_ITEM % itemCount);
     takeTextToNext();
     START_RUNNING_TIME = (int) AnimationUtils
       .currentAnimationTimeMillis();
    } else {
     scrollTo(distance, 0);
    }
   } else {
    START_RUNNING_TIME = (int) AnimationUtils.currentAnimationTimeMillis();
   }
   // 必须调用该方法，否则不一定能看到滚动效果
   postInvalidate();
  }
  super.computeScroll();
 }

 public void takeTextToNext() {
  Log.i("tags", "===takeTextToNext==>>===count=" + childCount);
  //遍历子视图，重新设置内容 第一个子视图的下标我们已经知道  后面的在此基础加i就行 直到最后一个再回到第一个
  for (int i = 0; i < childCount; i++) {
   TextView view = (TextView) getChildAt(i);
   view.setText(textStrs[(FIRST_ITEM + i) % itemCount]);
  }
 }
 // 开始滚动跑马灯
 public void start() {
  handler.sendEmptyMessageDelayed(INIT_DATA, 500);
 }
 public void initData() {
  MARQUEE_IS_RUNNING = true;
  itemCount = textStrs.length;

  childCount = getChildCount();
  //初始化视图的内容
  takeTextToNext();
  START_RUNNING_TIME = AnimationUtils.currentAnimationTimeMillis();
  IS_INIT = true;
 }
}

布局文件main_demo2.xml

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="vertical" >

<com.pui.view.MarqueeLinearLayout2
    android:id="@+id/marqueeLayout2"
    android:layout_width="fill_parent"
    android:layout_height="50dp"
    android:orientation="horizontal"
    >

    <TextView 
        android:layout_width="100dp"
        android:layout_height="wrap_content"

        />
     <TextView 
         android:layout_width="100dp"
        android:layout_height="wrap_content"

        />
     <TextView 
         android:layout_width="100dp"
        android:layout_height="wrap_content"

        />
     <TextView 
         android:layout_width="100dp"
        android:layout_height="wrap_content"

        />
     <TextView 
         android:layout_width="100dp"
        android:layout_height="wrap_content"

        />
     <TextView 
         android:layout_width="100dp"
        android:layout_height="wrap_content"

        />

</com.pui.view.MarqueeLinearLayout2>
</LinearLayout>

三、动画方式实现

 protected boolean drawChild(Canvas canvas, View child, long drawingTime) {
   ....
     final Animation a = child.getAnimation();
        if (a != null) {
            final boolean initialized = a.isInitialized();
            if (!initialized) {
                a.initialize(cr - cl, cb - ct, getWidth(), getHeight());
                a.initializeInvalidateRegion(0, 0, cr - cl, cb - ct);
                child.onAnimationStart();
            }

            more = a.getTransformation(drawingTime, mChildTransformation,
                    scalingRequired ? mAttachInfo.mApplicationScale : 1f);
            if (scalingRequired && mAttachInfo.mApplicationScale != 1f) {
                if (mInvalidationTransformation == null) {
                    mInvalidationTransformation = new Transformation();
                }
                invalidationTransform = mInvalidationTransformation;
                a.getTransformation(drawingTime, invalidationTransform, 1f);
            } else {
                invalidationTransform = mChildTransformation;
            }
            transformToApply = mChildTransformation;

            concatMatrix = a.willChangeTransformationMatrix();

            if (more) {
                if (!a.willChangeBounds()) {
                    if ((flags & (FLAG_OPTIMIZE_INVALIDATE | FLAG_ANIMATION_DONE)) ==
                            FLAG_OPTIMIZE_INVALIDATE) {
                        mGroupFlags |= FLAG_INVALIDATE_REQUIRED;
                    } else if ((flags & FLAG_INVALIDATE_REQUIRED) == 0) {
                        // The child need to draw an animation, potentially offscreen, so
                        // make sure we do not cancel invalidate requests
                        mPrivateFlags |= DRAW_ANIMATION;
                        invalidate(cl, ct, cr, cb);
                    }
                } else {
                    if (mInvalidateRegion == null) {
                        mInvalidateRegion = new RectF();
                    }
                    final RectF region = mInvalidateRegion;
                    a.getInvalidateRegion(0, 0, cr - cl, cb - ct, region, invalidationTransform);

                    // The child need to draw an animation, potentially offscreen, so
                    // make sure we do not cancel invalidate requests
                    mPrivateFlags |= DRAW_ANIMATION;

                    final int left = cl + (int) region.left;
                    final int top = ct + (int) region.top;
                    invalidate(left, top, left + (int) (region.width() + .5f),
                            top + (int) (region.height() + .5f));
                }
            }
        } else if ((flags & FLAG_SUPPORT_STATIC_TRANSFORMATIONS) ==
                FLAG_SUPPORT_STATIC_TRANSFORMATIONS) {
            final boolean hasTransform = getChildStaticTransformation(child, mChildTransformation);
            if (hasTransform) {
                final int transformType = mChildTransformation.getTransformationType();
                transformToApply = transformType != Transformation.TYPE_IDENTITY ?
                        mChildTransformation : null;
                concatMatrix = (transformType & Transformation.TYPE_MATRIX) != 0;
            }
        }

        concatMatrix |= !childHasIdentityMatrix;

        // Sets the flag as early as possible to allow draw() implementations
        // to call invalidate() successfully when doing animations
        child.mPrivateFlags |= DRAWN;

        if (!concatMatrix && canvas.quickReject(cl, ct, cr, cb, Canvas.EdgeType.BW) &&
                (child.mPrivateFlags & DRAW_ANIMATION) == 0) {
            return more;
        }

        float alpha = child.getAlpha();
        // Bail out early if the view does not need to be drawn
        if (alpha <= ViewConfiguration.ALPHA_THRESHOLD && (child.mPrivateFlags & ALPHA_SET) == 0 &&
                !(child instanceof SurfaceView)) {
            return more;
        }

        if (hardwareAccelerated) {
            // Clear INVALIDATED flag to allow invalidation to occur during rendering, but
            // retain the flag's value temporarily in the mRecreateDisplayList flag
            child.mRecreateDisplayList = (child.mPrivateFlags & INVALIDATED) == INVALIDATED;
            child.mPrivateFlags &= ~INVALIDATED;
        }


        return more;
    }

我们重点关注动画相关的代码
final Animation a = child.getAnimation(); 从子View中获取Animation对象，
（1）、调用Animation对象的isInitialized()方法判断Animation是否已经初始化.
（2）、如果没有初始化，调用Animation对象的initialize和initializeInvalidateRegion方法初始化。
（3）、调用Animation对象的getTransformation方法，这个方法的第一个参数为当前时间，第二个参数为Transformation类型的对象，当该方法返回时，矩阵对象可以从里面获取。返回值为true表示动画还未结束，false表示动画结束了。
（4）、如果上一步返回true,会接着调用 invalidate，表示马上要接着重绘，这样可以使动画更连贯
调用invalidate并不是意味着立马重绘，而是向主线程的MessageQueue发送了一个异步消息说我要重绘了,但是主线程其实正在忙呢，忙啥呢？当然是在draw()，我们现在不就是在draw()–>dispatchDraw()—>drawChild中, 所以只有当这次draw完成后，主线程才会再次从MessageQueue中获取消息，发现又是一次重绘。才会再次执行draw的过程。
（5）、根据动画获取的矩阵绘制。

  public boolean getTransformation(long currentTime, Transformation outTransformation,
            float scale) {
        mScaleFactor = scale;
        return getTransformation(currentTime, outTransformation);
    }

  public boolean getTransformation(long currentTime, Transformation outTransformation) {

        if (mStartTime == -1) {
            mStartTime = currentTime;
        }

        final long startOffset = getStartOffset();
        final long duration = mDuration;
        float normalizedTime;
        if (duration != 0) {
            normalizedTime = ((float) (currentTime - (mStartTime + startOffset))) /
                    (float) duration;
        } else {
            // time is a step-change with a zero duration
            normalizedTime = currentTime < mStartTime ? 0.0f : 1.0f;
        }

        final boolean expired = normalizedTime >= 1.0f;
        mMore = !expired;

        if (!mFillEnabled) normalizedTime = Math.max(Math.min(normalizedTime, 1.0f), 0.0f);

        if ((normalizedTime >= 0.0f || mFillBefore) && (normalizedTime <= 1.0f || mFillAfter)) {
         .....

            final float interpolatedTime = mInterpolator.getInterpolation(normalizedTime);

        //我们自定义动画一班会重写这个方法
            applyTransformation(interpolatedTime, outTransformation);
        }

        if (expired) {
            if (mRepeatCount == mRepeated) {
                if (!mEnded) {
                    mEnded = true;
                    guard.close();
                    if (mListener != null) {
                        mListener.onAnimationEnd(this);
                    }
                }
            } else {
                if (mRepeatCount > 0) {
                    mRepeated++;
                }

                if (mRepeatMode == REVERSE) {
                    mCycleFlip = !mCycleFlip;
                }

                mStartTime = -1;
                mMore = true;

                if (mListener != null) {
                    mListener.onAnimationRepeat(this);
                }
            }
        }

        if (!mMore && mOneMoreTime) {
            mOneMoreTime = false;
            return true;
        }

        return mMore;
    }

注意下面这句代码， mInterpolator这个变量是通过setInterpolator设置进去的
mInterpolator.getInterpolation(normalizedTime);
Interpolator是一个可以看成一个转换器，传入的是一个时间相关的参数，传出的是一个移动距离相关的，至于怎么转换，我们可以通过自定义Interpolator自己实现。

normalizedTime为到当前为止，动画持续的时间占整个动画需要持续的时间的比例，整个动画需要持续的时间是我们定义Animation时设置的。
如果这个比例大于等于1了，则动画有可能结束了（注意还没有确认需要结束，只是可能），expired = normalizedTime >= 1.0f;

如果比例大于1，在判断要求的重复次数和当前已经重复的次数是否一致，一致那就真的结束了，如果不一致，那就将mStartTime = -1; mMore = true; 表示动画还未真正结束，还得重复。
mRepeatCount这个值当前类搜索可以知道是通过setRepeatCount这个函数设置的。

  if (expired) {

            if (mRepeatCount == mRepeated) {
                if (!mEnded) {
                    mEnded = true;
                    guard.close();
                    if (mListener != null) {
                        mListener.onAnimationEnd(this);
                    }
                }
            } else {
                if (mRepeatCount > 0) {
                    mRepeated++;
                }

                if (mRepeatMode == REVERSE) {
                    mCycleFlip = !mCycleFlip;
                }

                mStartTime = -1;
                mMore = true;

                if (mListener != null) {
                    mListener.onAnimationRepeat(this);
                }
            }

我们现在需要实现滚动，那就是要对所有的子View添加一个左方向移动的动画了。来看看我是怎么自定义动画的。

android系统自带有平移的动画类，叫做TranslateAnimation，但是它并不适用我们的需求，我们这要求循环滚动。虽然不适合，但是我们完全可以在它的基础上修改。我们学习一样新东西不就是从模仿开始的吗。

package com.example.marqueedemo.anim;
import android.view.animation.Animation;
import android.view.animation.LinearInterpolator;
import android.view.animation.Transformation;
public class MyTranslateAnimation extends Animation {
 private int mFromXType = ABSOLUTE;
 private int mToXType = ABSOLUTE;
 private float mFromXValue = 0.0f;
 private float mToXValue = 0.0f;
 private float viewlen = 0.0f;

 private float mFromXDelta;
 private float mToXDelta;
 private float lend;

 public MyTranslateAnimation(float fromXDelta, float toXDelta,
   float fromYDelta, float toYDelta) {
  mFromXValue = fromXDelta;
  mToXValue = toXDelta;

  mFromXType = ABSOLUTE;
  mToXType = ABSOLUTE;
 }

 public MyTranslateAnimation(int fromXType, float fromXValue, int toXType,
   float toXValue, int fromYType, float fromYValue, int toYType,
   float toYValue) {
  mFromXValue = fromXValue;
  mToXValue = toXValue;

  mFromXType = fromXType;
  mToXType = toXType;
 }

 public void setWidth(int width){
  viewlen = width;
 }

 @Override
 protected void applyTransformation(float interpolatedTime, Transformation t) {
  float dx = 0f;

  float distance = lend *interpolatedTime;
  if(distance < (-mToXDelta)){
   dx=mFromXDelta-distance;
  }else{
   dx=mFromXDelta+lend - distance;
  }
  t.getMatrix().setTranslate(dx, 0);
 }
 @Override
 public void initialize(int width, int height, int parentWidth,
   int parentHeight) {
  super.initialize(width, height, parentWidth, parentHeight);
  mFromXDelta = resolveSize(mFromXType, mFromXValue, width, parentWidth);
  mToXDelta = resolveSize(mToXType, mToXValue, width, parentWidth);
  lend = resolveSize(mFromXType, viewlen, width, parentWidth);
  setInterpolator(new LinearInterpolator());
  //setFillAfter(true);
  setRepeatCount(-1);
 }
}

先来想一下我们的动画和普通的移动动画有什么区别
1.无限循环
2.从左边滚动出界后，会再次从右侧滚出

initialize函数中，我们添加setInterpolator(new LinearInterpolator()); 因为我们的滚动是匀速的，也就是说我们前面mInterpolator.getInterpolation(normalizedTime); normalizedTime和返回的值是成正比的。
setRepeatCount(-1); 设置重复次数，当次数为负数时，将会无限循环。
lend为整个可滚动的视图宽度，包括屏幕外的那部分，也就是12个TextView的宽度我们是通过最后一个TextView的getRight获取的

applyTransformation中 lend *interpolatedTime; 为一共滚动的距离，如果这个距离小于-mToXDelta，即还没有超出左侧边界，
dx=mFromXDelta-distance; 如果超出了，那就dx=mFromXDelta+lend - distance;

动画定义好了我们怎么用呢？

package com.pui.view;

import com.example.marqueedemo.anim.MyTranslateAnimation;
import com.example.putil.PLog;

import android.content.Context;
import android.os.Handler;
import android.os.Message;
import android.util.AttributeSet;
import android.util.Log;
import android.widget.LinearLayout;
import android.widget.TextView;

public class MarqueeLinearLayout3 extends LinearLayout {

 private int childCount;

 private final int INIT_DATA = 0;



 private static int FIRST_ITEM = 0;

 private int itemCount = 0;

 // 滚动显示的内容
 private String[] textStrs = { "深证：", "23.345%", "44656.5", "3.567%", "沪证",
   "34.456%", "32324", "5.754%", "沪深300", "36.456%", "366624",
   "9.754%" };

 public MarqueeLinearLayout3(Context context, AttributeSet attrs) {
  super(context, attrs);
  // TODO Auto-generated constructor stub
 }

 public MarqueeLinearLayout3(Context context) {
  super(context);
  // TODO Auto-generated constructor stub
 }

 private Handler handler = new Handler() {

  @Override
  public void handleMessage(Message msg) {
   // TODO Auto-generated method stub
   super.handleMessage(msg);
   switch (msg.what) {
   case INIT_DATA:
    initData();
    requestLayout();
    break;

   default:
    ;
   }
  }

 };

 public void takeTextToNext() {
  Log.i("tags", "===takeTextToNext==>>===count=" + childCount);
  // 遍历子视图，重新设置内容 第一个子视图的下标我们已经知道 后面的在此基础加i就行 直到最后一个再回到第一个
  for (int i = 0; i < childCount; i++) {
   TextView view = (TextView) getChildAt(i);
   view.setText(textStrs[(FIRST_ITEM + i) % itemCount]);
  }

 }

 // 开始滚动跑马灯
 public void start() {
  handler.sendEmptyMessageDelayed(INIT_DATA, 500);
 }

 public void initData() {

  itemCount = textStrs.length;

  childCount = getChildCount();
  // 初始化视图的内容
  takeTextToNext();


  int width = getChildAt(childCount-1).getRight();

  PLog.i("tags", "width==" + width);

//为所有子View添加动画
  loadAnimations(width);
 }

 private void loadAnimations(int width) {
  for (int i = 0; i < childCount; i++) {
   TextView view = (TextView) getChildAt(i);


   int right = view.getRight();
   MyTranslateAnimation trans = new MyTranslateAnimation(0f,
     -right, 30f, 300f);
   trans.setDuration(5000);
   trans.setWidth(width);

   view.setAnimation(trans);

   PLog.i("tags",
     "mleft===" + view.getLeft() + "===right=" + view.getRight()
       + "===count=" + childCount);

  }
 }
}

动画方式的实现也讲完了，这种方式的缺点是为每个子View添加了各自的动画，增加了运算量，而且对每个View的动画处理也要注意之间的衔接，毕竟我们要滚动的是整个视图，但动画却是添加在子View上。

这里三种方式我并没有做过多的测试，而且我确定一定存在兼容性问题。在这里讲这么多重点是分析怎么自定义一个View 怎么重写它的方法，以及理解View重绘的原理。这篇就到此结束了，TextView好像有两个属性android:ellipsize=”marquee” android:marqueeRepeatLimit=”marquee_forever”也有跑马灯的效果，但是好像速度不可调，且会停顿。我暂时还未来得及看那TextView那一块的源码，打算接下去几天看看，然后在下一篇中通过类似的途径实现跑马灯。