Merge "Revert "An optimization for Pointer Location for drawing the trace"" into main

package com.android.internal.widget;

import static java.lang.Float.NaN;

import android.compat.annotation.UnsupportedAppUsage;

import android.content.Context;

import android.content.res.Configuration;

import android.graphics.Bitmap;

import android.graphics.Canvas;

import android.graphics.Color;

import android.graphics.Insets;

import android.graphics.Paint;

import android.graphics.Paint.FontMetricsInt;

import android.graphics.Path;

import android.graphics.PorterDuff;

import android.graphics.RectF;

import android.graphics.Region;

import android.hardware.input.InputManager;

    private static final PointerState EMPTY_POINTER_STATE = new PointerState();

    public static class PointerState {

        private float mCurrentX = NaN;

        private float mCurrentY = NaN;

        private float mPreviousX = NaN;

        private float mPreviousY = NaN;

        private float mFirstX = NaN;

        private float mFirstY = NaN;

        private boolean mPreviousPointIsHistorical;

        private boolean mCurrentPointIsHistorical;

        // Trace of previous points.

        private float[] mTraceX = new float[32];

        private float[] mTraceY = new float[32];

        private boolean[] mTraceCurrent = new boolean[32];

        private int mTraceCount;

        // True if the pointer is down.

        @UnsupportedAppUsage

        public PointerState() {

        }

        public void addTrace(float x, float y, boolean isHistorical) {

            if (Float.isNaN(mFirstX)) {

                mFirstX = x;

        public void clearTrace() {

            mTraceCount = 0;

        }

            if (Float.isNaN(mFirstY)) {

                mFirstY = y;

        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;

            }

            mPreviousX = mCurrentX;

            mPreviousY = mCurrentY;

            mCurrentX = x;

            mCurrentY = y;

            mPreviousPointIsHistorical = mCurrentPointIsHistorical;

            mCurrentPointIsHistorical = isHistorical;

            mTraceX[mTraceCount] = x;

            mTraceY[mTraceCount] = y;

            mTraceCurrent[mTraceCount] = current;

            mTraceCount += 1;

        }

    }

    private final SparseArray<PointerState> mPointers = new SparseArray<PointerState>();

    private final PointerCoords mTempCoords = new PointerCoords();

    // Draw the trace of all pointers in the current gesture in a separate layer

    // that is not cleared on every frame so that we don't have to re-draw the

    // entire trace on each frame.

    private final Bitmap mTraceBitmap;

    private final Canvas mTraceCanvas;

    private final Region mSystemGestureExclusion = new Region();

    private final Region mSystemGestureExclusionRejected = new Region();

    private final Path mSystemGestureExclusionPath = new Path();

        mPathPaint.setARGB(255, 0, 96, 255);

        mPathPaint.setStyle(Paint.Style.STROKE);

        mTraceBitmap = Bitmap.createBitmap(getResources().getDisplayMetrics().widthPixels,

                getResources().getDisplayMetrics().heightPixels, Bitmap.Config.ARGB_8888);

        mTraceCanvas = new Canvas(mTraceBitmap);

        configureDensityDependentFactors();

        mSystemGestureExclusionPaint = new Paint();

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

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

    protected void onDraw(Canvas canvas) {

        final int NP = mPointers.size();

        canvas.drawBitmap(mTraceBitmap, 0, 0, null);

        if (!mSystemGestureExclusion.isEmpty()) {

            mSystemGestureExclusionPath.reset();

            mSystemGestureExclusion.getBoundaryPath(mSystemGestureExclusionPath);

        // Pointer trace.

        for (int p = 0; p < NP; p++) {

            final PointerState ps = mPointers.valueAt(p);

            float lastX = ps.mCurrentX, lastY = ps.mCurrentY;

            if (!Float.isNaN(lastX) && !Float.isNaN(lastY)) {

            // Draw path.

            final int N = ps.mTraceCount;

            float lastX = 0, lastY = 0;

            boolean haveLast = false;

            boolean drawn = false;

            mPaint.setARGB(255, 128, 255, 255);

            for (int i=0; i < N; i++) {

                float x = ps.mTraceX[i];

                float y = ps.mTraceY[i];

                if (Float.isNaN(x) || Float.isNaN(y)) {

                    haveLast = false;

                    continue;

                }

                if (haveLast) {

                    canvas.drawLine(lastX, lastY, x, y, mPathPaint);

                    final Paint paint = ps.mTraceCurrent[i - 1] ? mCurrentPointPaint : mPaint;

                    canvas.drawPoint(lastX, lastY, paint);

                    drawn = true;

                }

                lastX = x;

                lastY = y;

                haveLast = true;

            }

            if (drawn) {

                // Draw velocity vector.

                mPaint.setARGB(255, 255, 64, 128);

                float xVel = ps.mXVelocity * (1000 / 60);

                .append(" / ").append(mMaxNumPointers)

                .toString(), 1, base, mTextPaint);

        if ((mCurDown && ps.mCurDown) || Float.isNaN(ps.mCurrentX)) {

        final int count = ps.mTraceCount;

        if ((mCurDown && ps.mCurDown) || count == 0) {

            canvas.drawRect(itemW, mHeaderPaddingTop, (itemW * 2) - 1, bottom,

                    mTextBackgroundPaint);

            canvas.drawText(mText.clear()

                    .append("Y: ").append(ps.mCoords.y, 1)

                    .toString(), 1 + itemW * 2, base, mTextPaint);

        } else {

            float dx = ps.mCurrentX - ps.mFirstX;

            float dy = ps.mCurrentY - ps.mFirstY;

            float dx = ps.mTraceX[count - 1] - ps.mTraceX[0];

            float dy = ps.mTraceY[count - 1] - ps.mTraceY[0];

            canvas.drawRect(itemW, mHeaderPaddingTop, (itemW * 2) - 1, bottom,

                    Math.abs(dx) < mVC.getScaledTouchSlop()

                            ? mTextBackgroundPaint : mTextLevelPaint);

                mCurNumPointers = 0;

                mMaxNumPointers = 0;

                mVelocity.clear();

                mTraceCanvas.drawColor(Color.TRANSPARENT, PorterDuff.Mode.CLEAR);

                if (mAltVelocity != null) {

                    mAltVelocity.clear();

                }

                    logCoords("Pointer", action, i, coords, id, event);

                }

                if (ps != null) {

                    ps.addTrace(coords.x, coords.y, true);

                    updateDrawTrace(ps);

                    ps.addTrace(coords.x, coords.y, false);

                }

            }

        }

                logCoords("Pointer", action, i, coords, id, event);

            }

            if (ps != null) {

                ps.addTrace(coords.x, coords.y, false);

                updateDrawTrace(ps);

                ps.addTrace(coords.x, coords.y, true);

                ps.mXVelocity = mVelocity.getXVelocity(id);

                ps.mYVelocity = mVelocity.getYVelocity(id);

                if (mAltVelocity != null) {

                if (mActivePointerId == id) {

                    mActivePointerId = event.getPointerId(index == 0 ? 1 : 0);

                }

                ps.addTrace(Float.NaN, Float.NaN, true);

                ps.addTrace(Float.NaN, Float.NaN, false);

            }

        }

        invalidate();

    }

    private void updateDrawTrace(PointerState ps) {

        mPaint.setARGB(255, 128, 255, 255);

        float x = ps.mCurrentX;

        float y = ps.mCurrentY;

        float lastX = ps.mPreviousX;

        float lastY = ps.mPreviousY;

        if (!Float.isNaN(x) && !Float.isNaN(y) && !Float.isNaN(lastX) && !Float.isNaN(lastY)) {

            mTraceCanvas.drawLine(lastX, lastY, x, y, mPathPaint);

            Paint paint = ps.mPreviousPointIsHistorical ? mPaint : mCurrentPointPaint;

            mTraceCanvas.drawPoint(lastX, lastY, paint);

        }

    }

    @Override

    public boolean onTouchEvent(MotionEvent event) {

        onPointerEvent(event);

    private ISystemGestureExclusionListener mSystemGestureExclusionListener =

            new ISystemGestureExclusionListener.Stub() {

        @Override

                public void onSystemGestureExclusionChanged(int displayId,

                        Region systemGestureExclusion,

        public void onSystemGestureExclusionChanged(int displayId, Region systemGestureExclusion,

                Region systemGestureExclusionUnrestricted) {

            Region exclusion = Region.obtain(systemGestureExclusion);

            Region rejected = Region.obtain();