• Android自定义 View惯性滚动效果（不使用Scroller）

    效果图：

    前言：

    看了网上很多惯性滚动方案，都是通过Scroller 配合 computeScroll实现的，但在实际开发中可能有一些场景不合适，比如协调布局，内部子View有特别复杂的联动效果，需要通过偏移来配合。我通过VelocityTracker（速度跟踪器）实现了相同的效果，感觉还行🤣，欢迎指正，虚拟机有延迟，真机效果最佳。

    1. 布局文件 activity_main.xml

    1. "1.0" encoding="utf-8"?>
    2. <FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    3.     xmlns:app="http://schemas.android.com/apk/res-auto"
    4.     xmlns:tools="http://schemas.android.com/tools"
    5.     android:layout_width="match_parent"
    6.     android:layout_height="match_parent"
    7.     tools:context=".MainActivity">
    8.  
    9.     <com.example.flingscrollview.LinerScrollView
    10.         android:id="@+id/mScrollView"
    11.         android:orientation="vertical"
    12.         android:layout_height="match_parent"
    13.         android:layout_width="match_parent"/>
    14.  
    15. FrameLayout>

    2. 演示View

    1. package com.example.flingscrollview;
    2.  
    3. import android.content.Context;
    4. import android.graphics.Color;
    5. import android.os.Handler;
    6. import android.os.Looper;
    7. import android.util.AttributeSet;
    8. import android.view.Gravity;
    9. import android.view.MotionEvent;
    10. import android.view.VelocityTracker;
    11. import android.view.View;
    12. import android.view.ViewConfiguration;
    13. import android.view.ViewGroup;
    14. import android.widget.LinearLayout;
    15. import android.widget.TextView;
    16.  
    17. import androidx.annotation.Nullable;
    18.  
    19. public class LinerScrollView extends LinearLayout {
    20.  
    21.     final Handler mHandler;
    22.     private final int mTouchSlop; // 移动的距离大于这个像素值的时候，会认为是在滑动
    23.     private final int mMinimumVelocity; // 最小的速度
    24.     private final int mMaximumVelocity; // 最大的速度
    25.     private VelocityTracker mVelocityTracker; // 速度跟踪器
    26.     private int mScrollPointerId; // 当前最新放在屏幕伤的手指
    27.     private int mLastTouchX; // 上一次触摸的X坐标
    28.     private int mLastTouchY; // 上一次触摸的Y坐标
    29.     private int mInitialTouchX; // 初始化触摸的X坐标
    30.     private int mInitialTouchY; // 初始化触摸的Y坐标
    31.     public final int SCROLL_STATE_IDLE = -1; // 没有滚动
    32.     public final int SCROLL_STATE_DRAGGING = 1; // 被手指拖动情况下滚动
    33.     public final int SCROLL_STATE_SETTLING = 2; // 没有被手指拖动情况下，惯性滚动
    34.     private int mScrollState = SCROLL_STATE_IDLE; // 滚动状态
    35.  
    36.     // 在测试过程中，通过速度正负值判断方向，方向有概率不准确
    37.     // 所以我在onTouchEvent里自己处理
    38.     private boolean direction = true; // true：向上 false：向下
    39.     private FlingTask flingTask; // 惯性任务
    40.  
    41.     public LinerScrollView(Context context, @Nullable AttributeSet attrs) {
    42.         super(context, attrs);
    43.         mHandler = new Handler(Looper.getMainLooper());
    44.  
    45.         // 一些系统的预定义值:
    46.         ViewConfiguration configuration = ViewConfiguration.get(getContext());
    47.         mTouchSlop = configuration.getScaledTouchSlop();
    48.         mMinimumVelocity = configuration.getScaledMinimumFlingVelocity();
    49.         mMaximumVelocity = configuration.getScaledMaximumFlingVelocity();
    50.  
    51.         initView();
    52.     }
    53.  
    54.     /**
    55.      * 初始化视图
    56.      */
    57.     private void initView() {
    58.         for (int i = 0; i < 50; i++) {
    59.             TextView textView = new TextView(getContext());
    60.             ViewGroup.LayoutParams params = new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, 350);
    61.             textView.setLayoutParams(params);
    62.             textView.setText("index：" + i);
    63.             textView.setTextColor(Color.BLACK);
    64.             textView.setTextSize(30);
    65.             textView.setBackgroundColor(Color.CYAN);
    66.             textView.setGravity(Gravity.CENTER_VERTICAL);
    67.             addView(textView);
    68.         }
    69.     }
    70.  
    71.     boolean notUp = false; // 是否 不能再向上滑了
    72.     boolean notDown = false; // 是否 不能再向下滑了
    73.     int listMaxOffsetY = 0; // 列表最大滑动Y值
    74.  
    75.     /**
    76.      * 滚动列表
    77.      * @param offsetY 偏移Y值
    78.      */
    79.     private void translationViewY(int offsetY) {
    80.         if (listMaxOffsetY == 0) {
    81.             listMaxOffsetY = (350 * 50) - getHeight();
    82.         }
    83.  
    84.         if (mScrollState == SCROLL_STATE_DRAGGING) {
    85.  
    86.             if (direction) { // 向上滑动
    87.                 if (Math.abs(getChildAt((getChildCount() - 1)).getTranslationY()) < listMaxOffsetY) {
    88.                     notUp = false;
    89.                 }
    90.             } else { // 向下滑动
    91.                 if (getChildAt(0).getTranslationY() < 0) {
    92.                     notDown = false;
    93.                 }
    94.             }
    95.         }
    96.  
    97.         for (int i = 0; i < getChildCount(); i++) {
    98.             View childView = getChildAt(i);
    99.             int yv = (int) (childView.getTranslationY() + offsetY);
    100.             if (direction) { // 向上滑动
    101.                 notDown = false;
    102.                 if (!notUp) {
    103.                     if (Math.abs(yv) >= listMaxOffsetY) {
    104.                         notUp = true;
    105.                     }
    106.                 }
    107.                 if (!notUp) childView.setTranslationY(yv);
    108.             } else { // 向下滑动
    109.                 notUp = false;
    110.                 if (!notDown) {
    111.                     if (yv >= 0) {
    112.                         notDown = true;
    113.                     }
    114.                 }
    115.                 if (!notDown) childView.setTranslationY(yv);
    116.             }
    117.         }
    118.     }
    119.  
    120.     /**
    121.      * 惯性任务
    122.      * @param velocityX X轴速度
    123.      * @param velocityY Y轴速度
    124.      * @return
    125.      */
    126.     private boolean fling(int velocityX, int velocityY) {
    127.         if (Math.abs(velocityY) > mMinimumVelocity) {
    128.             flingTask = new FlingTask(Math.abs(velocityY), mHandler, new FlingTask.FlingTaskCallback() {
    129.                 @Override
    130.                 public void executeTask(int dy) {
    131.                     if (direction) { // 向上滑动
    132.                         translationViewY(-dy);
    133.                     } else { // 向下滑动
    134.                         translationViewY(dy);
    135.                     }
    136.                 }
    137.  
    138.                 @Override
    139.                 public void stopTask() {
    140.                     setScrollState(SCROLL_STATE_IDLE);
    141.                 }
    142.             });
    143.  
    144.             flingTask.run();
    145.             setScrollState(SCROLL_STATE_SETTLING);
    146.             return true;
    147.         }
    148.         return false;
    149.     }
    150.  
    151.     /**
    152.      * 停止惯性滚动任务
    153.      */
    154.     private void stopFling() {
    155.         if (mScrollState == SCROLL_STATE_SETTLING) {
    156.             if (flingTask != null) {
    157.                 flingTask.stopTask();
    158.                 setScrollState(SCROLL_STATE_IDLE);
    159.             }
    160.         }
    161.     }
    162.  
    163.  
    164.     @Override
    165.     public boolean onTouchEvent(MotionEvent event) {
    166.         super.onTouchEvent(event);
    167.         boolean eventAddedToVelocityTracker = false;
    168.  
    169.         // 获取一个新的VelocityTracker对象来观察滑动的速度
    170.         if (mVelocityTracker == null) {
    171.             mVelocityTracker = VelocityTracker.obtain();
    172.         }
    173.         mVelocityTracker.addMovement(event);
    174.  
    175.         // 返回正在执行的操作，不包含触摸点索引信息。即事件类型，如MotionEvent.ACTION_DOWN
    176.         final int action = event.getActionMasked();
    177.         int actionIndex = event.getActionIndex();// Action的索引
    178.  
    179.         // 复制事件信息创建一个新的事件，防止被污染
    180.         final MotionEvent copyEv = MotionEvent.obtain(event);
    181.  
    182.         switch (action) {
    183.             case MotionEvent.ACTION_DOWN: { // 手指按下
    184.                 stopFling();
    185.  
    186.                 // 特定触摸点相关联的触摸点id,获取第一个触摸点的id
    187.                 mScrollPointerId = event.getPointerId(0);
    188.  
    189.                 // 记录down事件的X、Y坐标
    190.                 mInitialTouchX = mLastTouchX = (int) (event.getX() + 0.5f);
    191.                 mInitialTouchY = mLastTouchY = (int) (event.getY() + 0.5f);
    192.             }
    193.             break;
    194.             case MotionEvent.ACTION_POINTER_DOWN: { // 多个手指按下
    195.                 // 更新mScrollPointerId,表示只会响应最近按下的手势事件
    196.                 mScrollPointerId = event.getPointerId(actionIndex);
    197.  
    198.                 // 更新最近的手势坐标
    199.                 mInitialTouchX = mLastTouchX = (int) (event.getX() + 0.5f);
    200.                 mInitialTouchY = mLastTouchY = (int) (event.getY() + 0.5f);
    201.             }
    202.             break;
    203.             case MotionEvent.ACTION_MOVE: { // 手指移动
    204.                 setScrollState(SCROLL_STATE_DRAGGING);
    205.  
    206.                 // 根据mScrollPointerId获取触摸点下标
    207.                 final int index = event.findPointerIndex(mScrollPointerId);
    208.  
    209.                 // 根据move事件产生的x，y来计算偏移量dx，dy
    210.                 final int x = (int) (event.getX() + 0.5f);
    211.                 final int y = (int) (event.getY() + 0.5f);
    212.  
    213.                 int dx = Math.abs(mLastTouchX - x);
    214.                 int dy = Math.abs(mLastTouchY - y);
    215.  
    216.                 // 在手指拖动状态下滑动
    217.                 if (mScrollState == SCROLL_STATE_DRAGGING) {
    218.                     if (mLastTouchY - y > 0.5f) {
    219.                         direction = true;
    220.                         // Log.d("TAG", "向上");
    221.                         translationViewY(-dy);
    222.                     } else if (y - mLastTouchY > 0.5f) {
    223.                         direction = false;
    224.                         // Log.d("TAG", "向下");
    225.                         translationViewY(dy);
    226.                     }
    227.                 }
    228.  
    229.                 mLastTouchX = x;
    230.                 mLastTouchY = y;
    231.             }
    232.             break;
    233.             case MotionEvent.ACTION_POINTER_UP: { // 多个手指离开
    234.                 // 选择一个新的触摸点来处理结局，重新处理坐标
    235.                 onPointerUp(event);
    236.             }
    237.             break;
    238.             case MotionEvent.ACTION_UP: { // 手指离开，滑动事件结束
    239.                 mVelocityTracker.addMovement(copyEv);
    240.                 eventAddedToVelocityTracker = true;
    241.  
    242.                 // 计算滑动速度
    243.                 mVelocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);
    244.  
    245.                 // 最后一次 X/Y 轴的滑动速度
    246.                 final float xVel = -mVelocityTracker.getXVelocity(mScrollPointerId);
    247.                 final float yVel = -mVelocityTracker.getYVelocity(mScrollPointerId);
    248.  
    249.                 if (!((xVel != 0 || yVel != 0) && fling((int) xVel, (int) yVel))) {
    250.                     setScrollState(SCROLL_STATE_IDLE); // 设置滑动状态
    251.                 }
    252.                 resetScroll(); // 重置滑动
    253.             }
    254.             break;
    255.             case MotionEvent.ACTION_CANCEL: { //手势取消，释放各种资源
    256.                 cancelScroll(); // 退出滑动
    257.             }
    258.             break;
    259.         }
    260.  
    261.         if (!eventAddedToVelocityTracker) {
    262.             // 回收滑动事件，方便重用，调用此方法你不能再接触事件
    263.             mVelocityTracker.addMovement(copyEv);
    264.         }
    265.  
    266.         // 回收滑动事件，方便重用
    267.         copyEv.recycle();
    268.         return true;
    269.     }
    270.  
    271.     /**
    272.      * 有新手指触摸屏幕，更新初始坐标
    273.      * @param e
    274.      */
    275.     private void onPointerUp(MotionEvent e) {
    276.         final int actionIndex = e.getActionIndex();
    277.         if (e.getPointerId(actionIndex) == mScrollPointerId) {
    278.             // Pick a new pointer to pick up the slack.
    279.             final int newIndex = actionIndex == 0 ? 1 : 0;
    280.             mScrollPointerId = e.getPointerId(newIndex);
    281.             mInitialTouchX = mLastTouchX = (int) (e.getX(newIndex) + 0.5f);
    282.             mInitialTouchY = mLastTouchY = (int) (e.getY(newIndex) + 0.5f);
    283.         }
    284.     }
    285.  
    286.     /**
    287.      * 手指离开屏幕
    288.      */
    289.     private void cancelScroll() {
    290.         resetScroll();
    291.         setScrollState(SCROLL_STATE_IDLE);
    292.     }
    293.  
    294.     /**
    295.      * 重置速度
    296.      */
    297.     private void resetScroll() {
    298.         if (mVelocityTracker != null) {
    299.             mVelocityTracker.clear();
    300.         }
    301.     }
    302.  
    303.     /**
    304.      * 更新 滚动状态
    305.      * @param state
    306.      */
    307.     private void setScrollState(int state) {
    308.         if (state == mScrollState) {
    309.             return;
    310.         }
    311.         mScrollState = state;
    312.     }
    313.  
    314. }

    3. 惯性滚动任务类（核心类）

    1. package com.example.flingscrollview;
    2.  
    3. import android.os.Handler;
    4. import android.util.Log;
    5.  
    6. /**
    7.  * 惯性任务
    8.  */
    9. public class FlingTask implements Runnable {
    10.  
    11.     private Handler mHandler;
    12.     private int velocityY = 0;
    13.     private int originalVelocityY = 0;
    14.     private FlingTaskCallback flingTaskCallback;
    15.  
    16.     public FlingTask(int velocityY, Handler handler, FlingTaskCallback callback) {
    17.         this.velocityY = velocityY;
    18.         this.mHandler = handler;
    19.         this.originalVelocityY = velocityY;
    20.         this.flingTaskCallback = callback;
    21.     }
    22.  
    23.     boolean initSlide = false; // 初始化滑动
    24.     int average = 0; // 平均速度
    25.     int tempAverage = 1;
    26.     boolean startSmooth = false; // 开始递减速度平滑处理
    27.     int sameCount = 0; // 值相同次数
    28.  
    29.     // 这里控制平均每段滑动的速度
    30.     private int getAverageDistance(int velocityY) {
    31.         int t = velocityY;
    32.         if (t < 470) {
    33.             t /= 21;
    34.         }
    35.         // divide by zero
    36.         if (t == 0) return 0;
    37.         int v = Math.abs(velocityY / t);
    38.         if (v < 21) {
    39.             t /= 21;
    40.             if (t > 20) {
    41.                 t /= 5;
    42.             }
    43.         }
    44.         return t;
    45.     }
    46.  
    47.     @Override
    48.     public void run() {
    49.         // 速度完全消耗完才结束任务，和view滚动结束不冲突
    50.         // 这个判断是为了扩展，将没消耗完的速度，转给指定的滚动view
    51.         // if (velocityY > 0) {
    52.  
    53.         // 只要view滚动结束，立刻结束任务
    54.         if (tempAverage > 0 && velocityY > 0) {
    55.  
    56.             if (!initSlide) {
    57.                 average = getAverageDistance(velocityY);
    58.                 initSlide = true;
    59.             }
    60.  
    61.             float progress = (float) velocityY / originalVelocityY;
    62.             float newProgress = 0f;
    63.             if (average > 300) {
    64.                 newProgress = getInterpolation(progress);
    65.             } else {
    66.                 newProgress = getInterpolation02(progress);
    67.             }
    68.  
    69.             int prTemp = tempAverage;
    70.             if (!startSmooth) tempAverage = (int) (average * newProgress);
    71.  
    72.             // 递减速度平滑处理
    73.             if (prTemp == tempAverage) {
    74.                 sameCount++;
    75.                 if (sameCount > 1 && tempAverage > 0) { // 这个值越大，最后衰减停止时越生硬，0 - 30
    76.                     tempAverage--;
    77.                     sameCount = 0;
    78.                     startSmooth = true;
    79.                 }
    80.             }
    81.  
    82.             flingTaskCallback.executeTask(tempAverage);
    83.  
    84.             velocityY -= tempAverage;
    85.  
    86.             // 这里这样写是为了扩展，将没消耗完的速度，转给其他滚动列表
    87.             // 判断语句需要改成 if (velocityY > 0)
    88.             if (tempAverage == 0) { // view滚动停止时
    89.                 // 如果速度没有消耗完，继续消耗
    90.                 flingTaskCallback.executeConsumptionTask(velocityY);
    91.                 velocityY -= average;
    92.             }
    93.             // Log.d("TAG", "tempAverage：" + tempAverage + " --- velocityY：" + velocityY + " --- originalVelocityY：" + originalVelocityY);
    94.  
    95.             mHandler.post(this);
    96.         } else {
    97.             flingTaskCallback.stopTask();
    98.             stopTask();
    99.         }
    100.     }
    101.  
    102.     public void stopTask() {
    103.         mHandler.removeCallbacks(this);
    104.         initSlide = false;
    105.         startSmooth = false;
    106.     }
    107.  
    108.     // 从加速度到逐步衰减（AccelerateDecelerateInterpolator插值器 核心源码）
    109.     public float getInterpolation(float input) {
    110.         return (float) (Math.cos((input + 1) * Math.PI) / 2.0f) + 0.5f;
    111.     }
    112.  
    113.     // 速度逐步衰减（DecelerateInterpolator插值器 核心源码）
    114.     public float getInterpolation02(float input) {
    115.         return (float) (1.0f - (1.0f - input) * (1.0f - input));
    116.     }
    117.  
    118.     public interface FlingTaskCallback {
    119.         void executeTask(int dy);
    120.  
    121.         void stopTask();
    122.  
    123.         void executeConsumptionTask(int dy);
    124.     }
    125. }

    4. Activity

    1. package com.example.flingscrollview;
    2.  
    3. import androidx.appcompat.app.AppCompatActivity;
    4.  
    5. import android.graphics.Color;
    6. import android.os.Bundle;
    7. import android.view.View;
    8. import android.view.ViewGroup;
    9. import android.widget.TextView;
    10.  
    11. public class MainActivity extends AppCompatActivity {
    12.  
    13.     @Override
    14.     protected void onCreate(Bundle savedInstanceState) {
    15.         super.onCreate(savedInstanceState);
    16.         setContentView(R.layout.activity_main);
    17.     }
    18.  
    19. }
  • 相关阅读:
    LP10备料单指定WM仓位设定（生产供应区域设定）
    执行SQL语句&存储过程的真正【神器】，不用ORM的全选它，比dapper好
    近200篇文章汇总而成的机器翻译非自回归生成最新综述，揭示其挑战和未来研究方向...
    APS成功实施的关键要点
    前端 JS 经典：上传文件
    适合上班族使用的电脑笔记软件使用哪一款
    【Redis 系列】redis 学习十六，redis 字典(map) 及其核心编码结构
    道可云元宇宙每日资讯｜《江苏省元宇宙产业发展行动计划》发布
    【数据结构】图的存储结构—邻接表
    铭飞MCms不建议使用
  • 原文地址：https://blog.csdn.net/Lan_Se_Tian_Ma/article/details/134323084