VelocityTracker简析

VelocityTracker

直译过来就是速度追踪的意思，用于追踪手指滑动过程中的瞬时速度

使用方法如下

VelocityTracker velocityTracker = VelocityTracker.obtain();
//想要追踪当前速度，将事件加入追踪器
velocityTracker.addMovement(event);
//调用计算速度代码, 这个必须要调用
velocityTracker.computeCurrentVelocity(1000);
//分别获取x轴和y轴方向的1s时间内的平均速度
int xVelocity = (int) velocityTracker.getXVelocity();
int yVelocity = (int) velocityTracker.getYVelocity();
//释放追踪器
velocityTracker.recycle();
//重置并回收内存
velocityTracker.clear();

使用起来很简单，VelocityTracker源码大多都是native方法，研究了它的缓存机制，涉及以下方法

• static public VelocityTracker obtain()
• public void recycle()

VelocityTracker涉及缓存相关如下

• SynchronizedPool<VelocityTracker> sPool //缓存池变量

//设置缓存池大小为2
private static final SynchronizedPool<VelocityTracker> sPool =
            new SynchronizedPool<VelocityTracker>(2);

static public VelocityTracker obtain() {
      //从缓存池中获取VelocityTracker对象
       VelocityTracker instance = sPool.acquire();
       return (instance != null) ? instance : new VelocityTracker(null);
}
/**
  * 释放VelocityTracker归还缓存池中
  */
public void recycle() {
        if (mStrategy == null) {
            clear();
            sPool.release(this);
        }
}

SynchronizedPool这个类继承自SimplePool

    public static class SimplePool<T> implements Pool<T> {
        private final Object[] mPool;

        private int mPoolSize;

        /**
         * 创建一个指定大小的缓存池对象
         */
        public SimplePool(int maxPoolSize) {
            if (maxPoolSize <= 0) {
                throw new IllegalArgumentException("The max pool size must be > 0");
            }
            mPool = new Object[maxPoolSize];
        }

        @Override
        @SuppressWarnings("unchecked")
        public T acquire() {
            //如果缓存池有对象 ，则直接将末尾的实例返回，同时置空处理，缓存池大小-1
            if (mPoolSize > 0) {
                final int lastPooledIndex = mPoolSize - 1;
                T instance = (T) mPool[lastPooledIndex];
                mPool[lastPooledIndex] = null;
                mPoolSize--;
                return instance;
            }
            return null;
        }

       /**
        *  释放操作，如果缓存池为空，则将实例加入池中，如果不调用release操作，缓存池当中将不会有实例
        */
        @Override
        public boolean release(T instance) {
            if (isInPool(instance)) {
                throw new IllegalStateException("Already in the pool!");
            }
            if (mPoolSize < mPool.length) {
                mPool[mPoolSize] = instance;
                mPoolSize++;
                return true;
            }
            return false;
        }

        private boolean isInPool(T instance) {
            for (int i = 0; i < mPoolSize; i++) {
                if (mPool[i] == instance) {
                    return true;
                }
            }
            return false;
        }
    }

SynchronizedPool相比于SimplePool不同点在于SynchronizedPool的获取和释放操作都是同步加锁操作
另外如果VelocityTracker中不调用recycle操作，sPool不会起到缓存的作用，因为始终是空的