先上实现效果图
一、TV开发中自定义RecyclerView解决若干问题
1、快速滑动焦点乱跑问题
在Android TV端使用原生RecyclerView在快速滑动的过程会发现焦点不见了很莫名奇怪，通过阅读相关源码发现，我们只需要自定义的查找焦点的逻辑即可
可以看看这篇大佬写的焦点分析Android TV开发总结【焦点】
我在查阅其他大神的解决方案中总结了两种，供大家参考
1、重写RecyclerView的focusSearch方法
@Override
public View focusSearch(View focused, int direction) {
View realNextFocus = super.focusSearch(focused, direction);
View nextFocus = FocusFinder.getInstance().findNextFocus(this, focused, direction);
switch (direction) {
case FOCUS_RIGHT:
case FOCUS_LEFT:
// 调用移出的监听
if (nextFocus == null && !canScrollHorizontally(-1)) {
if (mCanFocusOutHorizontal) {
if (mFocusLostListener != null) {
mFocusLostListener.onFocusLost(focused, direction);
}
return realNextFocus;
} else {
return focused;
}
}
break;
case FOCUS_UP:
case FOCUS_DOWN:
if (nextFocus == null && !canScrollVertically(1)) {
if (mCanFocusOutVertical) {
return realNextFocus;
} else {
return focused;
}
}
break;
}
return realNextFocus;
}
2、重写dispatchKeyEvent方法
@Override
public boolean dispatchKeyEvent(KeyEvent event) {
boolean result = super.dispatchKeyEvent(event);
View focusView = this.getFocusedChild();
if (focusView == null) {
return result;
}
int dy = 0;
int dx = 0;
if (getChildCount() > 0) {
View firstView = this.getChildAt(0);
dy = firstView.getHeight();
dx = firstView.getWidth();
}
if (event.getAction() == KeyEvent.ACTION_UP) {
if (event.getKeyCode() == KeyEvent.KEYCODE_BACK) {
return super.dispatchKeyEvent(event);
}
return true;
} else {
switch (event.getKeyCode()) {
case KeyEvent.KEYCODE_DPAD_RIGHT:
View rightView = FocusFinder.getInstance().findNextFocus(this, focusView, View.FOCUS_RIGHT);
Log.i(TAG, "rightView is null:" + (rightView == null));
if (rightView != null) {
rightView.requestFocus();
return true;
} else {
this.smoothScrollBy(dx, 0);
return true;
}
case KeyEvent.KEYCODE_DPAD_LEFT:
View leftView = FocusFinder.getInstance().findNextFocus(this, focusView, View.FOCUS_LEFT);
Log.i(TAG, "leftView is null:" + (leftView == null));
if (leftView != null) {
leftView.requestFocus();
return true;
} else {
this.smoothScrollBy(-dx, 0);
return true;
}
case KeyEvent.KEYCODE_DPAD_DOWN:
View downView = FocusFinder.getInstance().findNextFocus(this, focusView, View.FOCUS_DOWN);
Log.i(TAG, " downView is null:" + (downView == null));
if (downView != null) {
downView.requestFocus();
return true;
} else {
this.smoothScrollBy(0, dy);
return true;
}
case KeyEvent.KEYCODE_DPAD_UP:
View upView = FocusFinder.getInstance().findNextFocus(this, focusView, View.FOCUS_UP);
Log.i(TAG, "upView is null:" + (upView == null));
if (upView != null) {
upView.requestFocus();
return true;
} else {
this.smoothScrollBy(0, -dy);
return true;
}
}
}
return result;
}
2、实现焦点记忆功能
如果想实现焦点记忆功能的话可以重写如下RecyclerView函数
private View mLastFocusView = null;
// 最后一次聚焦的位置
private int mLastFocusPosition = 0;
@Override
public void requestChildFocus(View child, View focused) {
Log.i(TAG, "requestChildFocus nextchild= " + child + ",focused = " + focused);
Log.i(TAG, "requestChildFocus focusPos = " + mLastFocusPosition);
super.requestChildFocus(child, focused);
mLastFocusView = focused;
//执行过super.requestChildFocus之后hasFocus会变成true
mLastFocusPosition = getChildViewHolder(child).getBindingAdapterPosition();
Log.i(TAG, "requestChildFocus focusPos = " + mLastFocusPosition);
}
@Override
public void addFocusables(ArrayList<View> views, int direction, int focusableMode) {
Log.i(TAG, "addFocusables--focusPos = " + mLastFocusPosition);
if (this.hasFocus() || mLastFocusView == null) {
//在recyclerview内部焦点切换
super.addFocusables(views, direction, focusableMode);
} else {
//将当前的view放到Focusable views列表中，再次移入焦点时会取到该view,实现焦点记忆功能
views.add(getLayoutManager().findViewByPosition(mLastFocusPosition));
}
}
3、实现Item焦点放大不被遮挡
如果想实现Item放大不被遮挡的话，需要重写getChildDrawingOrder函数
@Override
protected int getChildDrawingOrder(int childCount, int position) {
View focusedView = getFocusedChild();
if (null != focusedView) {
int pos = indexOfChild(focusedView);
/* 这是最后一个需要刷新的item */
if (position == childCount - 1) {
if (pos > position) {
pos = position;
}
return pos;
}
else if (pos == position) {
/* 这是原本要在最后一个刷新的item */
return childCount - 1;
}
}
return position;
}
4、实现Item居中滑动效果
如果想实现居中滑动效果，有两种方式 1、重写RecyclerView的requestChildFocus和requestChildRectangleOnScreen方法
//焦点是否居中
private boolean mSelectedItemCentered = true;
private int mSelectedItemOffsetStart = 0;
private int mSelectedItemOffsetEnd = 0;
@Override
public void requestChildFocus(View child, View focused) {
Log.i(TAG, "nextchild= " + child + ",focused = " + focused);
//计算控制recyclerview 选中item的居中从参数
if (mSelectedItemCentered && child != null) {
mSelectedItemOffsetStart = !isVertical() ? (getFreeWidth() - child.getWidth()) : (getFreeHeight() - child.getHeight());
mSelectedItemOffsetStart /= 2;
mSelectedItemOffsetEnd = mSelectedItemOffsetStart;
}
Log.i(TAG, "requestChildFocus focusPos = " + mCurrentFocusPosition);
super.requestChildFocus(child, focused);
//执行过super.requestChildFocus之后hasFocus会变成true
mCurrentFocusPosition = getChildViewHolder(child).getBindingAdapterPosition();
Log.i(TAG, "requestChildFocus focusPos = " + mCurrentFocusPosition);
}
/**
* 通过该方法设置选中的item居中
* <p>
* 该方法能够确定在布局中滚动或者滑动时候，子item和parent之间的位置
* dy，dx的实际意义就是在滚动中下滑和左右滑动的距离
* 而这个值的确定会严重影响滑动的流畅程度
*/
@Override
public boolean requestChildRectangleOnScreen(View child, Rect rect, boolean immediate) {
Log.i(TAG, "requestChildRectangleOnScreen= " + child + ",pos = " + immediate);
final int parentLeft = getPaddingLeft();
final int parentRight = getWidth() - getPaddingRight();
final int parentTop = getPaddingTop();
final int parentBottom = getHeight() - getPaddingBottom();
final int childLeft = child.getLeft() + rect.left;
final int childTop = child.getTop() + rect.top;
final int childRight = childLeft + rect.width();
final int childBottom = childTop + rect.height();
final int offScreenLeft = Math.min(0, childLeft - parentLeft - mSelectedItemOffsetStart);
final int offScreenRight = Math.max(0, childRight - parentRight + mSelectedItemOffsetEnd);
final int offScreenTop = Math.min(0, childTop - parentTop - mSelectedItemOffsetStart);
final int offScreenBottom = Math.max(0, childBottom - parentBottom + mSelectedItemOffsetEnd);
final boolean canScrollHorizontal = getLayoutManager().canScrollHorizontally();
final boolean canScrollVertical = getLayoutManager().canScrollVertically();
// Favor the "start" layout direction over the end when bringing one side or the other
// of a large rect into view. If we decide to bring in end because start is already
// visible, limit the scroll such that start won't go out of bounds.
final int dx;
if (canScrollHorizontal) {
if (ViewCompat.getLayoutDirection(this) == ViewCompat.LAYOUT_DIRECTION_RTL) {
dx = offScreenRight != 0 ? offScreenRight
: Math.max(offScreenLeft, childRight - parentRight);
} else {
dx = offScreenLeft != 0 ? offScreenLeft
: Math.min(childLeft - parentLeft, offScreenRight);
}
} else {
dx = 0;
}
// Favor bringing the top into view over the bottom. If top is already visible and
// we should scroll to make bottom visible, make sure top does not go out of bounds.
final int dy;
if (canScrollVertical) {
dy = offScreenTop != 0 ? offScreenTop : Math.min(childTop - parentTop, offScreenBottom);
} else {
dy = 0;
}
if (dx != 0 || dy != 0) {
scrollBy(dx, dy);
if (immediate) {
scrollBy(dx, dy);
} else {
smoothScrollBy(dx, dy);
}
// 重绘是为了选中item置顶，具体请参考getChildDrawingOrder方法
postInvalidate();
return true;
}
return false;
}
2、自定义LayoutManager，来实现居中滑动
public class CenterLayoutManager extends LinearLayoutManager {
public CenterLayoutManager(Context context) {
super(context);
}
@Override
public void smoothScrollToPosition(final RecyclerView recyclerView, RecyclerView.State state,final int position) {
CenterSmoothScroller smoothScroller = new CenterSmoothScroller(recyclerView.getContext(),recyclerView) {
@Override
public PointF computeScrollVectorForPosition(int targetPosition) {
return computeVectorForPosition(targetPosition);
}
};
smoothScroller.setTargetPosition(position);
startSmoothScroll(smoothScroller);
}
public PointF computeVectorForPosition(int targetPosition) {
return super.computeScrollVectorForPosition(targetPosition);
}
abstract class CenterSmoothScroller extends LinearSmoothScroller {
RecyclerView recyclerView;
CenterSmoothScroller(Context context,RecyclerView recyclerView) {
super(context);
this.recyclerView = recyclerView;
}
@Override
public int calculateDtToFit(int viewStart, int viewEnd, int boxStart, int boxEnd, int snapPreference) {
Log.i("du","calculateDtToFit viewStart:" + viewStart + "---viewEnd:" + viewEnd + "---boxStart:" + boxStart + "---boxEnd:" + boxEnd + "----snapPreference:" + snapPreference );
return (boxStart + (boxEnd - boxStart) / 2) - (viewStart + (viewEnd - viewStart) / 2);
}
/**
* 滑动完成后,让该targetPosition 处的item获取焦点
*/
@Override
protected void onStop() {
Log.i("du","onStop-Position" + getTargetPosition());
super.onStop();
final View itemView = findViewByPosition(getTargetPosition());
if (null != itemView) {
itemView.requestFocus();
}
}
}
}
//recyclerview中调用
@Override
public void onBindViewHolder(final @NonNull BaseViewHolder viewHolder, final int i) {
viewHolder.itemView.setOnFocusChangeListener(new View.OnFocusChangeListener() {
@Override
public void onFocusChange(View v, boolean hasFocus) {
Log.i("du","onBindViewHolder-Position"+ i + "---hasFocus:" + hasFocus);
if (hasFocus) {
ViewCompat.animate(viewHolder.itemView).scaleX(1.5f).scaleY(1.5f).start();
mCenterLayoutManager.smoothScrollToPosition(mRecyclerView,new RecyclerView.State(), i);
} else {
ViewCompat.animate(viewHolder.itemView).scaleX(1f).scaleY(1f).start();
}
}
});
二、实现垂直列表的无线循环滑动
在这里参照了网上的方法 在RecyclerView.Adapter的方法中:
@Override
public int getItemCount() {
return Integer.MAX_VALUE;
}
由于我们需要时需要无线居中滑动而且默认定位，所以我们需要调整下逻辑重写setAdapter
@Override
public void setAdapter(@Nullable Adapter adapter) {
super.setAdapter(adapter);
//定位到对应位置
scrollToPosition(((Integer.MAX_VALUE / 2) - ((Integer.MAX_VALUE / 2) % realCount)) + mCurPos);
postDelayed(new Runnable() {
@Override
public void run() {
View targetView = getLayoutManager().findViewByPosition(((Integer.MAX_VALUE/2)-((Integer.MAX_VALUE/2)%realCount)) + mCurPos);
if (targetView != null) {
targetView.requestFocus();
}
}
},100);
}
三、实现垂直列表的渐隐效果
自定义RecyclerView并重写对应方法即可
private Paint paint;
private int height;
private int width;
private int spanPixel = 100;
@Override
protected void onSizeChanged(int w, int h, int oldw, int oldh) {
super.onSizeChanged(w, h, oldw, oldh);
height = h;
width = w;
float spanFactor = spanPixel / (height / 2f);
// 设置渐隐效果，起始0为0x00000000,中间spanFactor为0xff000000,末尾为0xff000000
LinearGradient linearGradient = new LinearGradient(0, 0, 0, height / 2,
new int[]{0x00000000, 0xff000000, 0xff000000}, new float[]{0, spanFactor, 1f}, Shader.TileMode.MIRROR);
paint.setShader(linearGradient);
}
@Override
public void draw(Canvas c) {
c.saveLayer(0, 0, width, height, null, Canvas.ALL_SAVE_FLAG);
super.draw(c);
c.drawRect(0, 0, width, height, paint);
c.restore();
}
四、限制RecyclerView滑动速度
可以使用通过调整dispatchKeyEvent 的输入间隔时间
private long mLastKeyDownTime;
@Override
public boolean dispatchKeyEvent(KeyEvent event) {
long current = System.currentTimeMillis();
if (event.getAction() != KeyEvent.ACTION_DOWN || getChildCount() == 0) {
return super.dispatchKeyEvent(event);
}
// 限制两个KEY_DOWN事件的最低间隔为120ms
if (isComputingLayout() || current - mLastKeyDownTime <= 120) {
return true;
}
mLastKeyDownTime = current;
return super.dispatchKeyEvent(event);
}
