Android 自定义View总结（2）

属性动画和硬件加速

属性动画

ViewPropertyAnimator

1.使用View.animate()创建对象，以及使用ViewPropertyAnimator.translationX()等方法来设置动画；

2.可以连续调用来设置多个动画；

3.可以用setDuration()来设置持续时间；

4.可以用setStartDelay()来设置开始延时；

ObjectAnimator

使用ObjectAnimator.ofxxx()来创建对象，以及使用ObjectAnimator.statr()来主动启动动画。它的优势在于，可以为自定义属性设置动画。

ObjectAnimator animator = ObjectAnimator.ofObject(view, "radius", Utils.dp2px(200));

另外，自定义属性需要设置 getter 和 setter 方法，并且 setter 方法里需要调用 来触发重绘：

public float getRadius() {
return radius;
}
public void setRadius(float radius) {
this.radius = radius; invalidate();
}

可以使用 setduration()来设置持续时间；

可以用 setStartDelay()来设置开始延时；

以及其他一些便捷方法。

Interpolator

插值器，用于设置时间完成度到动画完成度的计算公式，直白地说即设置动画的速度曲线，通过setInterpolator(Interpolator)方法来设置.

常用的有

AccelerateDecelerateInterpolator:开始与结束的地方速率改变比较慢，在中间的时候加速

AccelerateInterpolator:开始的地方速率改变比较慢，然后开始加速

DecelerateInterpolator:在开始的地方快然后慢

LinearInterpolator: 以常量速率改变

PropertyValuesHolder

用于设置更加详细的动画，例如多个属性应用于同一个对象：

PropertyValuesHolder holder1 = PropertyValuesHolder.ofFloat("radius", Utils.dp2px(200));
PropertyValuesHolder holder2 = PropertyValuesHolder.ofFloat("offset", Utils.dp2px(100));
ObjectAnimator animator = PropertyValuesHolder.ofPropertyValuesHolder(view, holder1, holder2);

或者，配合使用 ，对一个属性分多个段：

Keyframe keyframe1 = Keyframe.ofFloat(0, Utils.dpToPixel(100)); 
Keyframe keyframe2 = Keyframe.ofFloat(0.5f, Utils.dpToPixel(250));
 Keyframe keyframe3 = Keyframe.ofFloat(1, Utils.dpToPixel(200)); 
PropertyValuesHolder holder = PropertyValuesHolder.ofKeyframe("radius", keyframe1, keyframe2, keyframe3);
ObjectAnimator animator = ObjectAnimator.ofPropertyValuesHolder(view, holder);

AnimatorSet 

将多个 Animator 合并在一起使用，先后顺序或并列顺序都可以：

AnimatorSet animatorSet = new AnimatorSet(); 
animatorSet.playTogether(animator1, animator2); 
animatorSet.start();

 TypeEvaluator

用于设置动画完成度到属性具体值的计算公式。默认的offInt()和ofFloat()已经有了自带的IntEvaluator和FloatEvaluator，但有的时候需要自己设置 Evaluator。例如，对于颜色，需要为 int 类型的颜色设置 ArgbEvaluator，而不是让它们使用 IntEvaluator：

animator.setEvaluator(new ArgbEvaluator());

3.使用 GPU 绘制就叫做硬件加速

怎么就加速了？

 1.GPU 分摊了工作

2.GPU 绘制简单图形（例如方形、圆形、直线）在硬件设计上具有先天优势，会更快

 3.流程得到优化（重绘流程涉及的内容更少）

硬件加速的缺陷：

兼容性。由于使用 GPU 的绘制（暂时）无法完成某些绘制，因此对于一些特定的 API，需要关闭硬件加速来转回到使用 CPU 进行绘制。

离屏缓冲：

4.saveLayer() 是针对 Canvas 的，所以在 onDraw() 里可以使用 saveLayer() 来圈出具体哪部分绘制要用离屏缓冲

5.然而……最新的文档表示这个方法太重了，能不用就别用，尽量用 setLayerType() 代替。

自定义布局

布局过程

1.确定每个 View 的位置和尺寸 作用：为绘制和触摸范围做支持

 2.绘制：知道往哪里绘制

 3.触摸反馈：知道用户点的是哪里

流程

1.从整体看：

测量流程：从根 View 递归调用每一级子 View 的 measure() 方法，对它们进行测量

布局流程：从根 View 递归调用每一级子 View 的 layout() 方法，把测量过程得出的子 View的位置和尺寸传给子 View，子 View 保存

2.从个体看，对于每个 View：

1. 运行前，开发者在 xml 文件里写入对 View 的布局要求 layout_xxx
2. 父 View 在自己的 onMeasure() 中，根据开发者在 xml 中写的对子 View 的要求，和自己的可用空间，得出对子 View 的具体尺寸要求
3. 子 View 在自己的 onMeasure() 中，根据自己的特性算出自己的期望尺寸（如果是 ViewGroup，还会在这里调用每个子 View 的 measure() 进行测量）
4. 父 View 在子 View 计算出期望尺寸后，得出子 View 的实际尺寸和位置
5. 子 View 在自己的 layout() 方法中，将父 View 传进来的自己的实际尺寸和位置保存（如果是 ViewGroup，还会在 onLayout() 里调用每个字 View 的 layout() 把它们的尺寸位置传给它们）

具体开发

继承已有的 View，简单改写它们的尺寸：SquareImageView

1. 重写 onMeasure()
2. 用 getMeasuredWidth() 和 getMeasuredSize() 获取到测量出的尺寸
3. 计算出最终要的尺寸
4. 用 setMeasuredDimension(width, height) 把结果保存

public class SquareImageView extends androidx.appcompat.widget.AppCompatImageView {
    public SquareImageView(Context context, @Nullable AttributeSet attrs) {
        super(context, attrs);
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);

        int measuredWidth = getMeasuredWidth();
        int measuredHeight = getMeasuredHeight();
        int size = Math.max(measuredWidth, measuredHeight);

        setMeasuredDimension(size, size); // 保存测得的尺寸
    }
}

对自定义 View 完全进行自定义尺寸计算：重写 onMeasure()：CircleView

1. 重写 onMeasure()
2. 计算出自己的尺寸
3. 用 resolveSize() 或者 resolveSizeAndState() 修正结果

3.1resolveSize() / resolveSizeAndState() 内部实现

3.1.1首先用 MeasureSpec.getMode(measureSpec) 和MeasureSpec.getSize(measureSpec) 取出父 对自己的尺寸限制类型和具体限制尺寸；

3.1.2如果 measure spec 的 mode 是 EXACTLY，表示父 View 对子 View 的尺寸做出了精确限制，所以就放弃计算出的 size，直接选用 measure spec 的 size；

3.1.3如果 measure spec 的 mode 是 AT_MOST，表示父 View 对子 View 的尺寸只限制了上限，需要看情况：

(1)如果计算出的 size 不大于 spec 中限制的 size，表示尺寸没有超出限制，所以选用计算出的 size；

(2)而如果计算出的 size 大于 spec 中限制的 size，表示尺寸超限了，所以选用spec 的 size，并且在 resolveSizeAndState() 中会添加标志MEASURED_STATE_TOO_SMALL（这个标志可以辅助父 View 做测量和布局的计算；

(3)如果 measure spec 的 mode 是 UNSPECIFIED，表示父 View 对子 View 没有任何尺寸限制，所以直接选用计算出的 size，忽略 spec 中的 size。

3.1.4使用 setMeasuredDimension(width, height) 保存结果

public class CircleView extends View {
    private static final int RADIUS = (int) Utils.dpToPixel(80);
    private static final int PADDING = (int) Utils.dpToPixel(30);

    Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);

    public CircleView(Context context, @Nullable AttributeSet attrs) {
        super(context, attrs);
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        int width = (PADDING + RADIUS) * 2;
        int height = (PADDING + RADIUS) * 2;

        width = resolveSizeAndState(width, widthMeasureSpec, 0);
        height = resolveSizeAndState(height, widthMeasureSpec, 0);
        setMeasuredDimension(width, height);
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);

        canvas.drawColor(Color.RED);
        canvas.drawCircle(PADDING + RADIUS, PADDING + RADIUS, RADIUS, paint);
    }
}

(1)遍历每个子 View，用 measureChildWidthMargins() 测量子 View

(2)需要重写 generateLayoutParams() 并返回 MarginLayoutParams 才能measureChildWithMargins() 方法

(3)有些子 View 可能需要重新测量（比如换行处）

(4)测量完成后，得出子 View 的实际位置和尺寸，并暂时保存

  @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        int widthUsed = 0;
        int heightUsed = 0;
        int lineWidthUsed = 0;
        int lineMaxHeight = 0;
        int specMode = MeasureSpec.getMode(widthMeasureSpec);
        int specWidth = MeasureSpec.getSize(widthMeasureSpec);
        for (int i = 0; i < getChildCount(); i++) {
            View child = getChildAt(i);
            measureChildWithMargins(child, widthMeasureSpec, 0, heightMeasureSpec, heightUsed);
            if (specMode != MeasureSpec.UNSPECIFIED &&
                    lineWidthUsed + child.getMeasuredWidth() > specWidth) {
                lineWidthUsed = 0;
                heightUsed += lineMaxHeight;
                lineMaxHeight = 0;
                measureChildWithMargins(child, widthMeasureSpec, 0, heightMeasureSpec, heightUsed);
            }
            Rect childBound;
            if (childrenBounds.size() <= i) {
                childBound = new Rect();
                childrenBounds.add(childBound);
            } else {
                childBound = childrenBounds.get(i);
            }
            childBound.set(lineWidthUsed, heightUsed, lineWidthUsed + child.getMeasuredWidth(), heightUsed + child.getMeasuredHeight());
            lineWidthUsed += child.getMeasuredWidth();
            widthUsed = Math.max(widthUsed, lineWidthUsed);
            lineMaxHeight = Math.max(lineMaxHeight, child.getMeasuredHeight());
        }

        int width = widthUsed;
        int height = heightUsed + lineMaxHeight;
        setMeasuredDimension(width, height);
    }

 2.重写 onLayout()

测量出所有子 View 的位置和尺寸后，计算出自己的尺寸，并用setMeasuredDimension(width, height) 保存 

最后重写 onLayout()遍历每个子 View，调用它们的 layout() 方法来将位置和尺寸传给它们：完整代码

public class TagLayout extends ViewGroup {
    List<Rect> childrenBounds = new ArrayList<>();

    public TagLayout(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        int widthUsed = 0;
        int heightUsed = 0;
        int lineWidthUsed = 0;
        int lineMaxHeight = 0;
        int specMode = MeasureSpec.getMode(widthMeasureSpec);
        int specWidth = MeasureSpec.getSize(widthMeasureSpec);
        for (int i = 0; i < getChildCount(); i++) {
            View child = getChildAt(i);
            measureChildWithMargins(child, widthMeasureSpec, 0, heightMeasureSpec, heightUsed);
            if (specMode != MeasureSpec.UNSPECIFIED &&
                    lineWidthUsed + child.getMeasuredWidth() > specWidth) {
                lineWidthUsed = 0;
                heightUsed += lineMaxHeight;
                lineMaxHeight = 0;
                measureChildWithMargins(child, widthMeasureSpec, 0, heightMeasureSpec, heightUsed);
            }
            Rect childBound;
            if (childrenBounds.size() <= i) {
                childBound = new Rect();
                childrenBounds.add(childBound);
            } else {
                childBound = childrenBounds.get(i);
            }
            childBound.set(lineWidthUsed, heightUsed, lineWidthUsed + child.getMeasuredWidth(), heightUsed + child.getMeasuredHeight());
            lineWidthUsed += child.getMeasuredWidth();
            widthUsed = Math.max(widthUsed, lineWidthUsed);
            lineMaxHeight = Math.max(lineMaxHeight, child.getMeasuredHeight());
        }

        int width = widthUsed;
        int height = heightUsed + lineMaxHeight;
        setMeasuredDimension(width, height);
    }

    @Override
    protected void onLayout(boolean changed, int l, int t, int r, int b) {
        for (int i = 0; i < getChildCount(); i++) {
            View child = getChildAt(i);
            Rect childBounds = childrenBounds.get(i);
            child.layout(childBounds.left, childBounds.top, childBounds.right, childBounds.bottom);
        }
    }

    @Override
    public LayoutParams generateLayoutParams(AttributeSet attrs) {
        return new MarginLayoutParams(getContext(), attrs);
    }
}

View.dispatchTouchEvent()

1.如果设置了 OnTouchListener，调用 OnTouchListener.onTouch()

(1)如果 OnTouchListener 消费了事件，返回 true

(2)如果 OnTouchListener 没有消费事件，继续调用自己的 onTouchEvent()，并返回和onTouchEvent() 相同的结果

2.如果没有设置 OnTouchListener，同上

ViewGroup.dispatchTouchEvent()

1.如果是用户初次按下（ACTION_DOWN），清空 TouchTargets 和 DISALLOW_INTERCEPT  标记拦截处理

2.如果不拦截并且不是 CANCEL 事件，并且是 DOWN 或者 POINTER_DOWN，尝试把pointer（手指）通过 TouchTarget 分配给子 View；并且如果分配给了新的子 View，调用child.dispatchTouchEvent() 把事件传给子 View

3.看有没有 TouchTarget

(1)如果没有，调用自己的 super.dispatchTouchEvent()

(2)如果有，调用 child.dispatchTouchEvent() 把事件传给对应的子 View（如果有的话）

4.如果是 POINTER_UP，从 TouchTargets 中清除 POINTER 信息,如果是 UP  或 CANCEL，重置状态

TouchTarget

作用：记录每个子 View 是被哪些 pointer（手指）

按下的结构：单向链表

拦截处理

1.如果不是初次按下，并且没有 TouchTarget，直接拦截

2.如果是初次按下，或者有 TouchTarget

(1)如果设置了 disallow intercept，不拦截

(2)否则，调用 onInterceptTouchEvent()，如果返回 true 则拦截，返回 false 则不拦截