本文作者
作者:陈小缘
链接:
https://blog.csdn.net/u011387817/article/details/80313184
本文由作者授权发布。
本文为原文中的一部分,原文除了还包含一个实例,还有 fling 的处理的一个比较有意思的知识点。话说我告诉小缘要发这篇文章的时候,他估计修改了一下内容,还触发了CSDN的 bug...被CSDN当成新文章了,估计下一次炫酷的UI估计是第十四式了,上一式:
这交互炸了系列 第十二式之年年有鱼
说起View的动画播放,大家肯定都是轻车熟路了,如果一个View,它有监听点击事件,那么在播放位移动画后,监听的位置按道理,也应该在它最新的位置上(即位移后的位置),在这种情况下我们用View的startAnimation就不奏效了:
TranslateAnimation translateAnimation = new TranslateAnimation(0, 150, 0, 300);
translateAnimation.setDuration(500);
translateAnimation.setFillAfter(true);
mView.startAnimation(translateAnimation);

可以看到,在View位移之后,监听点击事件的区域还是在原来的地方。
我们再看下用属性动画的:
mView
.animate()
.translationX(150)
.translationY(300)
.setDuration(500)
.start();

监听点击事件的区域随着View的移动而更新了。
嘻嘻,我们通过实践来验证了这个说法。
那么我们做的这个是要支持触摸事件的,肯定是使用第二种方法。
ViewPropertyAnimator的源码分析相信大家之前也都已经看过其他大佬们的文章了,这里就只讲讲关键代码:
ViewPropertyAnimator它不是ValueAnimator的子类,哈哈,这个有点意外吧,我们直接看startAnimation方法(这个方法是start()里面调用的):
private void startAnimation() {
...
//可以看到这里创建了ValueAnimator对象
ValueAnimator animator = ValueAnimator.ofFloat(1.0f);
...
animator.addUpdateListener(mAnimatorEventListener);
...
animator.start();
}
中间那里addUpdateListener(mAnimatorEventListener),我们来看看这个listener里面做了什么:
@Override
public void onAnimationUpdate(ValueAnimator animation) {
...
...
ArrayList<NameValuesHolder> valueList = propertyBundle.mNameValuesHolder;
if (valueList != null) {
int count = valueList.size();
for (int i = 0; i < count; ++i) {
NameValuesHolder values = valueList.get(i);
float value = values.mFromValue + fraction * values.mDeltaValue;
if (values.mNameConstant == ALPHA) {
alphaHandled = mView.setAlphaNoInvalidation(value);
} else {
setValue(values.mNameConstant, value);
}
}
}
...
...
}
else里面调用了setValue方法,我们再继续跟下去 (哈哈,感觉好像捉贼一样):
private void setValue(int propertyConstant, float value) {
final View.TransformationInfo info = mView.mTransformationInfo;
final RenderNode renderNode = mView.mRenderNode;
switch (propertyConstant) {
case TRANSLATION_X:
renderNode.setTranslationX(value);
break;
case TRANSLATION_Y:
renderNode.setTranslationY(value);
break;
case TRANSLATION_Z:
renderNode.setTranslationZ(value);
break;
case ROTATION:
renderNode.setRotation(value);
break;
case ROTATION_X:
renderNode.setRotationX(value);
break;
case ROTATION_Y:
renderNode.setRotationY(value);
break;
case SCALE_X:
renderNode.setScaleX(value);
break;
case SCALE_Y:
renderNode.setScaleY(value);
break;
case X:
renderNode.setTranslationX(value - mView.mLeft);
break;
case Y:
renderNode.setTranslationY(value - mView.mTop);
break;
case Z:
renderNode.setTranslationZ(value - renderNode.getElevation());
break;
case ALPHA:
info.mAlpha = value;
renderNode.setAlpha(value);
break;
}
}
我们可以看到,它就调用了View的mRenderNode里面的setXXX方法,最关键就是这些方法啦,其实这几个setXXX方法在View里面也有公开的,我们也是可以直接调用的,所以我们在处理ACTION_MOVE的时候,就直接调用它而不用播放动画啦。
我们现在验证一下这个方案可不可行:
先试试setTranslationY:

将setTranslationY方法换成setRotation看看:

好了,经过我们实践验证了这个方案是可行的,在旋转之后,监听点击事件的位置也更新了,这正好是我们需要的效果。
哈哈,其实现在就有点 知其然而不知其所以然 的感觉了,既然我们都知道补间动画不能改变接受触摸事件的区域,而属性动画就可以。
那么,有没有想过为什么会这样呢?
可能有同学就会说了: “因为属性动画改变了坐标”
真的是这样吗?
额,如果这个"坐标"指的是getX,getY取得的值,那就是对的。为什么呢?很简单,我们来看看getX和getY的方法源码就知道了:
public float getX() {
return mLeft + getTranslationX();
}
public float getY() {
return mTop + getTranslationY();
}
哈哈,看到了吧,它们返回的值都分别加上了对应的Translation的值,而属性动画更新帧时,也是更新了Translation的值,所以当动画播放完毕,getX和getY时,总是能取到正确的值。
但如果说这个坐标是指left,top,right,bottom呢,那就不对了,为什么呢?因为经过我们刚刚对ViewPropertyAnimator的源码分析,知道了位移动画最终也只是调用了RenderNode的setTranslation方法,而left,top,right,bottom这四个值并没有改变。
这时候可能有同学就会说了:我不信!既然没有真正改变它的坐标,那它接受触摸事件的区域怎么也会跟着移动呢?
好吧,既然你不信,那我们来做个试验就知道了,这次需要到 设置 - 开发者选项 里面把显示布局边界这个选项打开:

关键代码:
mView.setOnTouchListener(new View.OnTouchListener() {
int lastX, lastY;
Toast toast = Toast.makeText(TestActivity.this, "", Toast.LENGTH_SHORT);
@Override
public boolean onTouch(View v, MotionEvent event) {
int x = (int) event.getRawX();
int y = (int) event.getRawY();
if (event.getAction() == MotionEvent.ACTION_MOVE) {
//Toolbar和状态栏的高度
int toolbarHeight = (getWindow().getDecorView().getHeight() - findViewById(R.id.root_view).getHeight());
int widthOffset = mView.getWidth() / 2;
int heightOffset = mView.getHeight() / 2;
mView.setTranslationX(x - mView.getLeft() - widthOffset);
mView.setTranslationY(y - mView.getTop() - heightOffset - toolbarHeight);
toast.setText(String.format("left: %d, top: %d, right: %d, bottom: %d",
mView.getLeft(), mView.getTop(), mView.getRight(), mView.getBottom()));
toast.show();
}
lastX = x;
lastY = y;
return true;
}
});
看看效果:

emmm,我们开启了布局边界选项之后,可以看到当View移动的时候,那个框框并没有跟着移动,且我们打印的left, top, right, bottom的值一直都是一样的。
好,我们把setTranslation改成layout方法看看:
代码:
@Override
public boolean onTouch(View v, MotionEvent event) {
...
if (event.getAction() == MotionEvent.ACTION_MOVE) {
...
mView.layout(x - widthOffset, y - heightOffset - toolbarHeight,
x + widthOffset, y + heightOffset - toolbarHeight);
...
}
return true;
}
效果:

哈哈哈,看到了吧,用layout方法来移动View,那个框框也会跟着走的,且打印的ltrb值,也会跟着变(废话),而使用setTranslation的话,就像出窍了一样。。。
相信现在大家都已经知道了为什么说setTranslation方法也不是真正能改变坐标了吧。
好了,我们现在回到上面的问题:既然setTranslation方法没有真正的改变坐标,那为什么触摸区域却会跟着移动呢?
这个就需要看一下ViewGroup的源码了,我们先从哪里开始看呢?
emmm,肯定是从dispatchTouchEvent方法开始啦,原因想必大家都已经想到了吧。
我们要先找到判断ACTION_DOWN的,然后再找遍历子View的for循环,看看它是怎么找到偏移后的View的:
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
...
if (actionMasked == MotionEvent.ACTION_DOWN
|| (split && actionMasked == MotionEvent.ACTION_POINTER_DOWN)
|| actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
...
final View[] children = mChildren;
//从最后添加到ViewGroup的View(最上面的)开始递减遍历
for (int i = childrenCount - 1; i >= 0; i--) {
final int childIndex = getAndVerifyPreorderedIndex(childrenCount, i, customOrder);
final View child = getAndVerifyPreorderedView(preorderedList, children, childIndex);
...
//判断当前遍历到的子View是否符合条件
if (!canViewReceivePointerEvents(child)
|| !isTransformedTouchPointInView(x, y, child, null)) {
ev.setTargetAccessibilityFocus(false);
continue;
}
//找到合适的子View之后,将事件向下传递
if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {
...
}
...
}
}
}
我们重点看for循环里面的第一个if,因为它能决定是否还要继续往下执行。通过看方法名能猜到,前面的方法大概就是判断子View能不能接受到事件,它里面是这样的:
private static boolean canViewReceivePointerEvents(@NonNull View child) {
return (child.mViewFlags & VISIBILITY_MASK) == VISIBLE
|| child.getAnimation() != null;
}
emmm,不可见的时候又没有设置动画,自然就不会把触摸事件给它了。
我们来看看第二个:isTransformedTouchPointInView方法:
protected boolean isTransformedTouchPointInView(float x, float y, View child,
PointF outLocalPoint) {
final float[] point = getTempPoint();
point[0] = x;
point[1] = y;
transformPointToViewLocal(point, child);
final boolean isInView = child.pointInView(point[0], point[1]);
if (isInView && outLocalPoint != null) {
outLocalPoint.set(point[0], point[1]);
}
return isInView;
}
中间调用了transformPointToViewLocal方法,看看:
public void transformPointToViewLocal(float[] point, View child) {
point[0] += mScrollX - child.mLeft;
point[1] += mScrollY - child.mTop;
if (!child.hasIdentityMatrix()) {
child.getInverseMatrix().mapPoints(point);
}
}
我们先放一放这个hasIdentityMatrix方法,直接看if里面的内容,它是get了一个矩阵然后调用了mapPoints方法,这个mapPoints方法就是:当矩阵发生变化后(旋转,缩放等),将最初位置上面的坐标,转换成变化后的坐标,比如说:
数组[0, 0](分别对应x和y)在矩阵向右边平移了50(matrix.postTranslate(50, 0))之后,调用mapPoints方法并将这个数组作为参数传进去,那这个数组就变成[50, 0],如果这个矩阵绕[100, 100]上的点顺时针旋转了90度(matrix.postRotate(90, 100, 100))的话,那这个数组就会变成[200, 0]了,只看文字可能有点难理解,没关系,我们做个图出来就很清晰明了了:

例如这个顺时针旋转90度的:
我们可以把矩形的宽高当作100x100,那个红点的坐标就是[0, 0]了,当这个矩形旋转的时候,可以看到它是以[100, 100]的点作旋转中心的,在旋转完之后,那个红点的Y轴并没有变化,而X轴则向右移动了两个矩形的宽,emmm,这下大家都明白上面说的为什么会由[0, 0]变成[200, 0]了吧。
现在就不难理解,为什么ViewGroup能找到“元神出窍”的View了,我们回到上面的isTransformedTouchPointInView方法:
可以看到,当它调用transformPointToViewLocal方法时,把触摸点的坐标传进去了,那么,等这个transformPointToViewLocal方法执行完毕之后呢,这个触摸点坐标就是转换后的坐标了,随后它还调用了View的pointInView方法,并把转换后的坐标分别传了进去,这个方法我们看名字就大概能猜到是检测传进去的xy坐标点是否在View内(哈哈,我们平时在开发中也应该尽量把方法和变量命名得通俗易懂些,一看就知道个大概那种,这样在团队协作中,就算注释写的比较少,同事也不会太难看懂),我们来看看这个pointInView方法:
final boolean pointInView(float localX, float localY) {
return pointInView(localX, localY, 0);
}
public boolean pointInView(float localX, float localY, float slop) {
return localX >= -slop && localY >= -slop && localX < ((mRight - mLeft) + slop) &&
localY < ((mBottom - mTop) + slop);
}
嗯,很显然就是判断传进去的坐标是否在此View中。
好了,现在我们来总结一下:
ViewGroup在分派事件的时候,会从最后添加到ViewGroup的View(最上面的)开始递减遍历;
通过调用isTransformedTouchPointInView方法来处理判断触摸的坐标是否在子View内;
这个isTransformedTouchPointInView方法会调用transformPointToViewLocal来把相对于ViewGroup的触摸坐标转换成相对于该子View的坐标,并且如果该子View所对应的矩阵有应用过变换(平移,旋转,缩放等)的话,还会继续将坐标转换成矩阵变换后的坐标。触摸坐标转换后,会调用View的pointInView方法来判断此触摸点是否在View内;
ViewGroup会根据isTransformedTouchPointInView方法的返回值来决定要不要把事件交给这个子View;
好,我们来模拟一下ViewGroup是怎么找到这个 “元神出窍” 的View的,加深下理解:
关键代码:
@Override
public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
float[] points = new float[2];
mView.setRotation(progress);
mView.setTranslationX(-progress);
mView.setTranslationY(-progress);
Matrix matrix = getViewMatrix(mView);
if (matrix != null) {
matrix.mapPoints(points);
}
mToast.setText(String.format("绿点在View中吗? %s",
pointInView(mView, points) ? "是的" : "不不不不"));
mToast.show();
}
private Matrix getViewMatrix(View view) {
try {
Method getInverseMatrix = View.class.getDeclaredMethod("getInverseMatrix");
getInverseMatrix.setAccessible(true);
return (Matrix) getInverseMatrix.invoke(view);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
private boolean pointInView(View view, float[] points) {
try {
Method pointInView = View.class.getDeclaredMethod("pointInView", float.class, float.class);
pointInView.setAccessible(true);
return (boolean) pointInView.invoke(view, points[0], points[1]);
} catch (Exception e) {
e.printStackTrace();
}
return false;
}
因为View的getInverseMatrix和pointInView方法,我们都不能直接调用到的,所以要用反射,来看看效果:

哈哈,现在大家都明白ViewGroup为什么还能找到 “元神出窍” 后的View了吧。
好了,现在来回顾一下transformPointToViewLocal方法,我们刚刚忽略了里面调用的hasIdentityMatrix方法,到现在这个方法也大概能猜到个大概了:就是鉴定这个View所对应的矩阵有没有应用过比如setTranslation,setRotation,setScale这些方法,如果有就返回false, 没有就true。
再回到最初的问题:既然属性动画可以,那为什么补间动画就不行呢?大家都是动画啊!
有同学可能已经知道为什么了,因为播放补间动画并没有影响到上面说的hasIdentityMatrix方法的返回值,那它是怎么改变View的位置或大小的呢?我们还是来看看源码吧:
通过看ScaleAnimation,TranslateAnimation和RotateAnimation能看出来,他们都重写了Animation类的applyTransformation和initialize方法,这个initialize方法看名字就大概知道是初始化一些东西,所以我们重点还是看他们重写之后的applyTransformation方法:
首先是ScaleAnimation:
@Override
protected void applyTransformation(float interpolatedTime, Transformation t) {
...
if (mPivotX == 0 && mPivotY == 0) {
t.getMatrix().setScale(sx, sy);
} else {
t.getMatrix().setScale(sx, sy, scale * mPivotX, scale * mPivotY);
}
}
TranslateAnimation:
@Override
protected void applyTransformation(float interpolatedTime, Transformation t) {
...
t.getMatrix().setTranslate(dx, dy);
}
RotateAnimation:
@Override
protected void applyTransformation(float interpolatedTime, Transformation t) {
...
if (mPivotX == 0.0f && mPivotY == 0.0f) {
t.getMatrix().setRotate(degrees);
} else {
t.getMatrix().setRotate(degrees, mPivotX * scale, mPivotY * scale);
}
}
emmm,通过对比他们各自实现的方法,发现最后都是调用Transformation的getMatrix方法来获取到矩阵对象然后对这个矩阵进行操作的,那我们就要看看这个Transformation是在哪里传进来的了:
回到Animation中,会发现applyTransformation方法是在getTransformation(long currentTime, Transformation outTransformation)方法中调用的,它直接把参数中的outTransformation作为applyTransformation方法的t参数传进去了,那现在就要看看在哪里调用了会发现applyTransformation方法是在getTransformation方法了:
在View中,我们通过搜索方法名可以找到调用它的是applyLegacyAnimation方法,我们这次主要是看它传进取的Transformation对象是哪里来的,最终要到哪里去:
private boolean applyLegacyAnimation(ViewGroup parent, long drawingTime,
Animation a, boolean scalingRequired) {
...
final Transformation t = parent.getChildTransformation();
boolean more = a.getTransformation(drawingTime, t, 1f);
if (scalingRequired && mAttachInfo.mApplicationScale != 1f) {
invalidationTransform = parent.mInvalidationTransformation;
a.getTransformation(drawingTime, invalidationTransform, 1f);
}
...
}
我们继续搜 “parent.getChildTransformation()”,最终发现在draw方法有再次调用,来看看精简后的draw方法:
boolean draw(Canvas canvas, ViewGroup parent, long drawingTime) {
Transformation transformToApply = null;
final Animation a = getAnimation();
if (a != null) {
more = applyLegacyAnimation(parent, drawingTime, a, scalingRequired);
transformToApply = parent.getChildTransformation();
}
if (transformToApply != null) {
if (drawingWithRenderNode) {
renderNode.setAnimationMatrix(transformToApply.getMatrix());
} else {
canvas.translate(-transX, -transY);
canvas.concat(transformToApply.getMatrix());
canvas.translate(transX, transY);
}
}
}
emmm,可以看到,当getAnimation不为空的时候,它就会先调用applyLegacyAnimation方法,而这个方法最终会调用到Animation的applyTransformation方法,Animation的子类会在这个方法中根据传进来的Transformation对象get到矩阵,然后那些平移呀,旋转,缩放等操作都只是对这个矩阵进行操作。
那么等这个applyLegacyAnimation方法执行完毕之后呢,就是时候刷新帧了,在draw方法中他会根据一个drawingWithRenderNode,来决定是调用RenderNode的setAnimationMatrix还是Canvas的concat方法,还记不记得我们上面分析的属性动画?它更新帧也是调用RenderNode提供的一系列方法,那我们再看看这个setAnimationMatrix方法的源码:
/**
* Set the Animation matrix on the display list. This matrix exists if an Animation is
* currently playing on a View, and is set on the display list during at draw() time. When
* the Animation finishes, the matrix should be cleared by sending <code>null</code>
* for the matrix parameter.
*
* @param matrix The matrix, null indicates that the matrix should be cleared.
*/
public boolean setAnimationMatrix(Matrix matrix) {
return nSetAnimationMatrix(mNativeRenderNode,
(matrix != null) ? matrix.native_instance : 0);
}
看它的文档注释可以大概知道:当动画正在播放的时候就会显示这个矩阵,当播放完毕时,就应该把它清除掉。
emmm,那就说明,播放补间动画的时候,我们所看到的变化,都只是临时的。而属性动画呢,它所改变的东西,却会更新到这个View所对应的矩阵中,所以当ViewGroup分派事件的时候,会正确的将当前触摸坐标,转换成矩阵变化后的坐标,这就是为什么播放补间动画不会改变触摸区域的原因了。
哈哈,现在我们就知其然,知其所以然了,是不是很开心?
推荐阅读:
轻松搞懂自定义蒙层引导原理
ViewPager 要被废弃?
再“丧心病狂”的混淆也不怕

扫一扫 关注我的公众号
如果你想要跟大家分享你的文章,欢迎投稿~
┏(^0^)┛明天见!

