androidTV开发---RecyclerView焦点乱跳问题

已于 2023-02-27 10:31:30 修改
阅读量2.1k 收藏 5
点赞数 3
分类专栏： androidTV 文章标签： android java
于 2020-01-06 18:17:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43841938/article/details/103861548
版权

1、KeyUtils

import android.graphics.Color;
import android.graphics.drawable.GradientDrawable;
import android.util.Log;
import android.view.View;
import android.view.animation.ScaleAnimation;

import androidx.recyclerview.widget.RecyclerView;

import com.pjx.core.event.callback.CallbackManager;
import com.pjx.core.event.callback.IGlobalCallback;

import rxhttp.wrapper.utils.LogUtil;

public class KeyUtils {

    public static void keyListenerBackground(final View mView){
        mView.setOnFocusChangeListener(new View.OnFocusChangeListener() {
            @Override
            public void onFocusChange(View view, boolean b) {
                if (b) {
                    mView.setSelected(true);
                    ScaleAnimation animationTwoCopy = new ScaleAnimation(1f, 1.1f, 1f, 1.1f, mView.getWidth() / 2, mView.getHeight() / 2);
                    animationTwoCopy.setDuration(300);
                    animationTwoCopy.setFillAfter(true);
                    mView.startAnimation(animationTwoCopy);
                }else {
                    mView.setSelected(false);
                    ScaleAnimation animationTwo = new ScaleAnimation(1.1f, 1f, 1.1f, 1f, mView.getWidth() / 2, mView.getHeight() / 2);
                    animationTwo.setDuration(300);
                    animationTwo.setFillAfter(true);
                    mView.startAnimation(animationTwo);
                }
            }
        });
    }
    public static void keyListenerBackground(final View mView, final View v2){
        mView.setOnFocusChangeListener(new View.OnFocusChangeListener() {
            @Override
            public void onFocusChange(View view, boolean b) {
                if (b) {
                    v2.setSelected(true);
                    ScaleAnimation animationTwoCopy = new ScaleAnimation(1f, 1.1f, 1f, 1.1f, mView.getWidth() / 2, mView.getHeight() / 2);
                    animationTwoCopy.setDuration(300);
                    animationTwoCopy.setFillAfter(true);
                    mView.startAnimation(animationTwoCopy);
                }else {
                    v2.setSelected(false);
                    ScaleAnimation animationTwo = new ScaleAnimation(1.1f, 1f, 1.1f, 1f, mView.getWidth() / 2, mView.getHeight() / 2);
                    animationTwo.setDuration(300);
                    animationTwo.setFillAfter(true);
                    mView.startAnimation(animationTwo);
                }
            }
        });
    }
    public static void keyListenerBackground(final View mView, final int position, final String type){
        mView.setOnFocusChangeListener(new View.OnFocusChangeListener() {
            @Override
            public void onFocusChange(View view, boolean b) {
                if (b) {
                    IGlobalCallback callback= CallbackManager.Companion.getInstance().getCallback(type);
                    if (callback != null) {
                        callback.executeCallback(position);
                    }
                    mView.setSelected(true);
                    ScaleAnimation animationTwoCopy = new ScaleAnimation(1f, 1.1f, 1f, 1.1f, mView.getWidth() / 2, mView.getHeight() / 2);
                    animationTwoCopy.setDuration(300);
                    animationTwoCopy.setFillAfter(true);
                    mView.startAnimation(animationTwoCopy);
                }else {
                    mView.setSelected(false);
                    ScaleAnimation animationTwo = new ScaleAnimation(1.1f, 1f, 1.1f, 1f, mView.getWidth() / 2, mView.getHeight() / 2);
                    animationTwo.setDuration(300);
                    animationTwo.setFillAfter(true);
                    mView.startAnimation(animationTwo);
                }
            }
        });
    }
    /*****************************item获得与失去焦点的监听***************************/
    public static void keyListenerItem(final View mView){
        mView.setOnFocusChangeListener(new View.OnFocusChangeListener() {
            @Override
            public void onFocusChange(View view, boolean b) {
                if (b) {
                    mView.setSelected(true);
                    ScaleAnimation animationTwoCopy = new ScaleAnimation(1f, 1.02f, 1f, 1.02f, mView.getWidth() / 2, mView.getHeight() / 2);
                    animationTwoCopy.setDuration(300);
                    animationTwoCopy.setFillAfter(true);
                    mView.startAnimation(animationTwoCopy);

                    yesBorder(mView);
                }else {
                    mView.setSelected(false);
                    //mView.setBackgroundResource(R.drawable.shape_select_background_false);
                    ScaleAnimation animationTwo = new ScaleAnimation(1.02f, 1f, 1.02f, 1f, mView.getWidth() / 2, mView.getHeight() / 2);
                    animationTwo.setDuration(300);
                    animationTwo.setFillAfter(true);
                    mView.startAnimation(animationTwo);

                    noBorder(mView);
                }
            }
        });
    }
    public static void keyListenerItem(final View mView,RecyclerView rv){
        mView.setOnFocusChangeListener(new View.OnFocusChangeListener() {
            @Override
            public void onFocusChange(View view, boolean b) {
                LogUtil.log("选择"+b);
                LogUtil.log("view="+view);
                if (b) {
                    mView.setSelected(true);
                    ScaleAnimation animationTwoCopy = new ScaleAnimation(1f, 1.02f, 1f, 1.02f, mView.getWidth() / 2, mView.getHeight() / 2);
                    animationTwoCopy.setDuration(300);
                    animationTwoCopy.setFillAfter(true);
                    mView.startAnimation(animationTwoCopy);
                    rv.smoothScrollToPosition(rv.getChildLayoutPosition(view));

                    yesBorder(mView);
                }else {
                    mView.setSelected(false);
                    //mView.setBackgroundResource(R.drawable.shape_select_background_false);
                    ScaleAnimation animationTwo = new ScaleAnimation(1.02f, 1f, 1.02f, 1f, mView.getWidth() / 2, mView.getHeight() / 2);
                    animationTwo.setDuration(300);
                    animationTwo.setFillAfter(true);
                    mView.startAnimation(animationTwo);

                    noBorder(mView);
                }
            }
        });
    }
    public static void keyListenerItem(final View mView, final int position, final String type){
        mView.setOnFocusChangeListener(new View.OnFocusChangeListener() {
            @Override
            public void onFocusChange(View view, boolean b) {
                if (b) {
                    IGlobalCallback callback=CallbackManager.Companion.getInstance().getCallback(type);
                    if (callback != null) {
                        callback.executeCallback(position);
                    }
                    ScaleAnimation animationTwoCopy = new ScaleAnimation(1f, 1.06f, 1f, 1.06f, mView.getWidth() / 2, mView.getHeight() / 2);
                    animationTwoCopy.setDuration(300);
                    animationTwoCopy.setFillAfter(true);
                    mView.startAnimation(animationTwoCopy);

                    yesBorder(mView);
                }else {
                    ScaleAnimation animationTwo = new ScaleAnimation(1.06f, 1f, 1.06f, 1f, mView.getWidth() / 2, mView.getHeight() / 2);
                    animationTwo.setDuration(300);
                    animationTwo.setFillAfter(true);
                    mView.startAnimation(animationTwo);

                    noBorder(mView);
                }
            }
        });
    }
    /********************************************************/
    public static void keyListenerText(final View mView){
        mView.setOnFocusChangeListener(new View.OnFocusChangeListener() {
            @Override
            public void onFocusChange(View view, boolean b) {
                if (b) {
                    ScaleAnimation animationTwoCopy = new ScaleAnimation(1f, 1.15f, 1f, 1.15f, mView.getWidth() / 2, mView.getHeight() / 2);
                    animationTwoCopy.setDuration(300);
                    animationTwoCopy.setFillAfter(true);
                    mView.startAnimation(animationTwoCopy);

                    yesBorder(mView);
                }else {
                    ScaleAnimation animationTwo = new ScaleAnimation(1.15f, 1f, 1.15f, 1f, mView.getWidth() / 2, mView.getHeight() / 2);
                    animationTwo.setDuration(300);
                    animationTwo.setFillAfter(true);
                    mView.startAnimation(animationTwo);

                    noBorder(mView);
                }
            }
        });
    }
    private static void yesBorder(View mView){
        //创建Drawable对象
        GradientDrawable drawable=new GradientDrawable();
        drawable.setStroke(3, Color.parseColor("#A4D9DF"));
        drawable.setColor(Color.TRANSPARENT);
        drawable.setCornerRadius(6);
        mView.setBackground(drawable);
    }
    private static void noBorder(View mView){
        GradientDrawable drawable=new GradientDrawable();
        drawable.setCornerRadius(6);
        drawable.setColor(Color.TRANSPARENT);
        mView.setBackground(drawable);
    }
}

2、AnimationUtil

import android.animation.Animator;
import android.animation.Keyframe;
import android.animation.ObjectAnimator;
import android.animation.PropertyValuesHolder;
import android.util.Log;
import android.view.KeyEvent;
import android.view.View;
import android.view.animation.Animation;
import android.view.animation.LinearInterpolator;
import android.view.animation.RotateAnimation;
import android.view.animation.ScaleAnimation;
import android.widget.ImageView;

public class AnimationUtil {

    private AnimationUtil() {
    }

    private static final String TAG = AnimationUtil.class.getSimpleName();

    public static void zoomByFactor(View view, float factor, int duration) {

        ScaleAnimation animation = AnimationBuilder.getInstance()
                .getScaleAnimation(1.0f, factor, 1.0f, factor,
                        Animation.RELATIVE_TO_SELF, 0.5f,
                        Animation.RELATIVE_TO_SELF, 0.5f, duration);

        if (animation != null) {
            view.startAnimation(animation);
        }
    }

    public static void scaleToOriginalDimension(View view, float factor, int duration) {
        ScaleAnimation animation = AnimationBuilder.getInstance()
                .getScaleAnimation(factor, 1.0f, factor, 1.0f,
                        Animation.RELATIVE_TO_SELF, 0.5f,
                        Animation.RELATIVE_TO_SELF, 0.5f, duration);

        if (animation != null) {
            view.startAnimation(animation);
        }
    }

    //键盘移动的位移动画，动画类型为属性动画
    public static void slideView(View view, final float p1, final float p2, int duration, final View showView, final View hideView) {
        ObjectAnimator objectAnimator = ObjectAnimator.ofFloat(view, "translationX", p1, p2);
        objectAnimator.setDuration(duration);
        objectAnimator.addListener(new Animator.AnimatorListener() {
            @Override
            public void onAnimationStart(Animator animator) {
//                try {
//
//                } catch (Exception e) {
//                    Log.e(TAG, "wqs:slideView:onAnimationStart:Exception:" + e.toString());
//                    e.printStackTrace();
//                }
            }

            @Override
            public void onAnimationEnd(Animator animator) {
//                if (showView != null) {
//                    showView.setVisibility(View.VISIBLE);
//                }
//                if (hideView != null) {
//                    hideView.setVisibility(View.INVISIBLE);
//                }
            }

            @Override
            public void onAnimationCancel(Animator animator) {

            }

            @Override
            public void onAnimationRepeat(Animator animator) {

            }
        });
        objectAnimator.start();
    }

    public static void doBoundaryAnimation(View view, int keyCode, int ratio) {
        int leftShakeDegrees = 6 * ratio;
        int rightShakeDegrees = 2 * ratio;
        if (keyCode == KeyEvent.KEYCODE_DPAD_RIGHT) {
            leftShakeDegrees = 2 * ratio;
            rightShakeDegrees = 6 * ratio;
        }
        PropertyValuesHolder rotateValuesHolder = PropertyValuesHolder.ofKeyframe(View.TRANSLATION_X,
                Keyframe.ofFloat(0f, 0f),
                Keyframe.ofFloat(0.2f, -leftShakeDegrees),
                Keyframe.ofFloat(0.4f, rightShakeDegrees),
                Keyframe.ofFloat(0.6f, -leftShakeDegrees),
                Keyframe.ofFloat(0.8f, rightShakeDegrees),
                Keyframe.ofFloat(1.0f, 0f)
        );

        ObjectAnimator objectAnimator = ObjectAnimator.ofPropertyValuesHolder(view, rotateValuesHolder);
        objectAnimator.setDuration(500);
        objectAnimator.start();
    }

    public static void startLoadingAni(ImageView loadingImg) {
        if (loadingImg == null) {
            Log.e(TAG, "wqs:startLoadingAni:loadingImg==null");
            return;
        }
        loadingImg.clearAnimation();
        RotateAnimation rotateAnimation = new RotateAnimation(0f, 360f, Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF, 0.5f);
        rotateAnimation.setFillAfter(true);
        rotateAnimation.setRepeatMode(Animation.RESTART);
        rotateAnimation.setRepeatCount(Animation.INFINITE);
        rotateAnimation.setDuration(1000);
        rotateAnimation.setInterpolator(new LinearInterpolator());
        loadingImg.startAnimation(rotateAnimation);
        showView(loadingImg);
    }

    public static void stopLoadingAni(ImageView loadingImg) {
        if (loadingImg == null) {
            Log.e(TAG, "wqs:stopLoadingAni:loadingImg==null");
            return;
        }
        loadingImg.clearAnimation();
        goneView(loadingImg);
    }

    public static void showView(View view) {
        if (view != null) {
            view.setVisibility(View.VISIBLE);
        }
    }

    public static void hideView(View view) {
        if (view != null) {
            view.setVisibility(View.INVISIBLE);
        }
    }

    public static void goneView(View view) {
        if (view != null) {
            view.setVisibility(View.GONE);
        }
    }

    public static void setFouseView(View view) {
        if (view != null) {
            view.requestFocus();
        }
    }
}

3、AnimationBuilder

import android.view.animation.ScaleAnimation;

public final class AnimationBuilder {

    private static AnimationBuilder mInstance;

    private AnimationBuilder() {
    }

    public static synchronized AnimationBuilder getInstance() {
        if (mInstance == null) {
            mInstance = new AnimationBuilder();
        }
        return mInstance;
    }

    public ScaleAnimation getScaleAnimation(float fromX, float toX,
                                            float fromY, float toY, int pivotXType, float pivotXValue,
                                            int pivotYType, float pivotYValue, int duration) {

        ScaleAnimation sa = new ScaleAnimation(fromX, toX, fromY, toY,
                pivotXType, pivotXValue,
                pivotYType, pivotYValue);
        sa.setDuration(duration);
        sa.setFillAfter(true);
        return sa;
    }
}

4、IRecyclerView

import android.view.View;

import androidx.annotation.Nullable;
import androidx.recyclerview.widget.LinearLayoutManager;


/**
 * @author weihaichao
 * @date 2019-10-10 16:00
 */
public interface IRecyclerView {

    int ALIGN_MODE_START = 2;
    int ALIGN_MODE_CENTER = 1;
    int ALIGN_MODE_FIRST = 3;

    int DIRECTION_HORIZONTAL = LinearLayoutManager.HORIZONTAL;
    int DIRECTION_VERTICAL = LinearLayoutManager.VERTICAL;

    /**
     * 获取默认焦点View
     * @return View
     */
    @Nullable
    View getDefaultFocusView();

    /**
     * 请求默认焦点
     * @return Boolean 是否请求成功
     */
    boolean requestDefaultFocus();

    /**
     * 设置对齐方式
     * @param mode 对齐方式
     * @param direction
     */
    void setLayoutManager(int mode, int direction);
}

5、CenterLayoutManager （居中移动）

import android.content.Context;
import android.util.DisplayMetrics;
import android.view.View;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.LinearSmoothScroller;
import androidx.recyclerview.widget.RecyclerView;


public class CenterLayoutManager extends LinearLayoutManager {

    public CenterLayoutManager(Context context, int orientation, boolean reverseLayout) {
        super(context, orientation, reverseLayout);
    }

    @Override
    public void smoothScrollToPosition(RecyclerView recyclerView, RecyclerView.State state, int position) {
        RecyclerView.SmoothScroller centerSmoothScroller = new CenterSmoothScroller(recyclerView.getContext());
        centerSmoothScroller.setTargetPosition(position);
        startSmoothScroll(centerSmoothScroller);
    }

    @Override
    protected int getExtraLayoutSpace(RecyclerView.State state) {
        return 100;
    }

    @Nullable
    @Override
    public View onInterceptFocusSearch(@NonNull View focused, int direction) {
        int pos = getPosition(focused);
        if (pos != findLastCompletelyVisibleItemPosition()) {
            return null;
        }
        return super.onInterceptFocusSearch(focused, direction);
    }

    private static class CenterSmoothScroller extends LinearSmoothScroller {

        CenterSmoothScroller(Context context) {
            super(context);
        }

        @Override
        public int calculateDxToMakeVisible(View view, int snapPreference) {
            final RecyclerView.LayoutManager layoutManager = getLayoutManager();
            if (layoutManager == null || !layoutManager.canScrollHorizontally()) {
                return 0;
            }
            final RecyclerView.LayoutParams params = (RecyclerView.LayoutParams)
                    view.getLayoutParams();
            final int left = view.getLeft() - params.leftMargin;
            final int right = view.getRight() + params.rightMargin;
            final int start = layoutManager.getPaddingLeft();
            final int end = layoutManager.getWidth() - layoutManager.getPaddingRight();
            return (start + (end - start) / 2) - (left + (right - left) / 2);
        }

        @Override
        protected float calculateSpeedPerPixel(DisplayMetrics displayMetrics) {
            return 60f / displayMetrics.densityDpi;
        }
    }
}

6、BothSidesLayoutManager（两边移动）

import android.content.Context;
import android.util.DisplayMetrics;
import android.util.Log;

import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.LinearSmoothScroller;
import androidx.recyclerview.widget.RecyclerView;


public class BothSidesLayoutManager extends LinearLayoutManager {

    public BothSidesLayoutManager(Context context, int orientation, boolean reverseLayout) {
        super(context, orientation, reverseLayout);
    }

    @Override
    public void smoothScrollToPosition(RecyclerView recyclerView, RecyclerView.State state,
                                       int position) {
        RecyclerView.SmoothScroller smoothScroller =
                new StartSmoothScroller(recyclerView.getContext());
        smoothScroller.setTargetPosition(position);
        startSmoothScroll(smoothScroller);
    }

    private static class StartSmoothScroller extends LinearSmoothScroller {

        StartSmoothScroller(Context context) {
            super(context);
        }

        @Override
        public int calculateDtToFit(int viewStart, int viewEnd, int boxStart, int boxEnd,
                                    int snapPreference) {
            Log.d("LayoutManager","vs="+viewStart+" vd="+viewEnd+" bs="+boxStart+" bd="+boxEnd);
            return boxStart - viewStart;
        }

        @Override
        protected int getHorizontalSnapPreference() {
            return SNAP_TO_START;
        }

        @Override
        protected int getVerticalSnapPreference() {
            return SNAP_TO_START;
        }

        @Override
        protected float calculateSpeedPerPixel(DisplayMetrics displayMetrics) {
            return 80f / displayMetrics.densityDpi;
        }
    }
}

7、FirstLayoutManager（首个移动）

mport android.content.Context;
import android.util.DisplayMetrics;
import android.util.Log;

import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.LinearSmoothScroller;
import androidx.recyclerview.widget.RecyclerView;


public class FirstLayoutManager extends LinearLayoutManager {

    public FirstLayoutManager(Context context, int orientation, boolean reverseLayout) {
        super(context, orientation, reverseLayout);
    }

    @Override
    public void smoothScrollToPosition(RecyclerView recyclerView, RecyclerView.State state,
                                       int position) {
        RecyclerView.SmoothScroller smoothScroller =
                new FirstSmoothScroller(recyclerView.getContext());
        smoothScroller.setTargetPosition(position);
        startSmoothScroll(smoothScroller);
    }

    private static class FirstSmoothScroller extends LinearSmoothScroller {

        FirstSmoothScroller(Context context) {
            super(context);
        }

        @Override
        public int calculateDtToFit(int viewStart, int viewEnd, int boxStart, int boxEnd,
                                    int snapPreference) {
            Log.d("LayoutManager","vs="+viewStart+" vd="+viewEnd+" bs="+boxStart+" bd="+boxEnd);
            return boxStart - viewStart + (viewEnd - viewStart);
        }

        @Override
        protected float calculateSpeedPerPixel(DisplayMetrics displayMetrics) {
            return 150f / displayMetrics.densityDpi;
        }
    }
}

下面的方式有缺陷

1、CenterFocusLinearLayoutManager 类是解决LinearLayoutManager模式下的item居中问题同时也控制了焦点乱跳问题，有多个重载构造函数，其中isLeft表示是否控制左键，其他参数就不用我说了吧。如果false表示不自己控制左键，那么将默认使用系统的规范。
isLeft默认true
isRight默认true
isUp默认false
isDown默认false

public class CenterFocusLinearLayoutManager extends LinearLayoutManager {

    private int orientation = VERTICAL;

    public CenterFocusLinearLayoutManager(Context context) {
        super(context);
    }

    public CenterFocusLinearLayoutManager(Context context, boolean isLeft, boolean isRight) {
        super(context);
        this.isLeft = isLeft;
        this.isRight = isRight;
    }

    public CenterFocusLinearLayoutManager(Context context, boolean isLeft, boolean isRight, boolean isDown) {
        super(context);
        this.isLeft = isLeft;
        this.isRight = isRight;
        this.isDown = isDown;
    }

    public CenterFocusLinearLayoutManager(Context context, int orientation, boolean reverseLayout) {
        super(context, orientation, reverseLayout);
        this.orientation = orientation;
    }

    public CenterFocusLinearLayoutManager(Context context, int orientation, boolean reverseLayout, boolean isLeft, boolean isRight) {
        super(context, orientation, reverseLayout);
        this.isLeft = isLeft;
        this.isRight = isRight;
        this.orientation = orientation;
    }

    public CenterFocusLinearLayoutManager(Context context, int orientation, boolean reverseLayout, boolean isLeft, boolean isRight, boolean isDown) {
        super(context, orientation, reverseLayout);
        this.isLeft = isLeft;
        this.isRight = isRight;
        this.isDown = isDown;
        this.orientation = orientation;
    }

    public CenterFocusLinearLayoutManager(Context context, int orientation, boolean reverseLayout, boolean isLeft, boolean isRight, boolean isUp, boolean isDown) {
        super(context, orientation, reverseLayout);
        this.isLeft = isLeft;
        this.isRight = isRight;
        this.isUp = isUp;
        this.isDown = isDown;
        this.orientation = orientation;
    }


    private boolean isLeft = true;
    private boolean isRight = true;
    private boolean isUp = false;
    private boolean isDown = false;

    @Override
    public void smoothScrollToPosition(RecyclerView recyclerView, RecyclerView.State state, int position) {
        RecyclerView.SmoothScroller smoothScroller = new CenterSmoothScroller(recyclerView.getContext());
        smoothScroller.setTargetPosition(position);
        startSmoothScroll(smoothScroller);
    }

    public static class CenterSmoothScroller extends LinearSmoothScroller {

        CenterSmoothScroller(Context context) {
            super(context);
        }

        @Override
        public int calculateDtToFit(int viewStart, int viewEnd, int boxStart, int boxEnd, int snapPreference) {
            return (boxStart + (boxEnd - boxStart) / 2) - (viewStart + (viewEnd - viewStart) / 2);
        }
    }

    private long mLastKeyDownTime = 0;

    @Override
    public View onInterceptFocusSearch(View focused, int direction) {

        long current = System.currentTimeMillis();
        if (current - mLastKeyDownTime < 500) {//延时获得焦点
            return focused;
        } else {
            mLastKeyDownTime = current;
            if (getFocusedChild() != null) {
                int pos = getPosition(getFocusedChild());//这里要用这个方法
//            int pos = getPosition(focused);//这里要用这个方法
                int count = getItemCount();
                int lastVisiblePosition = findLastVisibleItemPosition();
                switch (direction) {
                    case View.FOCUS_LEFT:
                        if (isLeft) {
                            if (orientation == VERTICAL) {
                                return focused;
                            } else {
                                if (pos == 0) {
                                    return focused;
                                }
                            }
                        }
                        break;
                    case View.FOCUS_RIGHT:
                        if (isRight) {
                            if (orientation == VERTICAL) {
                                return focused;
                            } else {
                                if (pos == count - 1) {
                                    return focused;
                                }
                            }
                        }
                        break;
                    case View.FOCUS_UP:
                        if (isUp) {
                            if (orientation == VERTICAL) {
                                if (pos == 0) {
                                    return focused;
                                }
                            } else {
                                return focused;
                            }
                        }
                        break;
                    case View.FOCUS_DOWN:
                        if (isDown) {
                            if (orientation == VERTICAL) {
                                if (pos == count - 1) {
                                    return focused;
                                }
                            } else {
                                return focused;
                            }
                        }
                        break;
                }
                if (pos > getItemCount() - 1) {
                    return focused;
                } else if (pos > lastVisiblePosition) {
                    scrollToPosition(pos);
                }
            }
            return super.onInterceptFocusSearch(focused, direction);
        }
    }
}

如果想要居中的话需要写一个回调接口，在adapter中传position给activity，并在回调中加入下面代码即可

mRecyclerView.smoothScrollToPosition(position);

2、CenterFocusGridLayoutManager 类是解决GridLayoutManager模式下的item居中问题同时也控制了焦点乱跳问题，如果不居中，本人也想不到其他方法控制焦点乱跳，网上的方法都试过，没效果。
isLeft默认true
isRight默认true
isUp默认false
isDown默认false
isAlone默认false

public class CenterFocusGridLayoutManager extends GridLayoutManager {

    private int spanCount;
    private int orientation= VERTICAL;

    public CenterFocusGridLayoutManager(Context context, int spanCount) {
        super(context, spanCount);
        this.spanCount = spanCount;
    }

    public CenterFocusGridLayoutManager(Context context, int spanCount, boolean isAlone) {
        super(context, spanCount);
        this.spanCount = spanCount;
        this.isAlone = isAlone;
    }

    public CenterFocusGridLayoutManager(Context context, int spanCount, boolean isLeft, boolean isRight) {
        super(context, spanCount);
        this.spanCount = spanCount;
        this.isLeft = isLeft;
        this.isRight = isRight;
    }

    public CenterFocusGridLayoutManager(Context context, int spanCount, boolean isLeft, boolean isRight, boolean isDown) {
        super(context, spanCount);
        this.spanCount = spanCount;
        this.isLeft = isLeft;
        this.isRight = isRight;
        this.isDown = isDown;
    }

    public CenterFocusGridLayoutManager(Context context, int spanCount, int orientation, boolean reverseLayout, boolean isLeft, boolean isRight) {
        super(context, spanCount, orientation, reverseLayout);
        this.spanCount = spanCount;
        this.isLeft = isLeft;
        this.isRight = isRight;
        this.orientation = orientation;
    }

    public CenterFocusGridLayoutManager(Context context, int spanCount, int orientation, boolean reverseLayout,boolean isAlone, boolean isLeft, boolean isRight,boolean isUp, boolean isDown) {
        super(context, spanCount, orientation, reverseLayout);
        this.spanCount = spanCount;
        this.orientation = orientation;
        this.isAlone = isAlone;
        this.isLeft = isLeft;
        this.isRight = isRight;
        this.isUp = isUp;
        this.isDown = isDown;
    }

    private boolean isRight = true;
    private boolean isLeft = true;
    private boolean isUp=false;
    private boolean isDown = false;
    private boolean isAlone=false;


    //用来控制自定义每行/每列不同个数的焦点，默认false。因为平常的就不适用了
    private int[] rightPosArray;
    private int[] leftPosArray;

    public void setRightPosArray(int[] rightPosArray) {
        this.rightPosArray = rightPosArray;
    }
    public void setLeftPosArray(int[] leftPosArray) {
        this.leftPosArray = leftPosArray;
    }

    @Override
    public void smoothScrollToPosition(RecyclerView recyclerView, RecyclerView.State state, int position) {
        RecyclerView.SmoothScroller smoothScroller = new CenterSmoothScroller(recyclerView.getContext());
        smoothScroller.setTargetPosition(position);
        startSmoothScroll(smoothScroller);
    }

    public static class CenterSmoothScroller extends LinearSmoothScroller {

        CenterSmoothScroller(Context context) {
            super(context);
        }

        @Override
        public int calculateDtToFit(int viewStart, int viewEnd, int boxStart, int boxEnd, int snapPreference) {
            return (boxStart + (boxEnd - boxStart) / 2) - (viewStart + (viewEnd - viewStart) / 2);
        }
    }
    private long mLastKeyDownTime = 0;
    @Override
    public View onInterceptFocusSearch(View focused, int direction) {
        long current = System.currentTimeMillis();
        if (current - mLastKeyDownTime < 500) {
            return focused;
        } else {
            mLastKeyDownTime = current;
            if (getFocusedChild() != null) {
                int pos = getPosition(getFocusedChild());
                int lastVisibleItemPos = findLastVisibleItemPosition();
                int count = getItemCount();
                pos += 1;
                if (direction == View.FOCUS_RIGHT) {
                    if (isAlone) {
                        for (int position : rightPosArray) {
                            if (pos == position) {
                                return focused;
                            }
                        }
                    } else if (isRight) {
                        if (orientation == VERTICAL) {
                            if (pos % spanCount == 0) {//|| pos==getChildCount()
                                return focused;
                            }
                        } else {
                            if (pos > count - spanCount) {
                                return focused;
                            }
                        }
                    }
                } else if (direction == View.FOCUS_LEFT) {
                    if (isAlone) {
                        for (int position : leftPosArray) {
                            if (pos == position) {
                                return focused;
                            }
                        }
                    } else if (isLeft) {
                        if (orientation == VERTICAL) {
                            if (pos % spanCount == 1) {
                                return focused;
                            }
                        } else {
                            if (pos <= spanCount) {
                                return focused;
                            }
                        }
                    }
                } else if (direction == View.FOCUS_UP) {
                    if (isUp) {
                        if (orientation == VERTICAL) {
                            if (pos <= spanCount) {
                                return focused;
                            }
                        } else {
                            if (pos % spanCount == 1) {
                                return focused;
                            }
                        }
                    }
                } else if (direction == View.FOCUS_DOWN) {
                    if (isDown) {
                        if (orientation == VERTICAL) {
                            if (pos > count - spanCount) {
                                return focused;
                            }
                        } else {
                            if (pos % spanCount == 0) {
                                return focused;
                            }
                        }
                    }
                }
                if (pos > getItemCount()) {
                    return focused;
                } else if (pos > lastVisibleItemPos+1) {
                    scrollToPosition(pos);
                }
            }
            return super.onInterceptFocusSearch(focused, direction);
        }
    }
}

3、给大家一个焦点获得与失去监听的工具类（获得焦点的view会变大且可以获得边框并且可以通过回调得到选中的position）

public class KeyUtils {

    public static void keyListenerBackground(final View mView){
        mView.setOnFocusChangeListener(new View.OnFocusChangeListener() {
            @Override
            public void onFocusChange(View view, boolean b) {
                if (b) {
                    mView.setSelected(true);
                    ScaleAnimation animationTwoCopy = new ScaleAnimation(1f, 1.1f, 1f, 1.1f, mView.getWidth() / 2, mView.getHeight() / 2);
                    animationTwoCopy.setDuration(300);
                    animationTwoCopy.setFillAfter(true);
                    mView.startAnimation(animationTwoCopy);
                }else {
                    mView.setSelected(false);
                    ScaleAnimation animationTwo = new ScaleAnimation(1.1f, 1f, 1.1f, 1f, mView.getWidth() / 2, mView.getHeight() / 2);
                    animationTwo.setDuration(300);
                    animationTwo.setFillAfter(true);
                    mView.startAnimation(animationTwo);
                }
            }
        });
    }
    public static void keyListenerBackground(final View mView, final View v2){
        mView.setOnFocusChangeListener(new View.OnFocusChangeListener() {
            @Override
            public void onFocusChange(View view, boolean b) {
                if (b) {
                    v2.setSelected(true);
                    ScaleAnimation animationTwoCopy = new ScaleAnimation(1f, 1.1f, 1f, 1.1f, mView.getWidth() / 2, mView.getHeight() / 2);
                    animationTwoCopy.setDuration(300);
                    animationTwoCopy.setFillAfter(true);
                    mView.startAnimation(animationTwoCopy);
                }else {
                    v2.setSelected(false);
                    ScaleAnimation animationTwo = new ScaleAnimation(1.1f, 1f, 1.1f, 1f, mView.getWidth() / 2, mView.getHeight() / 2);
                    animationTwo.setDuration(300);
                    animationTwo.setFillAfter(true);
                    mView.startAnimation(animationTwo);
                }
            }
        });
    }
    public static void keyListenerBackground(final View mView, final int position, final String type){
        mView.setOnFocusChangeListener(new View.OnFocusChangeListener() {
            @Override
            public void onFocusChange(View view, boolean b) {
                if (b) {
                    IGlobalCallback callback= CallbackManager.getInstance().getCallback(type);
                    if (callback != null) {
                        callback.executeCallback(position);
                    }
                    mView.setSelected(true);
                    ScaleAnimation animationTwoCopy = new ScaleAnimation(1f, 1.1f, 1f, 1.1f, mView.getWidth() / 2, mView.getHeight() / 2);
                    animationTwoCopy.setDuration(300);
                    animationTwoCopy.setFillAfter(true);
                    mView.startAnimation(animationTwoCopy);
                }else {
                    mView.setSelected(false);
                    ScaleAnimation animationTwo = new ScaleAnimation(1.1f, 1f, 1.1f, 1f, mView.getWidth() / 2, mView.getHeight() / 2);
                    animationTwo.setDuration(300);
                    animationTwo.setFillAfter(true);
                    mView.startAnimation(animationTwo);
                }
            }
        });
    }
    /*****************************item获得与失去焦点的监听***************************/
    public static void keyListenerItem(final View mView){
        mView.setOnFocusChangeListener(new View.OnFocusChangeListener() {
            @Override
            public void onFocusChange(View view, boolean b) {
                if (b) {
                    mView.setSelected(true);
                    ScaleAnimation animationTwoCopy = new ScaleAnimation(1f, 1.02f, 1f, 1.02f, mView.getWidth() / 2, mView.getHeight() / 2);
                    animationTwoCopy.setDuration(300);
                    animationTwoCopy.setFillAfter(true);
                    mView.startAnimation(animationTwoCopy);

                    yesBorder(mView);
                }else {
                    mView.setSelected(false);
                    //mView.setBackgroundResource(R.drawable.shape_select_background_false);
                    ScaleAnimation animationTwo = new ScaleAnimation(1.02f, 1f, 1.02f, 1f, mView.getWidth() / 2, mView.getHeight() / 2);
                    animationTwo.setDuration(300);
                    animationTwo.setFillAfter(true);
                    mView.startAnimation(animationTwo);

                    noBorder(mView);
                }
            }
        });
    }
    public static void keyListenerItem(final View mView, final int position, final String type){
        mView.setOnFocusChangeListener(new View.OnFocusChangeListener() {
            @Override
            public void onFocusChange(View view, boolean b) {
                if (b) {
                    IGlobalCallback callback=CallbackManager.getInstance().getCallback(type);
                    if (callback != null) {
                        callback.executeCallback(position);
                    }
                    ScaleAnimation animationTwoCopy = new ScaleAnimation(1f, 1.06f, 1f, 1.06f, mView.getWidth() / 2, mView.getHeight() / 2);
                    animationTwoCopy.setDuration(300);
                    animationTwoCopy.setFillAfter(true);
                    mView.startAnimation(animationTwoCopy);

                    yesBorder(mView);
                }else {
                    ScaleAnimation animationTwo = new ScaleAnimation(1.06f, 1f, 1.06f, 1f, mView.getWidth() / 2, mView.getHeight() / 2);
                    animationTwo.setDuration(300);
                    animationTwo.setFillAfter(true);
                    mView.startAnimation(animationTwo);

                    noBorder(mView);
                }
            }
        });
    }
    /********************************************************/
    public static void keyListenerText(final View mView){
        mView.setOnFocusChangeListener(new View.OnFocusChangeListener() {
            @Override
            public void onFocusChange(View view, boolean b) {
                if (b) {
                    ScaleAnimation animationTwoCopy = new ScaleAnimation(1f, 1.15f, 1f, 1.15f, mView.getWidth() / 2, mView.getHeight() / 2);
                    animationTwoCopy.setDuration(300);
                    animationTwoCopy.setFillAfter(true);
                    mView.startAnimation(animationTwoCopy);

                    yesBorder(mView);
                }else {
                    ScaleAnimation animationTwo = new ScaleAnimation(1.15f, 1f, 1.15f, 1f, mView.getWidth() / 2, mView.getHeight() / 2);
                    animationTwo.setDuration(300);
                    animationTwo.setFillAfter(true);
                    mView.startAnimation(animationTwo);

                    noBorder(mView);
                }
            }
        });
    }
    private static void yesBorder(View mView){
        //创建Drawable对象
        GradientDrawable drawable=new GradientDrawable();
        drawable.setStroke(3, Color.parseColor("#A4D9DF"));
        drawable.setColor(Color.TRANSPARENT);
        drawable.setCornerRadius(6);
        mView.setBackground(drawable);
    }
    private static void noBorder(View mView){
        GradientDrawable drawable=new GradientDrawable();
        drawable.setCornerRadius(6);
        drawable.setColor(Color.TRANSPARENT);
        mView.setBackground(drawable);
    }
}
错把套路当深情
关注
  • 3
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
RecyclerView通过DPAD按键上下切换焦点 切换到界面外的控件时焦点会左右乱跳
mowwwcom的专栏
07-21 1061
RecyclerView上下切换焦点左右乱跳
android 控制焦点,Android应用开发：NO.2--RecyclerView 焦点控制
weixin_35719380的博客
05-31 1327
本文主要介绍了Android应用开发的NO.2--RecyclerView 焦点控制，希望对大家学习Android应用开发有所帮助。android TV使用 RecyclerView ，用焦点控制item首先在item中的xml中，的最外层添加 android:focusable="true"，此句是为RecyclerView 的item添加焦点属性，添加完属性后，在RecyclerView 的 ...
Android TV中使用RecyclerView左右长按或者连续按键焦点飞掉的问题
lb687的专栏
05-26 341
【代码】Android TV中使用RecyclerView左右长按或者连续按键焦点飞掉的问题。
recyclerview 中item多行多列edittext切换，及切换下一个item中的edittext问题
Runt02的博客
05-25 923
上一篇文章已经讲过，关于edittext切换焦点，将光标设置到最后一位的问题。有兴趣的朋友可以看我上一篇文章 今天主要讲recyclerview中多行多列的edittext切换及切换下一个item中的edittext问题 先看看在不加任何处理的情况下的edittext在recyclerview中切换效果（当然，edittext的前提需要设置singleline=true，maxlines=1，这样才能激活键盘中的切换下一项功能） 从图中大家可以看到，在没有任何处理的情况下，光标直接切换到底部的editte
android TV app适配遥控器思路，recycleview选中放大
最新发布
简公子的博客
05-06 541
再将adapter中的item布局中，只设置一个view的focusable是true，其他的都设置成false，这样，遥控器就可以进行选择了，同时遥控器中的ok键，就是click事件；这样就可以响应遥控器的操作了，并且还有失去、获取焦点，view放大缩小的动画；当遥控器遥控盒子，app内是有一套机制，响应遥控器的操作，
[Android]Android焦点流程代码分析
weixin_34160277的博客
08-04 196
以下内容为原创，欢迎转载，转载请注明 来自天天博客：http://www.cnblogs.com/tiantianbyconan/p/7286503.html 通过View的View::focusSearch进行焦点搜索对应方向上的下一个可以获取焦点的View： public View focusSearch(@FocusRealDirection int direction) { if...
android-recyclerview-binding:RecyclerView +数据绑定+ LiveData示例
04-28
RecyclerView +数据绑定示例简单样本直接将LiveData与数据绑定一起使用<? xml version = " 1.0 " encoding = " utf-8 " ?>< layout xss=removed xss=removed> < data> < variable xss=removed xss=removed> &...
android-support-v7-recyclerview.jar.zip
05-30
这个库，名为`android-support-v7-recyclerview.jar.zip`，包含了对RecyclerView的支持，使得开发者能够创建高效且可定制化的列表和网格视图。下面我们将深入探讨RecyclerView及其相关知识点。 一、RecyclerView...
Android-AndroidTV上使用的RecyclerView和焦点框架
08-12
在Android开发中，RecyclerView是一个非常重要的组件，尤其在Android TV这样的大屏幕设备上，它扮演着展示大量数据的关键角色。本文将深入探讨Android TV上RecyclerView的使用以及与焦点框架的结合，帮助开发者创建...
android-support-v7-recyclerview.jar
09-24
本人长期做Android机顶盒开发，需要直接在sdk中进行导入jar包。所以需要很多jar包的支持。有时候很难找到合适的jar包。为了方便使用jar的童鞋快速完成项目，我决定将所有亲测的jar包分享出来。我上传的每个jar包都是...
Android TV 上使用的RecyclerView和焦点框架，焦点框移动效果，完胜androidTvwidget的MainUpView
05-11
在android tv开发中最方便快捷的开发库，一两行代码搞定获取得焦点效果，列表移动框边缘拦截，事件处理
android TV Recyclerview焦点控制及自动换行
09-23
最近开始接触Android TV端开发，有好多不适应，尤其是对焦点的控制，这也是手机app和电视app最大的不同之处。RecyclerView是个强大的控件，能代替ListView，GridView，能实现瀑布流，还能实现横向ListView，只需要一句代码就能使纵向的ListView变成横向的（主要实现就是布局管理器的选择上）。这里我要实现的是RecyclerView的item的焦点控制和RecyclerView末尾自动换行。
电视TV端使用RecyclerView开发遇到的问题
Singleton1900的专栏
09-15 1万+
最近在做一个TV端使用的相册。偷偷展示一下，相册大概长这个样子： 相册也支持多选删除： 非删除模式下点击单一图片会进入单一图片展示界面。单一图片可以左右翻页。 从展示界面返回相册界面，光标定位到展示图片所在的相册位置。主要控件使用了CardView 和RecyclerView。 TV开发和手机开发有个不同的就是焦点问题。
android 两个控件同时获得焦点,Android TV 焦点 recycleview中包含多个 焦点获取控件，上下滑动时，焦点错乱...
weixin_39625864的博客
05-28 336
需要覆写LinearLayoutManager中的onFocusSearchFailed方法，在超出当前屏幕时进行特殊处理，代码如下：package com.**********.utils;import android.content.Context;import android.support.v7.widget.RecyclerView;import android.util.Attrib...
android 跳转的时候默认焦点,RecyclerView焦点跳转BUG优化的方法
weixin_35808305的博客
06-01 315
我们把RecyclerView写成GridView样式，并把RecyclerView的item写成focusable并且有焦点框的时候，我们用焦点滚动RecyclerView的时候会发现RecyclerView的焦点跳转有bug，跟我们想要的焦点跳转规则不一致，会出现的BUG如下图：黑色方框代表屏幕，我们从左上角的一个item往下按焦点的时候，当需要加载新的一行的时候焦点却跑到了新的一行的最后一个...
解决在机顶盒上RecyclerView设置GridLayoutManager时，每行的第一个item选中状态的放大聚焦无法展示完整的问题
weixin_41208172的博客
07-04 453
if (includeEdge) { // 如果需要设置左右边距。} else { // 如果不需要设置左右边距。放大时左边就不会出现展示不全的情况了。方法，该方法表示针对某个。的时候，左侧所有第一个。中的Item的间距。
TV开发焦点跑飞的问题
ithouse的专栏
08-27 1207
在使用TV开发时，有可以提供使用的leanback类库里的VerticalGridView等代替手机上的RecyclerView，但实际开发中，经常还是要用到RecyclerView，RecyclerView虽然强大，在TV上却经常遇到焦点跑飞的情况，原因： RecyclerView在长按遥控器的情况下会导致Item的焦点丢失或者说是飞到别的控件上。主要是因为RecyclerView设置适配器，将...
Android TV开发的焦点记忆 焦点移动到列表中的某一项中,焦点移出去,在回来时焦点还要定位到原来的item上
weixin_43721056的博客
11-01 1598
当焦点从 RecyclerView 上移出的时候，需要保存 RecyclerView 当前聚焦的 View ，下次 RecyclerVlew 将要获得焦点的时候，主动聚焦到上—次聚焦的 View 上。
Android中RecyclerView的使用(焦点控制)
热门推荐
Zou_pl的博客
01-01 1万+
注：第一篇博客，是因为项目中遇到一个RecyclerViewView使用时焦点出错问题，研究半天才解决，先写这么多，后续会专门整理RecyclerView的博客。
Android程序开发初级教程-水滴整理分享-永久免费(完整版)
《Android程序开发初级教程-水滴整理分享-永久免费(完整版).doc》是一本详尽的Android程序开发教程。本教程详细介绍了Android平台的架构、开发语言以及各种功能组件。通过阅读本教程，读者可以全面了解Android开发的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值