Introduction Android Input of Pointer Location

if (mCurDown && ps.mCurDown) {
    // 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);
}

final int N = event.getHistorySize();
// historical点可能不止一个或0个
for (int historyPos = 0; historyPos < N; historyPos++) {
    for (int i = 0; i < NI; i++) {
        final int id = event.getPointerId(i);
        final PointerState ps = mCurDown ? mPointers.get(id) : null;
        final PointerCoords coords = ps != null ? ps.mCoords : mTempCoords;
        event.getHistoricalPointerCoords(i, historyPos, coords);
        if (mPrintCoords) {
            logCoords("Pointer", action, i, coords, id, event);
        }
        if (ps != null) {
            // 将historical点加入trace，注意false代表的就是historical点
            ps.addTrace(coords.x, coords.y, false);
        }
    }
}

for (int i = 0; i < NI; i++) {
    final int id = event.getPointerId(i);
    final PointerState ps = mCurDown ? mPointers.get(id) : null;
    final PointerCoords coords = ps != null ? ps.mCoords : mTempCoords;
    event.getPointerCoords(i, coords);

if (ps != null) {
    // 将当前点加入trace，true代表当前点。注意每个pointer只执行一次
        ps.addTrace(coords.x, coords.y, true);
        ps.mXVelocity = mVelocity.getXVelocity(id);
        ps.mYVelocity = mVelocity.getYVelocity(id);
        mVelocity.getEstimator(id, ps.mEstimator);
        ps.mToolType = event.getToolType(i);
    }
}

// Pointer trace.
for (int p = 0; p < NP; p++) {
    final PointerState ps = mPointers.get(p);
    // Draw path.
    final int N = ps.mTraceCount;
    float lastX = 0, lastY = 0;
    boolean haveLast = false;
    boolean drawn = false;
    mPaint.setARGB(255, 128, 255, 255);     // light blue
    for (int i=0; i < N; i++) {
        float x = ps.mTraceX[i];
        float y = ps.mTraceY[i];
        if (Float.isNaN(x)) {
            haveLast = false;
            continue;
        }
        if (haveLast) {
            canvas.drawLine(lastX, lastY, x, y, mPathPaint);
            final Paint paint = ps.mTraceCurrent[i] ? mCurrentPointPaint : mPaint;
            canvas.drawPoint(lastX, lastY, paint);
            drawn = true;
        }
        lastX = x;
        lastY = y;
        haveLast = true;
    }

if (mCurDown && ps.mCurDown) {
// Draw crosshairs.
// ps.mCoords就是当前点的坐标属性
    canvas.drawLine(0, ps.mCoords.y, getWidth(), ps.mCoords.y, mTargetPaint);
    canvas.drawLine(ps.mCoords.x, 0, ps.mCoords.x, getHeight(), mTargetPaint);
}

if (mCurDown && ps.mCurDown) {
    // 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);
}

if (mCurDown && ps.mCurDown) {
    // 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);
    }
}

if (ps != null) {
    ps.addTrace(coords.x, coords.y, true);
    ps.mXVelocity = mVelocity.getXVelocity(id);
    ps.mYVelocity = mVelocity.getYVelocity(id);
    mVelocity.getEstimator(id, ps.mEstimator);
    ps.mToolType = event.getToolType(i);
}

if (drawn) {
    // Draw velocity vector.
    mPaint.setARGB(255, 255, 64, 128);      // pink
    float xVel = ps.mXVelocity * (1000 / 60);
    float yVel = ps.mYVelocity * (1000 / 60);
    canvas.drawLine(lastX, lastY, lastX + xVel, lastY + yVel, mPaint);
}

mVelocity.getEstimator(id, ps.mEstimator);

if (drawn) {
    // Draw movement estimate curve.
    mPaint.setARGB(128, 128, 0, 128);       // dark pink
    float lx = ps.mEstimator.estimateX(-ESTIMATE_PAST_POINTS * ESTIMATE_INTERVAL);
    float ly = ps.mEstimator.estimateY(-ESTIMATE_PAST_POINTS * ESTIMATE_INTERVAL);
    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);
        lx = x;
        ly = y;
    }
}

/**
 * Window type: secure system overlay windows, which need to be displayed
 * on top of everything else.  These windows must not take input
 * focus, or they will interfere with the keyguard.
 *
 * This is exactly like {@link #TYPE_SYSTEM_OVERLAY} except that only the
 * system itself is allowed to create these overlays.  Applications cannot
 * obtain permission to create secure system overlays.
 *
 * In multiuser systems shows only on the owning user's window.
 * @hide
 */
public static final int TYPE_SECURE_SYSTEM_OVERLAY = FIRST_SYSTEM_WINDOW+15;

if (action == MotionEvent.ACTION_UP
        || action == MotionEvent.ACTION_CANCEL) {
    mCurDown = false;
    mCurNumPointers = 0;
} else {
    mCurNumPointers -= 1;
if (mActivePointerId == id) {
    // 这里就是active pointer切换的代码
        mActivePointerId = event.getPointerId(index == 0 ? 1 : 0);
    }
    ps.addTrace(Float.NaN, Float.NaN, false);
}

public void clearTrace() {
    mTraceCount = 0;
}
public void addTrace(float x, float y, boolean current) {
    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;
  }
}

if (action == MotionEvent.ACTION_DOWN) {
    for (int p=0; p<NP; p++) {
        final PointerState ps = mPointers.get(p);
        ps.clearTrace();
        ps.mCurDown = false;
    }
    mCurDown = true;
    mCurNumPointers = 0;
    mMaxNumPointers = 0;
    mVelocity.clear();
    if (mAltVelocity != null) {
        mAltVelocity.clear();
    }
}

// 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;

// 显示字符的长度，并不是通过mChars.length来确定
    private int mLength;
    public FasterStringBuilder() {
        mChars = new char[64];
}
// 清除并不会清除mChars里的内容，而是将字符的长度置空
    public FasterStringBuilder clear() {
        mLength = 0;
        return this;
}
// 如果添加的是string类型直接用getChars()方法将string拷入mChars
// reserve()方法是用来当mChars容量满后扩充容量的
    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;
}
// 添加int类型，zeroPadWidth是总长度，如果value不足首位用0补
    public FasterStringBuilder append(int value, int zeroPadWidth) {
        final boolean negative = value < 0;
        if (negative) {
            value = - value;
        // 如果value超出int字节最大限制，则直接返回二进制26个0的int值
            if (value < 0) {
                append("-2147483648");
                return this;
            }
        }
      // 上个判断之后value总为正值
        int index = reserve(11);
        final char[] chars = mChars;
     // 如果value是0特殊值就直接处理
        if (value == 0) {
            chars[index++] = '0';
            mLength += 1;
            return this;
        }
        if (negative) {
            chars[index++] = '-';
        }
     // 根据zeroPadWidth的大小为整数前面加0
        int divisor = 1000000000;
        int numberWidth = 10;
        while (value < divisor) {
            divisor /= 10;
            numberWidth -= 1;
            if (numberWidth < zeroPadWidth) {
                chars[index++] = '0';
            }
        }
      // 将整数拆分存入chars[]中
        do {
            int digit = value / divisor;
            value -= digit * divisor;
            divisor /= 10;
        // 存储的是数字的ASCii码，所以用0的ASCii码加任意字符就是该字
            chars[index++] = (char) (digit + '0');
        } while (divisor != 0);
        mLength = index;
        return this;
}
// 添加float类型，precision是小数点后的精度值
    public FasterStringBuilder append(float value, int precision) {
        int scale = 1;
        for (int i = 0; i < precision; i++) {
            scale *= 10;
        }
     // rint()方法：四舍五入，小数点后为0
     // 相当于只保存precision精度范围内的值，大于精度范围的值被四舍五入掉
        value = (float) (Math.rint(value * scale) / scale);
        append((int) value);       // 只写入整数部分到char[]中
        if (precision != 0) {
            append(".");
        // 要写小数部分，故去掉正负号
            value = Math.abs(value);
        // floor()：返回小于等于x，且与x最接近的整数
        // 相当于只留下小数部分
            value -= Math.floor(value);
            append((int) (value * scale), precision);
        }
        return this;
    }
    @Override
    public String toString() {
        return new String(mChars, 0, mLength);
}
// 该方法判断mChars是否还能存入长度为length的字符。如果不能重新new
// 一个double长度的char[]保存所有字符
    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;
    }
}