获取Behavior
CoordinatorLayout中子view关联的动作主要由Behavior实现。
系统控件中往往把behavior作为内部类,自己实现,比如AppbarLayout。
当然我们也可以自己实现自定义的Behavior来完成我们需要的动作。
自定义Behavior时,我们需要在xml代码中实现相应属性,例如:
app:layout_behavior="com.wuba.views.CustomAppbarBehavior"
这个就是我们首页动画实现的自定义的behavior。
在xml中实现之后,必然会在代码中获取这个behavior:
public static class LayoutParams extends MarginLayoutParams {
CoordinatorLayout.Behavior mBehavior;
LayoutParams(Context context, AttributeSet attrs) {
super(context, attrs);
TypedArray a = context.obtainStyledAttributes(attrs, styleable.CoordinatorLayout_LayoutParams);
this.mBehaviorResolved = a.hasValue(styleable.CoordinatorLayout_LayoutParams_layout_behavior);
if(this.mBehaviorResolved) {
this.mBehavior = CoordinatorLayout.parseBehavior(context, attrs, a.getString(styleable.CoordinatorLayout_LayoutParams_layout_behavior));//这个方法获取到behavior的实例
}
a.recycle();
}
可以看到,获取behavior的方式和很多自定义view的方式是一样的,通过自定义属性来获取。我们具体看一下parseBehavior()方法是怎么实现的:
static CoordinatorLayout.Behavior parseBehavior(Context context, AttributeSet attrs, String name) {
if(TextUtils.isEmpty(name)) {
return null;
} else {
String fullName;
if(name.startsWith(".")) {//如果以.开始,就拼接上包名
fullName = context.getPackageName() + name;
} else if(name.indexOf(46) >= 0) {//这里我猜46是类名的最大长度,大于46由没有以.开始,说明它本身就是完整包名
fullName = name;
} else {
fullName = WIDGET_PACKAGE_NAME + '.' + name;//否则就是包名.类名
}
try {
Object e = (Map)sConstructors.get();
if(e == null) {
e = new HashMap();
sConstructors.set(e);
}
Constructor c = (Constructor)((Map)e).get(fullName);
if(c == null) {
Class clazz = Class.forName(fullName, true, context.getClassLoader());//用反射获取类
c = clazz.getConstructor(CONSTRUCTOR_PARAMS);//通过构造方法获取实例
((Map)e).put(fullName, c);
}
return (CoordinatorLayout.Behavior)c.newInstance(new Object[]{context, attrs});
} catch (Exception var7) {
throw new RuntimeException("Could not inflate Behavior subclass " + fullName, var7);
}
}
可以看到这个方法,通过拼接路径,然后用反射的方式获取到了behavior的实例。这样View就成功获取到了behavior。
通用动作的实现
Behavior中有很多可以实现的接口。在我看来关于动作的方法大概可以分成两类。先说第一类;
public boolean layoutDependsOn(CoordinatorLayout parent, V child, View dependency)
public boolean onDependentViewChanged(CoordinatorLayout parent, V child, View dependency)
这两个方法主要实现通用的的关联动作,各种view的改变都可以使用。
下面看一下他们的作用以及调用关系。
前两个方法和主要是在dispatchOnDependentViewChanged方法中调用,我们先看看在哪里调用了这个方法。
class OnPreDrawListener implements android.view.ViewTreeObserver.OnPreDrawListener {
OnPreDrawListener() {
}
public boolean onPreDraw() {
CoordinatorLayout.this.dispatchOnDependentViewChanged(false);
return true;
}
}
主要是在这个listener中,再看一下哪里注册了这个监听:
public void onAttachedToWindow() {
super.onAttachedToWindow();
this.resetTouchBehaviors();
if(this.mNeedsPreDrawListener) {
if(this.mOnPreDrawListener == null) {
this.mOnPreDrawListener = new CoordinatorLayout.OnPreDrawListener();
}
ViewTreeObserver vto = this.getViewTreeObserver();
vto.addOnPreDrawListener(this.mOnPreDrawListener);
}
this.mIsAttachedToWindow = true;
}
主要是在onAttachedToWindow里。也就是说在coordinatorlayout绑定到窗口是,就会直接注册这个监听,每次要绘制view之前都会i调用dispatchOnDependentViewChanged方法。现在再来看一下刚才提到的dispatchOnDependentViewChanged的具体实现:
void dispatchOnDependentViewChanged(boolean fromNestedScroll) {
int layoutDirection = ViewCompat.getLayoutDirection(this);
int childCount = this.mDependencySortedChildren.size();
for(int i = 0; i < childCount; ++i) {
View child = (View)this.mDependencySortedChildren.get(i);
CoordinatorLayout.LayoutParams lp = (CoordinatorLayout.LayoutParams)child.getLayoutParams();
for(int oldRect = 0; oldRect < i; ++oldRect) {
View newRect = (View)this.mDependencySortedChildren.get(oldRect);
if(lp.mAnchorDirectChild == newRect) {
this.offsetChildToAnchor(child, layoutDirection);
}
}
Rect var14 = this.mTempRect1;
Rect var15 = this.mTempRect2;
this.getLastChildRect(child, var14);
this.getChildRect(child, true, var15);
if(!var14.equals(var15)) {
this.recordLastChildRect(child, var15);
for(int j = i + 1; j < childCount; ++j) {
View checkChild = (View)this.mDependencySortedChildren.get(j);
CoordinatorLayout.LayoutParams checkLp = (CoordinatorLayout.LayoutParams)checkChild.getLayoutParams();
CoordinatorLayout.Behavior b = checkLp.getBehavior();
if(b != null && b.layoutDependsOn(this, checkChild, child)) {
if(!fromNestedScroll && checkLp.getChangedAfterNestedScroll()) {
checkLp.resetChangedAfterNestedScroll();
} else {
boolean handled = b.onDependentViewChanged(this, checkChild, child);
if(fromNestedScroll) {
checkLp.setChangedAfterNestedScroll(handled);
}
}
}
}
}
}
}
只看我们关心的部分,也就是最下边的for循环,可以看出coordinatorlayout会循环获取每个子view的behavior。然后在if中看到了b.layoutDependsOn,if里面有b.onDependentViewChanged。
也就是说,当view改变时,如果通过符合我们自己实现的某些条件(这个条件在layoutDependsOn中定义),就会调用onDependentViewChanged方法,实现我们需要的动作。
滚动动作的实现
下面就是第二类,专门针对滚动动作的接口
public boolean onStartNestedScroll(CoordinatorLayout coordinatorLayout, V child, View directTargetChild, View target, int nestedScrollAxes)
public void onNestedScrollAccepted(CoordinatorLayout coordinatorLayout, V child, View directTargetChild, View target, int nestedScrollAxes)
public void onStopNestedScroll(CoordinatorLayout coordinatorLayout, V child, View target)
public void onNestedScroll(CoordinatorLayout coordinatorLayout, V child, View target, int dxConsumed, int dyConsumed, int dxUnconsumed, int dyUnconsumed)
public void onNestedPreScroll(CoordinatorLayout coordinatorLayout, V child, View target, int dx, int dy, int[] consumed)
public boolean onNestedFling(CoordinatorLayout coordinatorLayout, V child, View target, float velocityX, float velocityY, boolean consumed)
public boolean onNestedPreFling(CoordinatorLayout coordinatorLayout, V child, View target, float velocityX, float velocityY)
可以看到有很多方法,针对各种不同的滚动以及不同的阶段。
这个单在coordinatorlayout中很难看清楚如何调用,因为它涉及到了,接口,以及其他的view。就从事件的源头看,也就是NestedScrollView。
首先看NestedScrollView,它实现了NestedScrollingChild接口,这个接口有很多方法,我们就找startNestedScroll这个方法,这个从名称来看,应该跟上边的onStartNestedScroll方法对应。
@Override
public boolean startNestedScroll(int axes) {
return mChildHelper.startNestedScroll(axes);
}
先看看哪里调用了这个方法,果然是touch事件触发的:
@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {
final int action = ev.getAction();
switch (action & MotionEventCompat.ACTION_MASK) {
case MotionEvent.ACTION_DOWN: {
startNestedScroll(ViewCompat.SCROLL_AXIS_VERTICAL);
break;
}
}
return mIsBeingDragged;
}
再跟进这个方法,可以看到是在NestedScrollingChildHelper中实现的
public boolean startNestedScroll(int axes) {
if (hasNestedScrollingParent()) {
// Already in progress
return true;
}
if (isNestedScrollingEnabled()) {
ViewParent p = mView.getParent();
View child = mView;
while (p != null) {
if (ViewParentCompat.onStartNestedScroll(p, child, mView, axes)) {
mNestedScrollingParent = p;
ViewParentCompat.onNestedScrollAccepted(p, child, mView, axes);
return true;
}
if (p instanceof View) {
child = (View) p;
}
p = p.getParent();
}
}
return false;
}
这个方法主要是循环网上找parent,直到符合条件,条件就是ViewParentCompat.onStartNestedScroll(p, child, mView, axes),具体看一下这个方法:
public static boolean onStartNestedScroll(ViewParent parent, View child, View target,
int nestedScrollAxes) {
return IMPL.onStartNestedScroll(parent, child, target, nestedScrollAxes);
}
再往下点:
static final ViewParentCompatImpl IMPL;
static {
final int version = Build.VERSION.SDK_INT;
if (version >= 21) {
IMPL = new ViewParentCompatLollipopImpl();
} else if (version >= 19) {
IMPL = new ViewParentCompatKitKatImpl();
} else if (version >= 14) {
IMPL = new ViewParentCompatICSImpl();
} else {
IMPL = new ViewParentCompatStubImpl();
}
}
这里是一个版本判断。我们app支持的最小版本是16,所以肯定看第三个:
@Override
public boolean onStartNestedScroll(ViewParent parent, View child, View target,int nestedScrollAxes) {
if (parent instanceof NestedScrollingParent) {
return ((NestedScrollingParent) parent).onStartNestedScroll(child, target,nestedScrollAxes);
}
return false;
}
所这里可以看到,如果想要实现滚动的关联,要求父view必须实现NestedScrollingParent接口,然后调用这个接口的onStartNestedScroll方法。
好了,现在再返回头来看:
public class CoordinatorLayout extends ViewGroup implements NestedScrollingParent
CoordinatorLayout 刚好实现了这个接口,所以如果它的子view如果实现了NestedScrollingChild接口就可以实现滚动动作的联动了
再来看下这个方法的具体实现:
public boolean onStartNestedScroll(View child, View target, int nestedScrollAxes) {
boolean handled = false;
int childCount = this.getChildCount();
for(int i = 0; i < childCount; ++i) {
View view = this.getChildAt(i);
CoordinatorLayout.LayoutParams lp = (CoordinatorLayout.LayoutParams)view.getLayoutParams();
CoordinatorLayout.Behavior viewBehavior = lp.getBehavior();
if(viewBehavior != null) {
boolean accepted = viewBehavior.onStartNestedScroll(this, view, child, target, nestedScrollAxes);
handled |= accepted;
lp.acceptNestedScroll(accepted);
} else {
lp.acceptNestedScroll(false);
}
}
return handled;
}
可以看到,最终还是通过调用其behavior中的onStartNestedScroll实现了具体的动作。