PointerLocationView 源码分析

package com.android.settings.macy11;

/*
 * Copyright (C) 2010 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */


import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.RectF;
import android.graphics.Paint.FontMetricsInt;
import android.hardware.input.InputManager;
import android.hardware.input.InputManager.InputDeviceListener;
import android.os.SystemProperties;
import android.util.Log;
import android.util.Slog;
import android.view.InputDevice;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.VelocityTracker;
import android.view.View;
import android.view.ViewConfiguration;
import android.view.WindowManagerPolicyConstants.PointerEventListener;
import android.view.MotionEvent.PointerCoords;

import java.util.ArrayList;
import java.util.Arrays;

/**
 * 此类默认情况下会绘制三条曲线
 * 第一条是手指触摸屏幕的轨迹 记录down-->move-->up
 * 第二条是手指离开屏幕那个时间点(对应ACTION_UP)获取到的估计量,在经过一个算法得到前后共7个时间点的估计值绘制出的估计轨迹
 * 第三条是手指离开屏幕那个时刻通过最后那个点(对应ACTION_UP)的x,y轴的速度刻画出未来16.67ms的速度矢量直线
 * 

 * {@link PLView#onPointerEvent(MotionEvent)} 此方法是记录整个TouchEvent的过程
 * Exp:
 * {@link PLView#mPointers} 屏幕上一共有几条触摸轨迹(一个完整的事件流的集合)记录在这个集合里
 * 集合中的数据类型是{@link PointerState}(一个完整的事件流)
 * 几个关键的属性
 * 

 * 以下三个变量用于实际触摸曲线的绘制
 * {@link PointerState#mTraceX x轨迹点的坐标}
 * {@link PointerState#mTraceY y轨迹点的坐标}
 * {@link PointerState#mTraceCurrent 经过的轨迹点:false 最后的触摸点:true 两种类型的点的坐标可能会有重合}
 * 

 * 用以下的两个变量来绘制速度矢量直线 这两个值的获取依赖 {@link PLView#mVelocityTracker}
 * {@link PointerState#mXVelocity} x分量速度
 * {@link PointerState#mYVelocity} y分量速度
 * 

 * 依靠下面的这个变量来绘制估计运动曲线 这个值的获取依赖于 {@link PLView#mVelocityTracker}
 * {@link PointerState#mEstimator} 位置估计变量 基于多项式模型的指针运动估计器
 * 

 * {@link PLView#mVelocityTracker} 事件的速度追踪
 * 

 * {@link PLView#onDraw(Canvas)} 绘制
 * 其余细节代码中有详细的标注
 */
public class PLView extends View implements InputDeviceListener,
        PointerEventListener {
    private static final String TAG = "Macy11-Pointer";

    // The system property key used to specify an alternate velocity tracker strategy
    // to plot alongside the default one.  Useful for testing and comparison purposes.
    // 系统属性键，用于指定另一种速度跟踪策略，以便与默认策略一起绘图。适用于测试和比较目的。
    private static final String ALT_STRATEGY_PROPERY_KEY = "debug.velocitytracker.alt";

    //--------------------------Pointer State----------------------------//
    // 指针状态 我理解的是一条完整轨迹曲线的数据状态
    // 其中会记录一次运动轨迹曲线上从down--> move --> up 的点的信息
    public static class PointerState {
        // Trace of previous points.
        // 该数组容量会随着触摸点数的增加一直增长 只要保持在这个View内部
        private float[] mTraceX = new float[32];// x轨迹的点的坐标
        private float[] mTraceY = new float[32];// y轨迹的点的坐标
        // true:current 通过getPointerCoords 获取的点;
        // false:history 通过getHistoricalPointerCoords获取的点
        private boolean[] mTraceCurrent = new boolean[32];
        // 记录每个点的估计值
        private int mTraceCount;// 一次触摸事件的所有点的数量


        private float[] mEstimatorTraceX = new float[32];
        private float[] mEstimatorTraceY = new float[32];
        private boolean[] mEstimatorTraceCurrent = new boolean[32];
        private int mEstimatorTraceCount;


        // True if the pointer is down.
        private boolean mCurDown;

        // Most recent coordinates.
        // 坐标点的数据(这条轨迹曲线上的点的坐标信息都可以获取到)
        private PointerCoords mCoords = new PointerCoords();
        private int mToolType;// 触摸的工具

        // Most recent velocity.
        private float mXVelocity;// x轴速度
        private float mYVelocity;// y轴速度
        private float mAltXVelocity;
        private float mAltYVelocity;

        // Current bounding box, if any
        // 测试中发现这些变量一直是默认值
        private boolean mHasBoundingBox;
        private float mBoundingLeft;
        private float mBoundingTop;
        private float mBoundingRight;
        private float mBoundingBottom;

        // Position estimator. 位置估值器 通过VelocityTracker来获取
        private VelocityTracker.Estimator mEstimator = new VelocityTracker.Estimator();
        private VelocityTracker.Estimator mAltEstimator = new VelocityTracker.Estimator();

        public void clearTrace() {
            mTraceCount = 0;
            mEstimatorTraceCount = 0;
        }

        //添加一次MotionEvent事件的触摸点的轨迹 (只记录 Move & Up)
        public void addTrace(float x, float y, boolean current) {
            Log.d(TAG, " addTrace x= " + x + " y= " + y + " current= "
                    + current + " traceCount= " + mTraceCount);
            int traceCapacity = mTraceX.length;
            if (mTraceCount == traceCapacity) {//自动扩容
                traceCapacity *= 2;
                float[] newTraceX = new float[traceCapacity];
                System.arraycopy(mTraceX, 0, newTraceX, 0, mTraceCount);
                mTraceX = newTraceX;

                float[] newTraceY = new float[traceCapacity];
                System.arraycopy(mTraceY, 0, newTraceY, 0, mTraceCount);
                mTraceY = newTraceY;

                boolean[] newTraceCurrent = new boolean[traceCapacity];
                System.arraycopy(mTraceCurrent, 0, newTraceCurrent, 0, mTraceCount);
                mTraceCurrent = newTraceCurrent;

            }

            mTraceX[mTraceCount] = x;
            mTraceY[mTraceCount] = y;
            mTraceCurrent[mTraceCount] = current;
            mTraceCount += 1;
        }

        //添加一次MotionEvent事件的触摸点的轨迹 (只记录 Move & Up)
        public void addEstimatorTrace(float x, float y, boolean current) {
            Log.d(TAG, " addTrace Estimator x= " + x + " y= " + y + " current= "
                    + current + " traceCount= " + mEstimatorTraceCount);
            int traceCapacity = mEstimatorTraceX.length;
            if (mEstimatorTraceCount == traceCapacity) {//自动扩容
                traceCapacity *= 2;
                // estimator
                float[] newEstimatorTraceX = new float[traceCapacity];
                System.arraycopy(mEstimatorTraceX, 0, newEstimatorTraceX, 0, mEstimatorTraceCount);
                mEstimatorTraceX = newEstimatorTraceX;

                float[] newEstimatorTraceY = new float[traceCapacity];
                System.arraycopy(mEstimatorTraceY, 0, newEstimatorTraceY, 0, mEstimatorTraceCount);
                mEstimatorTraceY = newEstimatorTraceY;

                boolean[] newEstimatorCurrent = new boolean[traceCapacity];
                System.arraycopy(mEstimatorTraceCurrent, 0, newEstimatorCurrent, 0, mEstimatorTraceCount);
                mEstimatorTraceCurrent = newEstimatorCurrent;

            }
            mEstimatorTraceX[mEstimatorTraceCount] = x;
            mEstimatorTraceY[mEstimatorTraceCount] = y;
            mEstimatorTraceCurrent[mEstimatorTraceCount] = current;
            mEstimatorTraceCount += 1;
        }

        public String getTraceArray() {
            return "\nmTraceX=" + Arrays.toString(mTraceX) +
                    "\nmTraceY=" + Arrays.toString(mTraceY) +
                    "\nmTraceCurrent=" + Arrays.toString(mTraceCurrent);
        }

        public String getTraceArrayLength() {
            return "\nmTraceCount=" + mTraceCount +
                    "\nmTraceX=" + mTraceX.length +
                    "\nmTraceY=" + mTraceY.length +
                    "\nmTraceCurrent=" + mTraceCurrent.length;
        }

        public String getBounding() {
            return "\nmHasBoundingBox=" + mHasBoundingBox +
                    "\nmBoundingLeft=" + mBoundingLeft +
                    "\nmBoundingTop=" + mBoundingTop +
                    "\nmBoundingRight=" + mBoundingRight +
                    "\nmBoundingBottom=" + mBoundingBottom;
        }

        @Override
        public String toString() {
            return "PointerState{" +
                    ", mCurDown=" + mCurDown +
                    ", mCoords=" + mCoords +
                    ", mToolType=" + mToolType +
                    ", mXVelocity=" + mXVelocity +
                    ", mYVelocity=" + mYVelocity +
                    ", mAltXVelocity=" + mAltXVelocity +
                    ", mAltYVelocity=" + mAltYVelocity +
                    ", mEstimator=" + mEstimator +
                    ", mAltEstimator=" + mAltEstimator +
                    '}';
        }
    }
    //--------------------------PointerState----------------------------//

    //用来计算估计值的常量
    private final int ESTIMATE_PAST_POINTS = 4;//过去时间的4个点
    private final int ESTIMATE_FUTURE_POINTS = 2;//将来时间的2个点
    private final float ESTIMATE_INTERVAL = 0.02f;//间隔

    private final InputManager mIm;

    private final ViewConfiguration mVC;// UI中的常量
    private final Paint mTextPaint;//顶部状态栏的绘制字体
    private final Paint mTextBackgroundPaint;//状态栏的字体的背景
    private final Paint mTextLevelPaint;//
    private final Paint mPaint;
    private final Paint mCurrentPointPaint;//当前一次Move MotionEvent的最后一个点
    private final Paint mHistoryPointPaint;//当前一次Move MotionEvent的经过的所有点
    private final Paint mTargetPaint;// 十字准线
    private final Paint mPathPaint; // 触摸轨迹路径
    private final FontMetricsInt mTextMetrics = new FontMetricsInt();
    private int mHeaderBottom;
    private boolean mCurDown;
    private int mCurNumPointers;//当前触碰点的数量
    private int mMaxNumPointers;//最大触碰点的数量
    private int mActivePointerId;// 当前活跃的id of pointer
    private final ArrayList mPointers = new ArrayList<>();//轨迹曲线集合 子元素为一条轨迹曲线的状态数据对象
    private final PointerCoords mTempCoords = new PointerCoords();
    private final VelocityTracker.Estimator mTempEstimator = new VelocityTracker.Estimator();

    private final VelocityTracker mVelocityTracker;//速度追踪
    private final VelocityTracker mAltVelocityTracker;

    private final FasterStringBuilder mText = new FasterStringBuilder();

    private boolean mPrintCoords = true;

    public PLView(Context c) {
        super(c);
        setEnabled(true);
        setClickable(true);
        setFocusable(true);
        setFocusableInTouchMode(true);

        mIm = c.getSystemService(InputManager.class);

        mVC = ViewConfiguration.get(c);
        mTextPaint = new Paint();
        mTextPaint.setAntiAlias(true);
        mTextPaint.setTextSize(10 * getResources().getDisplayMetrics().density);
        mTextPaint.setARGB(255, 0, 0, 0);

        mTextBackgroundPaint = new Paint();
        mTextBackgroundPaint.setAntiAlias(false);
        mTextBackgroundPaint.setARGB(128, 255, 255, 255);

        mTextLevelPaint = new Paint();
        mTextLevelPaint.setAntiAlias(false);
        mTextLevelPaint.setARGB(192, 255, 0, 0);

        mPaint = new Paint();
        mPaint.setAntiAlias(true);
        mPaint.setARGB(255, 255, 255, 255);
        mPaint.setStyle(Paint.Style.STROKE);
        mPaint.setStrokeWidth(2);

        mCurrentPointPaint = new Paint();
        mCurrentPointPaint.setAntiAlias(true);
        mCurrentPointPaint.setARGB(255, 255, 0, 0);
        mCurrentPointPaint.setStyle(Paint.Style.STROKE);
        mCurrentPointPaint.setStrokeWidth(6);

        mHistoryPointPaint = new Paint();
        mHistoryPointPaint.setAntiAlias(true);
        mHistoryPointPaint.setARGB(255, 0, 150, 0);
        mHistoryPointPaint.setStyle(Paint.Style.STROKE);
        mHistoryPointPaint.setStrokeWidth(4);

        mTargetPaint = new Paint();
        mTargetPaint.setAntiAlias(true);
        mTargetPaint.setARGB(255, 0, 0, 192);

        mPathPaint = new Paint();
        mPathPaint.setAntiAlias(true);
        mPathPaint.setARGB(255, 0, 0, 0);
        mPathPaint.setStrokeWidth(2);

        mPaint.setStyle(Paint.Style.STROKE);
        mPaint.setStrokeWidth(1);

        PointerState ps = new PointerState();
        Log.d(TAG, " onPointerLocation create new " + ps.toString());
        mPointers.add(ps);
        mActivePointerId = 0;

        mVelocityTracker = VelocityTracker.obtain();

        String altStrategy = SystemProperties.get(ALT_STRATEGY_PROPERY_KEY);
        Log.d(TAG, " altStrategy " + (altStrategy != null ? altStrategy + " " + altStrategy.length() : "null"));
        if (altStrategy.length() != 0) {
            Log.d(TAG, "Comparing default velocity tracker strategy with " + altStrategy);
            mAltVelocityTracker = VelocityTracker.obtain(altStrategy);
        } else {
            mAltVelocityTracker = null;
        }
    }

    public void setPrintCoords(boolean state) {
        mPrintCoords = state;
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        mTextPaint.getFontMetricsInt(mTextMetrics);
        mHeaderBottom = -mTextMetrics.ascent + mTextMetrics.descent + 2;
        if (true) {
            Log.i(TAG, " onPointerLocation Metrics: ascent=" + mTextMetrics.ascent
                    + " descent=" + mTextMetrics.descent
                    + " leading=" + mTextMetrics.leading
                    + " top=" + mTextMetrics.top
                    + " bottom=" + mTextMetrics.bottom);
        }
    }

    // Draw an oval.  When angle is 0 radians, orients the major axis vertically,
    // angles less than or greater than 0 radians rotate the major axis left or right.
    // 画一个椭圆。当角度为0弧度时，将主轴垂直定向，小于或大于0弧度的角将主轴向左或向右旋转。
    private RectF mReusableOvalRect = new RectF();// 可重复使用的

    //绘制椭圆 接触点的椭圆
    private void drawOval(Canvas canvas, float x, float y, float major, float minor,
                          float angle, Paint paint) {
        canvas.save(Canvas.MATRIX_SAVE_FLAG);
        canvas.rotate((float) (angle * 180 / Math.PI), x, y);
        mReusableOvalRect.left = x - minor / 2;
        mReusableOvalRect.right = x + minor / 2;
        mReusableOvalRect.top = y - major / 2;
        mReusableOvalRect.bottom = y + major / 2;
        canvas.drawOval(mReusableOvalRect, paint);
        canvas.restore();
    }

    //从down-->move--->up(一次完整的运动轨迹曲线)
    //会向mPointers(运动轨迹曲线数据的集合)添加pointerState(一次运动轨迹曲线的数据)对象
    //从而完成对一次完整的运动轨迹曲线的描述 在对应的onDraw中绘制出轨迹
    @Override
    public void onPointerEvent(MotionEvent event) {
        Log.d(TAG, " view callback onPointerEvent " + getTagName(event));
        final int action = event.getAction();
        int pointersSize = mPointers.size();
        Log.d(TAG, " onPointerEvent NP origin pointers size " + pointersSize);
        //-----------------------Action Down----------------------------//
        if (action == MotionEvent.ACTION_DOWN
                || (action & MotionEvent.ACTION_MASK) == MotionEvent.ACTION_POINTER_DOWN) {
            //多点触控判断获取当前触控点索引(依次为手指触碰屏幕的点标记index,一个完整的触摸事件拥有相同的index)
            final int index = (action & MotionEvent.ACTION_POINTER_INDEX_MASK)
                    >> MotionEvent.ACTION_POINTER_INDEX_SHIFT; // will be 0 for down
            Log.d(TAG, " current point index " + index);
            if (action == MotionEvent.ACTION_DOWN) {// 没必要加入多指触摸的条件是因为用了for循环
                //从down事件开始 每次重置 pointers集合 中 pointerState某些状态
                for (int p = 0; p < pointersSize; p++) {// 轨迹曲线的数量
                    final PointerState ps = mPointers.get(p);
                    Log.d(TAG, " trace contain others " + ps.toString());
                    Log.d(TAG, " trace contain length " + ps.getTraceArrayLength());
                    Log.d(TAG, " trace contain bounding " + ps.getBounding());
                    Logger.longLogD(" trace contain array body ", ps.getTraceArray());
                    ps.clearTrace();
                    ps.mCurDown = false;
                }
                mCurDown = true;
                mCurNumPointers = 0;
                mMaxNumPointers = 0;
                mVelocityTracker.clear();
                if (mAltVelocityTracker != null) {
                    mAltVelocityTracker.clear();
                }
            }

            mCurNumPointers += 1;// 屏幕触摸轨迹曲线数量
            if (mMaxNumPointers < mCurNumPointers) {
                mMaxNumPointers = mCurNumPointers;
            }

            // 从屏幕上有接触点到没有接触点 系统会按照触摸的先后为每一个触摸点标记index
            // 每一个pointer 对应唯一的 index, 而index又对应唯一的pointerId
            // 可以通过这个唯一的pointerId 获取 data
            final int id = event.getPointerId(index);
            Log.d(TAG, " onPointerEvent NP ---- " + pointersSize + " getPointerId " + id);
            Log.d(TAG, " onPointerEvent mPointers.size before " + mPointers.size());
            // 大于一个触摸点的时候会进入while 循环体
            while (pointersSize <= id) {
                PointerState ps = new PointerState();
                mPointers.add(ps);
                pointersSize++;
            }
            Log.d(TAG, " onPointerEvent mPointers.size after " + mPointers.size());
            Log.d(TAG, "  id xxxx total size " + mPointers.size());
            Log.d(TAG, " onPointerEvent-->> mActivePointerId before " + mActivePointerId);
            Log.d(TAG, " onPointerEvent-->> pointerState.mCurDown " + mPointers.get(mActivePointerId).mCurDown);
            if (mActivePointerId < 0 || !mPointers.get(mActivePointerId).mCurDown) {
                mActivePointerId = id;
            }
            Log.d(TAG, " onPointerEvent mActivePointerId after " + mActivePointerId);
            final PointerState ps = mPointers.get(id);
            ps.mCurDown = true;
            InputDevice device = InputDevice.getDevice(event.getDeviceId());
            Log.d(TAG, " device xxxxx " + (device != null ? device.toString() : "null"));
            ps.mHasBoundingBox = device != null &&
                    device.getMotionRange(MotionEvent.AXIS_GENERIC_1) != null;
            Log.d(TAG, " onPointerEvent action down ps.mHasBoundingBox " + ps.mHasBoundingBox);
        }
        //-----------------------Action Down----------------------------//

        //------中间的Action Move------//
        Log.d(TAG, " onPointerEvent middle numS mCurNumPointers= " + mCurNumPointers + " mMaxNumPointers= " + mMaxNumPointers);

        //触摸点的数量
        final int pointerCountNI = event.getPointerCount();
        while (pointersSize < pointerCountNI){
            PointerState ps = new PointerState();
            mPointers.add(ps);
            pointersSize++;
        }

        Log.d(TAG, "onPointerEvent event.getPointerCount NI middle " + pointerCountNI);
        mVelocityTracker.addMovement(event);
        mVelocityTracker.computeCurrentVelocity(1);
        Log.d(TAG, "onPointerEvent mAltVelocity " + mAltVelocityTracker);
        if (mAltVelocityTracker != null) {
            mAltVelocityTracker.addMovement(event);
            mAltVelocityTracker.computeCurrentVelocity(1);
        }

        // 当次Move事件轨迹段中包含的经过点的数量 用来描述轨迹曲线的点
        final int N = event.getHistorySize();
        Log.d(TAG, "onPointerEvent----->>>>>> event.getHistorySize N " + N);
        for (int historyPos = 0; historyPos < N; historyPos++) {
            for (int i = 0; i < pointerCountNI; i++) {
                final int id = event.getPointerId(i);
                Log.d(TAG," id xxxx history ----> " + id + " size " + (mPointers.size()));
                if (id >= mPointers.size()) {
                    continue;
                }
                Log.d(TAG, "onPointerEvent Pointer history id " + id);
                final PointerState ps = mCurDown ? mPointers.get(id) : null;
                final PointerCoords coords = ps != null ? ps.mCoords : mTempCoords;
                final VelocityTracker.Estimator estimator = ps != null ? ps.mEstimator : mTempEstimator;

                //填充历史坐标
                event.getHistoricalPointerCoords(i, historyPos, coords);
//                if (mPrintCoords) {
//                    logCoords("onPointerEvent Pointer history ", action, i, coords, id, event);
//                }
//                Logger.longLogD(TAG, "onPointerEvent historyPos & NI " + ps);
                if (ps != null) {
                    // 历史轨迹的点标记为蓝色
                    // 把历史轨迹点装箱到pointerState的数组里
                    mVelocityTracker.getEstimator(id, estimator);
                    float eX = estimator.estimateX(0);
                    float eY = estimator.estimateY(0);
                    Log.d(TAG, " xxxxxxxx history \n实际坐标: " + coords.x + " " + coords.y
                            + "\n估计坐标: " + eX + " " + eY);
                    ps.addTrace(coords.x, coords.y, false);
                    ps.addEstimatorTrace(eX, eY, false);
                }
            }
        }
        for (int i = 0; i < pointerCountNI; i++) {
            final int id = event.getPointerId(i);
            Log.d(TAG," id xxxx current ----> " + id+ " size " + (mPointers.size()));
            if (id >= mPointers.size()) {
                continue;
            }
            final PointerState ps = mCurDown ? mPointers.get(id) : null;
            final PointerCoords coords = ps != null ? ps.mCoords : mTempCoords;
            final VelocityTracker.Estimator estimator = ps != null ? ps.mEstimator : mTempEstimator;
            //使用指定指针索引的指针坐标数据填充{@link PointerCoords}对象。
            event.getPointerCoords(i, coords);
//            if (mPrintCoords) {
//                logCoords("onPointerEvent Pointer current ", action, i, coords, id, event);
//            }
//            Logger.longLogD(TAG, "onPointerEvent only & NI " + ps);
            if (ps != null) {
                Log.d(TAG, "onPointerEvent only & NI addTrace " + coords.x + " " + coords.y + " true");
//                ps.addTrace(coords.x, coords.y, true);
                ps.mXVelocity = mVelocityTracker.getXVelocity(id);
                ps.mYVelocity = mVelocityTracker.getYVelocity(id);
                Log.d(TAG, " current pointer velocity " + ps.mXVelocity + " " + ps.mYVelocity);
                //计算估计值
                //使用指针过去的运动来预测未来的运动，获得指针运动的估计量
                //调用本地方法获取估计值0
                //之后用来绘制估计曲线
                //每次MoveEvent回调事件后 更新(实际最后绘制的是UP点的前后几个估计点构成的曲线)
                //其中up点就是对应的最后一次更新的 ps.mEstimato
                Log.d(TAG, "------------------->" + event.getAction());

                mVelocityTracker.getEstimator(id, estimator);
                float eX = estimator.estimateX(0);
                float eY = estimator.estimateY(0);
                Log.d(TAG, " xxxxxxxx current \n实际坐标: " + coords.x + " " + coords.y
                        + "\n估计坐标: " + eX + " " + eY);
                ps.addTrace(coords.x, coords.y, true);
                ps.addEstimatorTrace(eX, eY, true);
                Log.d(TAG, "onPointerEvent action middle mAltVelocity " + mAltVelocityTracker);
//                if (mAltVelocityTracker != null) {
//                    ps.mAltXVelocity = mAltVelocityTracker.getXVelocity(id);
//                    ps.mAltYVelocity = mAltVelocityTracker.getYVelocity(id);
//                    mAltVelocityTracker.getEstimator(id, ps.mAltEstimator);
//                }
//                ps.mToolType = event.getToolType(i);
//                Log.d(TAG, "onPointerEvent ps.mToolType " + ps.mToolType + " ps.mHasBoundingBox " + ps.mHasBoundingBox);
//                if (ps.mHasBoundingBox) {// it sames always false
//                    ps.mBoundingLeft = event.getAxisValue(MotionEvent.AXIS_GENERIC_1, i);
//                    ps.mBoundingTop = event.getAxisValue(MotionEvent.AXIS_GENERIC_2, i);
//                    ps.mBoundingRight = event.getAxisValue(MotionEvent.AXIS_GENERIC_3, i);
//                    ps.mBoundingBottom = event.getAxisValue(MotionEvent.AXIS_GENERIC_4, i);
//                }
            }
        }
        //-------Action Move----////
        //---------------------------Action Up----------------------------//
        if (action == MotionEvent.ACTION_UP
                || action == MotionEvent.ACTION_CANCEL
                || (action & MotionEvent.ACTION_MASK) == MotionEvent.ACTION_POINTER_UP) {
            final int index = (action & MotionEvent.ACTION_POINTER_INDEX_MASK)
                    >> MotionEvent.ACTION_POINTER_INDEX_SHIFT; // will be 0 for UP

            final int id = event.getPointerId(index);
            Log.d(TAG, "onPointerEvent action up id " + id + " NP " + pointersSize);
            if (id >= pointersSize) {
                Slog.wtf(TAG, "Got pointer ID out of bounds: id=" + id + " arraysize="
                        + pointersSize + " pointerindex=" + index
                        + " action=0x" + Integer.toHexString(action));
                return;
            }
            Log.d(TAG, "onPointerEvent action up mPointers.size " + mPointers.size());
            final PointerState ps = mPointers.get(id);
            ps.mCurDown = false;

            if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL) {
                mCurDown = false;
                mCurNumPointers = 0;
            } else {
                Log.d(TAG, "onPointerEvent not action up \nmCurNumPointers " + mCurNumPointers
                        + "\nmActivePointerId " + mActivePointerId
                        + "\nid " + id);
                mCurNumPointers -= 1;
                if (mActivePointerId == id) {
                    mActivePointerId = event.getPointerId(index == 0 ? 1 : 0);
                }
                Log.d(TAG, "onPointerEvent not action up addTrace " + Float.NaN + " " + Float.NaN + " false");
                //异常状态
                ps.addTrace(Float.NaN, Float.NaN, false);
                ps.addEstimatorTrace(Float.NaN, Float.NaN, false);
            }
        }
        //---------------------------Action Up----------------------------//
        invalidate();//重新绘制
    }

    @Override
    protected void onDraw(Canvas canvas) {
        final int w = getWidth();
        final int itemW = w / 7;
        final int base = -mTextMetrics.ascent + 1;
        final int bottom = mHeaderBottom;

        final int NP = mPointers.size();
        Log.d(TAG, " onDraw NP " + NP + " mActivePointerId " + mActivePointerId);
        // Labels
        if (mActivePointerId >= 0) {
            final PointerState ps = mPointers.get(mActivePointerId);

            canvas.drawRect(0, 0, itemW - 1, bottom, mTextBackgroundPaint);
            canvas.drawText(mText.clear()
                    .append("P: ").append(mCurNumPointers)
                    .append(" / ").append(mMaxNumPointers)
                    .toString(), 1, base, mTextPaint);

            final int N = ps.mTraceCount;
            Log.d(TAG, "onDraw ps.mTraceCount " + N);
            if ((mCurDown && ps.mCurDown) || N == 0) {
                // 手指一直贴着屏幕时 会绘制手指触摸屏幕的点的坐标
                canvas.drawRect(itemW, 0, (itemW * 2) - 1, bottom, mTextBackgroundPaint);
                canvas.drawText(mText.clear()
                        .append("X: ").append(ps.mCoords.x, 1)
                        .toString(), 1 + itemW, base, mTextPaint);
                canvas.drawRect(itemW * 2, 0, (itemW * 3) - 1, bottom, mTextBackgroundPaint);
                canvas.drawText(mText.clear()
                        .append("Y: ").append(ps.mCoords.y, 1)
                        .toString(), 1 + itemW * 2, base, mTextPaint);
            } else {
                //手指脱离屏幕后 会打印出起始到终止位置的偏移量
                float dx = ps.mTraceX[N - 1] - ps.mTraceX[0];
                float dy = ps.mTraceY[N - 1] - ps.mTraceY[0];
                canvas.drawRect(itemW, 0, (itemW * 2) - 1, bottom,
                        Math.abs(dx) < mVC.getScaledTouchSlop()
                                ? mTextBackgroundPaint : mTextLevelPaint);
                canvas.drawText(mText.clear()
                        .append("dX: ").append(dx, 1)
                        .toString(), 1 + itemW, base, mTextPaint);
                canvas.drawRect(itemW * 2, 0, (itemW * 3) - 1, bottom,
                        Math.abs(dy) < mVC.getScaledTouchSlop()
                                ? mTextBackgroundPaint : mTextLevelPaint);
                canvas.drawText(mText.clear()
                        .append("dY: ").append(dy, 1)
                        .toString(), 1 + itemW * 2, base, mTextPaint);
            }

            canvas.drawRect(itemW * 3, 0, (itemW * 4) - 1, bottom, mTextBackgroundPaint);
            canvas.drawText(mText.clear()
                    .append("Xv: ").append(ps.mXVelocity, 3)
                    .toString(), 1 + itemW * 3, base, mTextPaint);

            canvas.drawRect(itemW * 4, 0, (itemW * 5) - 1, bottom, mTextBackgroundPaint);
            canvas.drawText(mText.clear()
                    .append("Yv: ").append(ps.mYVelocity, 3)
                    .toString(), 1 + itemW * 4, base, mTextPaint);

            canvas.drawRect(itemW * 5, 0, (itemW * 6) - 1, bottom, mTextBackgroundPaint);
            canvas.drawRect(itemW * 5, 0, (itemW * 5) + (ps.mCoords.pressure * itemW) - 1,
                    bottom, mTextLevelPaint);
            canvas.drawText(mText.clear()
                    .append("Prs: ").append(ps.mCoords.pressure, 2)
                    .toString(), 1 + itemW * 5, base, mTextPaint);

            canvas.drawRect(itemW * 6, 0, w, bottom, mTextBackgroundPaint);
            canvas.drawRect(itemW * 6, 0, (itemW * 6) + (ps.mCoords.size * itemW) - 1,
                    bottom, mTextLevelPaint);
            canvas.drawText(mText.clear()
                    .append("Size: ").append(ps.mCoords.size, 2)
                    .toString(), 1 + itemW * 6, base, mTextPaint);
        }

        Log.d(TAG, "onDraw draw pointer trace NP " + NP);
        // Pointer trace.
        for (int p = 0; p < NP; p++) {
            final PointerState ps = mPointers.get(p);

            // Draw path.
            // 每次都会从最开始的那个点开始绘制到当前手指移动到的位置 一直到手指离开屏幕
            final int traceCount = ps.mTraceCount;
            final int estimatorTraceCount = ps.mEstimatorTraceCount;
            Log.d(TAG, " onDraw path ps.mTraceCount " + traceCount);
            float lastX = 0, lastY = 0;
            boolean haveLast = false;
            boolean drawn = false;
            mPaint.setARGB(255, 128, 255, 255);
            for (int i = 0; i < traceCount; i++) {
                float x = ps.mTraceX[i];
                float y = ps.mTraceY[i];
                Log.d(TAG, " ----->>>>>> " + x + " " + y);
                Log.d(TAG, "onDraw -- isNaN " + i + " isNaN " + (Float.isNaN(x)));
                if (Float.isNaN(x)) {
                    haveLast = false;
                    continue;
                }
                Log.d(TAG, "onDraw -- haveLast " + i + " haveLast " + haveLast);
                if (haveLast) {
                    //画出运动轨迹线
                    canvas.drawLine(lastX, lastY, x, y, mPathPaint);
                    //画出运动轨迹的点
                    final Paint paint = ps.mTraceCurrent[i] ? mCurrentPointPaint : mHistoryPointPaint;
                    canvas.drawPoint(lastX, lastY, paint);
                    drawn = true;
                    Log.d(TAG, " onDraw path ps.mTraceCount v " + i);
                    //绘制 1 ------ 最后一个点
                }
                lastX = x;
                lastY = y;
                haveLast = true;
            }
            Log.d(TAG, "onDraw drawn " + drawn);
            if (drawn) {
                float lx = 0, ly = 0;
                boolean haveLast_Estimater = false;
                // Draw movement estimate curve.
//                mPaint.setARGB(128, 128, 0, 128);
                mPaint.setARGB(255, 255, 95, 33);
//                mCurrentPointPaint.setARGB(255,);
//                mHistoryPointPaint.setARGB(255,);
                // 橙色的运动轨迹估计曲线
                // 绘制了手指离开屏幕前后几个点得到估计运动曲线
                // 每段OnMove回调后计算出的运动估计值
//                float lx = ps.mEstimator.estimateX(-ESTIMATE_PAST_POINTS * ESTIMATE_INTERVAL);
//                float ly = ps.mEstimator.estimateY(-ESTIMATE_PAST_POINTS * ESTIMATE_INTERVAL);
                //起始绘制time点是 -0.08f
                //进行[-3,2] 共6段直线的绘制
                // (-0.08,-0.06)(-0.06,-0.04)(-0.04,-0.02)(-0.02,0)(0,0.02)(0.02,0.04) 这些区间点都是时刻点
                // 0时刻就是对应的 一组事件最后的Up点记录
//                for (int i = -ESTIMATE_PAST_POINTS + 1; i <= ESTIMATE_FUTURE_POINTS; i++) {
//                    float x = ps.mEstimator.estimateX(i * ESTIMATE_INTERVAL);
//                    float y = ps.mEstimator.estimateY(i * ESTIMATE_INTERVAL);
//                    canvas.drawLine(lx, ly, x, y, mPaint);
//                    Log.d(TAG, " 轨迹估计曲线 " + " lx= " + lx + " ly=" + ly + " x= " + x + "y= " + y);
//                    lx = x;
//                    ly = y;
//                }
                for (int i = 0; i < estimatorTraceCount; i++) {
                    float x = ps.mEstimatorTraceX[i];
                    float y = ps.mEstimatorTraceY[i];
                    if (Float.isNaN(x)) {
                        haveLast_Estimater = false;
                        continue;
                    }
                    if (haveLast_Estimater) {
                        //画出运动轨迹线
                        canvas.drawLine(lx, ly, x, y, mPaint);
                        Log.d(TAG, " estimator== ly " + ly + " lx " + lx + " x " + x + " y " + y);
                        //画出运动轨迹的点
                        final Paint paint = ps.mTraceCurrent[i] ? mCurrentPointPaint : mHistoryPointPaint;
//                        canvas.drawPoint(lastX, lastY, paint);
                        //绘制 1 ------ 最后一个点
                    }
                    lx = x;
                    ly = y;
                    haveLast_Estimater = true;
                }

                // Draw velocity vector.
//                mPaint.setARGB(255, 255, 64, 128);
                mPaint.setARGB(255, 0, 0, 255);
                //蓝色的速度矢量直线
                float xVel = ps.mXVelocity * (1000 / 60); // pixel/ms * 1000 / 60 --> 未来16.67ms 经过的距离
                float yVel = ps.mYVelocity * (1000 / 60);
                canvas.drawLine(lastX, lastY, lastX + xVel, lastY + yVel, mPaint);

                Log.d(TAG, "xxxxxx xVel " + xVel + " yVel " + yVel);

//                // Draw alternate estimate. 目前没用 mAltVelocity null
//                Log.d(TAG,"onDraw Draw alternate estimate mAltVelocity " + mAltVelocity);
//                if (mAltVelocity != null) {
//                    mPaint.setARGB(128, 0, 128, 128);
//                    lx = ps.mAltEstimator.estimateX(-ESTIMATE_PAST_POINTS * ESTIMATE_INTERVAL);
//                    ly = ps.mAltEstimator.estimateY(-ESTIMATE_PAST_POINTS * ESTIMATE_INTERVAL);
//                    for (int i = -ESTIMATE_PAST_POINTS + 1; i <= ESTIMATE_FUTURE_POINTS; i++) {
//                        float x = ps.mAltEstimator.estimateX(i * ESTIMATE_INTERVAL);
//                        float y = ps.mAltEstimator.estimateY(i * ESTIMATE_INTERVAL);
//                        canvas.drawLine(lx, ly, x, y, mPaint);
//                        lx = x;
//                        ly = y;
//                    }
//
//                    mPaint.setARGB(255, 64, 255, 128);
//                    xVel = ps.mAltXVelocity * (1000 / 60);
//                    yVel = ps.mAltYVelocity * (1000 / 60);
//                    canvas.drawLine(lastX, lastY, lastX + xVel, lastY + yVel, mPaint);
//                }
            }
//            Log.d(TAG, "onDraw mCurDown " + (mCurDown && ps.mCurDown));
//            if (mCurDown && ps.mCurDown) {
//                //绘制十字准线 x y 轴
//                // Draw crosshairs.
//                //x轴
////                canvas.drawLine(0, ps.mCoords.y, getWidth(), ps.mCoords.y, mTargetPaint);
//                //y轴
////                canvas.drawLine(ps.mCoords.x, 0, ps.mCoords.x, getHeight(), mTargetPaint);
//
//                // Draw current point. 十字轴准星点
////                int pressureLevel = (int) (ps.mCoords.pressure * 255);
////                mPaint.setARGB(255, pressureLevel, 255, 255 - pressureLevel);
////                canvas.drawPoint(ps.mCoords.x, ps.mCoords.y, mPaint);
//
//                // Draw current touch ellipse.
////                mPaint.setARGB(255, pressureLevel, 255 - pressureLevel, 128);
////                drawOval(canvas, ps.mCoords.x, ps.mCoords.y, ps.mCoords.touchMajor,
////                        ps.mCoords.touchMinor, ps.mCoords.orientation, mPaint);
//
//                // Draw current tool ellipse.
////                mPaint.setARGB(255, pressureLevel, 128, 255 - pressureLevel);
////                drawOval(canvas, ps.mCoords.x, ps.mCoords.y, ps.mCoords.toolMajor,
////                        ps.mCoords.toolMinor, ps.mCoords.orientation, mPaint);
//
//                // Draw the orientation arrow.
////                float arrowSize = ps.mCoords.toolMajor * 0.7f;
////                if (arrowSize < 20) {
////                    arrowSize = 20;
////                }
////                mPaint.setARGB(255, pressureLevel, 255, 0);
////                float orientationVectorX = (float) (Math.sin(ps.mCoords.orientation)
////                        * arrowSize);
////                float orientationVectorY = (float) (-Math.cos(ps.mCoords.orientation)
////                        * arrowSize);
////                if (ps.mToolType == MotionEvent.TOOL_TYPE_STYLUS
////                        || ps.mToolType == MotionEvent.TOOL_TYPE_ERASER) {
////                    // Show full circle orientation.
////                    canvas.drawLine(ps.mCoords.x, ps.mCoords.y,
////                            ps.mCoords.x + orientationVectorX,
////                            ps.mCoords.y + orientationVectorY,
////                            mPaint);
////                } else {
////                    // Show half circle orientation.
////                    canvas.drawLine(
////                            ps.mCoords.x - orientationVectorX,
////                            ps.mCoords.y - orientationVectorY,
////                            ps.mCoords.x + orientationVectorX,
////                            ps.mCoords.y + orientationVectorY,
////                            mPaint);
////                }
//
//                // Draw the tilt point along the orientation arrow.
////                float tiltScale = (float) Math.sin(
////                        ps.mCoords.getAxisValue(MotionEvent.AXIS_TILT));
////                canvas.drawCircle(
////                        ps.mCoords.x + orientationVectorX * tiltScale,
////                        ps.mCoords.y + orientationVectorY * tiltScale,
////                        3.0f, mPaint);
//
//                // Draw the current bounding box
////                if (ps.mHasBoundingBox) {
////                    canvas.drawRect(ps.mBoundingLeft, ps.mBoundingTop,
////                            ps.mBoundingRight, ps.mBoundingBottom, mPaint);
////                }
//            }
        }
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        Log.d(TAG, "onPointerEvent----->>>>>> view callback onTouchEvent " + event.getAction());
//        printSamples(event);
        onPointerEvent(event);
        if (event.getAction() == MotionEvent.ACTION_DOWN && !isFocused()) {
            requestFocus();
        }
        return true;
    }

    private void printSamples(MotionEvent ev) {
        final int historySize = ev.getHistorySize();
        final int pointerCount = ev.getPointerCount();
        for (int h = 0; h < historySize; h++) {
            Log.d("macy777", "At time historyET " + ev.getHistoricalEventTime(h));
            for (int p = 0; p < pointerCount; p++) {
                Log.d("macy777", "  pointerId " +
                        ev.getPointerId(p) + " historyX "
                        + ev.getHistoricalX(p, h)
                        + " historyY " + ev.getHistoricalY(p, h));
            }
        }
        Log.d("macy777", "At time ET " + ev.getEventTime());
        for (int p = 0; p < pointerCount; p++) {
            Log.d("macy777", "  pointerId " +
                    ev.getPointerId(p) + " X " + ev.getX(p) + " Y " + ev.getY(p));
        }
    }

    @Override
    public boolean onGenericMotionEvent(MotionEvent event) {
        Log.d(TAG, " view callback onGenericMotionEvent ");
        final int source = event.getSource();
        if ((source & InputDevice.SOURCE_CLASS_POINTER) != 0) {
            onPointerEvent(event);
        } else if ((source & InputDevice.SOURCE_CLASS_JOYSTICK) != 0) {
            logMotionEvent("Joystick", event);
        } else if ((source & InputDevice.SOURCE_CLASS_POSITION) != 0) {
            logMotionEvent("Position", event);
        } else {
            logMotionEvent("Generic", event);
        }
        return true;
    }

    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        if (shouldLogKey(keyCode)) {
            final int repeatCount = event.getRepeatCount();
            if (repeatCount == 0) {
                Log.i(TAG, "Key Down: " + event);
            } else {
                Log.i(TAG, "Key Repeat #" + repeatCount + ": " + event);
            }
            return true;
        }
        return super.onKeyDown(keyCode, event);
    }

    @Override
    public boolean onKeyUp(int keyCode, KeyEvent event) {
        if (shouldLogKey(keyCode)) {
            Log.i(TAG, "Key Up: " + event);
            return true;
        }
        return super.onKeyUp(keyCode, event);
    }

    private static boolean shouldLogKey(int keyCode) {
        switch (keyCode) {
            case KeyEvent.KEYCODE_DPAD_UP:
            case KeyEvent.KEYCODE_DPAD_DOWN:
            case KeyEvent.KEYCODE_DPAD_LEFT:
            case KeyEvent.KEYCODE_DPAD_RIGHT:
            case KeyEvent.KEYCODE_DPAD_CENTER:
                return true;
            default:
                return KeyEvent.isGamepadButton(keyCode)
                        || KeyEvent.isModifierKey(keyCode);
        }
    }

    @Override
    public boolean onTrackballEvent(MotionEvent event) {
        Log.d(TAG, " view callback onTrackballEvent ");
        logMotionEvent("Trackball", event);
        return true;
    }

    @Override
    protected void onAttachedToWindow() {
        super.onAttachedToWindow();

        mIm.registerInputDeviceListener(this, getHandler());
        logInputDevices();
    }

    @Override
    protected void onDetachedFromWindow() {
        super.onDetachedFromWindow();

        mIm.unregisterInputDeviceListener(this);
    }

    @Override
    public void onInputDeviceAdded(int deviceId) {
        logInputDeviceState(deviceId, "Device Added");
    }

    @Override
    public void onInputDeviceChanged(int deviceId) {
        logInputDeviceState(deviceId, "Device Changed");
    }

    @Override
    public void onInputDeviceRemoved(int deviceId) {
        logInputDeviceState(deviceId, "Device Removed");
    }

    private void logInputDevices() {
        int[] deviceIds = InputDevice.getDeviceIds();
        for (int i = 0; i < deviceIds.length; i++) {
            logInputDeviceState(deviceIds[i], "Device Enumerated");
        }
    }

    private void logInputDeviceState(int deviceId, String state) {
        InputDevice device = mIm.getInputDevice(deviceId);
        if (device != null) {
            Log.i(TAG, state + ": " + device);
        } else {
            Log.i(TAG, state + ": " + deviceId);
        }
    }

    private void logMotionEvent(String type, MotionEvent event) {
        final int action = event.getAction();
        final int N = event.getHistorySize();
        final int NI = event.getPointerCount();
        for (int historyPos = 0; historyPos < N; historyPos++) {
            for (int i = 0; i < NI; i++) {
                final int id = event.getPointerId(i);
                event.getHistoricalPointerCoords(i, historyPos, mTempCoords);
                logCoords(type, action, i, mTempCoords, id, event);
            }
        }
        for (int i = 0; i < NI; i++) {
            final int id = event.getPointerId(i);
            event.getPointerCoords(i, mTempCoords);
            logCoords(type, action, i, mTempCoords, id, event);
        }
    }

    private void logCoords(String type, int action, int index,
                           MotionEvent.PointerCoords coords, int id, MotionEvent event) {
        final int toolType = event.getToolType(index);
        final int buttonState = event.getButtonState();
        final String prefix;
        switch (action & MotionEvent.ACTION_MASK) {
            case MotionEvent.ACTION_DOWN:
                prefix = "DOWN";
                break;
            case MotionEvent.ACTION_UP:
                prefix = "UP";
                break;
            case MotionEvent.ACTION_MOVE:
                prefix = "MOVE";
                break;
            case MotionEvent.ACTION_CANCEL:
                prefix = "CANCEL";
                break;
            case MotionEvent.ACTION_OUTSIDE:
                prefix = "OUTSIDE";
                break;
            case MotionEvent.ACTION_POINTER_DOWN:
                if (index == ((action & MotionEvent.ACTION_POINTER_INDEX_MASK)
                        >> MotionEvent.ACTION_POINTER_INDEX_SHIFT)) {
                    prefix = "DOWN";
                } else {
                    prefix = "MOVE";
                }
                break;
            case MotionEvent.ACTION_POINTER_UP:
                if (index == ((action & MotionEvent.ACTION_POINTER_INDEX_MASK)
                        >> MotionEvent.ACTION_POINTER_INDEX_SHIFT)) {
                    prefix = "UP";
                } else {
                    prefix = "MOVE";
                }
                break;
            case MotionEvent.ACTION_HOVER_MOVE:
                prefix = "HOVER MOVE";
                break;
            case MotionEvent.ACTION_HOVER_ENTER:
                prefix = "HOVER ENTER";
                break;
            case MotionEvent.ACTION_HOVER_EXIT:
                prefix = "HOVER EXIT";
                break;
            case MotionEvent.ACTION_SCROLL:
                prefix = "SCROLL";
                break;
            default:
                prefix = Integer.toString(action);
                break;
        }

        Log.i(TAG, mText.clear()
                .append(type).append(" id ").append(id + 1)
                .append(": ")
                .append(prefix)
                .append(" (").append(coords.x, 3).append(", ").append(coords.y, 3)
                .append(") Pressure=").append(coords.pressure, 3)
                .append(" Size=").append(coords.size, 3)
                .append(" TouchMajor=").append(coords.touchMajor, 3)
                .append(" TouchMinor=").append(coords.touchMinor, 3)
                .append(" ToolMajor=").append(coords.toolMajor, 3)
                .append(" ToolMinor=").append(coords.toolMinor, 3)
                .append(" Orientation=").append((float) (coords.orientation * 180 / Math.PI), 1)
                .append("deg")
                .append(" Tilt=").append((float) (
                        coords.getAxisValue(MotionEvent.AXIS_TILT) * 180 / Math.PI), 1)
                .append("deg")
                .append(" Distance=").append(coords.getAxisValue(MotionEvent.AXIS_DISTANCE), 1)
                .append(" VScroll=").append(coords.getAxisValue(MotionEvent.AXIS_VSCROLL), 1)
                .append(" HScroll=").append(coords.getAxisValue(MotionEvent.AXIS_HSCROLL), 1)
                .append(" BoundingBox=[(")
                .append(event.getAxisValue(MotionEvent.AXIS_GENERIC_1), 3)
                .append(", ").append(event.getAxisValue(MotionEvent.AXIS_GENERIC_2), 3).append(")")
                .append(", (").append(event.getAxisValue(MotionEvent.AXIS_GENERIC_3), 3)
                .append(", ").append(event.getAxisValue(MotionEvent.AXIS_GENERIC_4), 3)
                .append(")]")
                .append(" ToolType=").append(MotionEvent.toolTypeToString(toolType))
                .append(" ButtonState=").append(MotionEvent.buttonStateToString(buttonState))
                .toString());
    }

    //fdfdfsd
    private String getTagName(MotionEvent motionEvent) {
        int action = motionEvent.getAction();
        String prefix = "default";
        switch (action & MotionEvent.ACTION_MASK) {
            case MotionEvent.ACTION_DOWN:
                prefix = "DOWN";
                break;
            case MotionEvent.ACTION_UP:
                prefix = "UP";
                break;
            case MotionEvent.ACTION_MOVE:
                prefix = "MOVE";
                break;
            case MotionEvent.ACTION_CANCEL:
                prefix = "CANCEL";
                break;
            case MotionEvent.ACTION_OUTSIDE:
                prefix = "OUTSIDE";
                break;
            case MotionEvent.ACTION_POINTER_DOWN:
                prefix = "ACTION_POINTER_DOWN";
                break;
            case MotionEvent.ACTION_POINTER_UP:
                prefix = "ACTION_POINTER_UP";
                break;
            case MotionEvent.ACTION_HOVER_MOVE:
                prefix = "HOVER MOVE";
                break;
            case MotionEvent.ACTION_HOVER_ENTER:
                prefix = "HOVER ENTER";
                break;
            case MotionEvent.ACTION_HOVER_EXIT:
                prefix = "HOVER EXIT";
                break;
            case MotionEvent.ACTION_SCROLL:
                prefix = "SCROLL";
                break;
            default:
                prefix = Integer.toString(action);
                break;
        }
        return prefix;
    }

    // HACK
    // A quick and dirty string builder implementation optimized for GC.
    // Using String.format causes the application grind to a halt when
    // more than a couple of pointers are down due to the number of
    // temporary objects allocated while formatting strings for drawing or logging.
    private static final class FasterStringBuilder {
        private char[] mChars;
        private int mLength;

        public FasterStringBuilder() {
            mChars = new char[64];
        }

        public FasterStringBuilder clear() {
            mLength = 0;
            return this;
        }

        public FasterStringBuilder append(String value) {
            final int valueLength = value.length();
            final int index = reserve(valueLength);
            value.getChars(0, valueLength, mChars, index);
            mLength += valueLength;
            return this;
        }

        public FasterStringBuilder append(int value) {
            return append(value, 0);
        }

        public FasterStringBuilder append(int value, int zeroPadWidth) {
            final boolean negative = value < 0;
            if (negative) {
                value = -value;
                if (value < 0) {
                    append("-2147483648");
                    return this;
                }
            }

            int index = reserve(11);
            final char[] chars = mChars;

            if (value == 0) {
                chars[index++] = '0';
                mLength += 1;
                return this;
            }

            if (negative) {
                chars[index++] = '-';
            }

            int divisor = 1000000000;
            int numberWidth = 10;
            while (value < divisor) {
                divisor /= 10;
                numberWidth -= 1;
                if (numberWidth < zeroPadWidth) {
                    chars[index++] = '0';
                }
            }

            do {
                int digit = value / divisor;
                value -= digit * divisor;
                divisor /= 10;
                chars[index++] = (char) (digit + '0');
            } while (divisor != 0);

            mLength = index;
            return this;
        }

        public FasterStringBuilder append(float value, int precision) {
            int scale = 1;
            for (int i = 0; i < precision; i++) {
                scale *= 10;
            }
            value = (float) (Math.rint(value * scale) / scale);

            append((int) value);

            if (precision != 0) {
                append(".");
                value = Math.abs(value);
                value -= Math.floor(value);
                append((int) (value * scale), precision);
            }

            return this;
        }

        @Override
        public String toString() {
            return new String(mChars, 0, mLength);
        }

        private int reserve(int length) {
            final int oldLength = mLength;
            final int newLength = mLength + length;
            final char[] oldChars = mChars;
            final int oldCapacity = oldChars.length;
            if (newLength > oldCapacity) {
                final int newCapacity = oldCapacity * 2;
                final char[] newChars = new char[newCapacity];
                System.arraycopy(oldChars, 0, newChars, 0, oldLength);
                mChars = newChars;
            }
            return oldLength;
        }
    }
}