core/java/android/accessibilityservice/GestureDescription.java - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2015 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.
  */

 package android.accessibilityservice;

 import android.annotation.IntRange;
 import android.annotation.NonNull;
 import android.graphics.Path;
 import android.graphics.PathMeasure;
 import android.graphics.RectF;
 import android.view.InputDevice;
 import android.view.MotionEvent;
 import android.view.MotionEvent.PointerCoords;
 import android.view.MotionEvent.PointerProperties;

 import java.util.ArrayList;
 import java.util.List;

 /**
  * Accessibility services with the
  * {@link android.R.styleable#AccessibilityService_canPerformGestures} property can dispatch
  * gestures. This class describes those gestures. Gestures are made up of one or more strokes.
  * Gestures are immutable once built.
  * <p>
  * Spatial dimensions throughout are in screen pixels. Time is measured in milliseconds.
  */
 public final class GestureDescription {
     /** Gestures may contain no more than this many strokes */
     private static final int MAX_STROKE_COUNT = 10;

     /**
      * Upper bound on total gesture duration. Nearly all gestures will be much shorter.
      */
     private static final long MAX_GESTURE_DURATION_MS = 60 * 1000;

     private final List<StrokeDescription> mStrokes = new ArrayList<>();
     private final float[] mTempPos = new float[2];

     /**
      * Get the upper limit for the number of strokes a gesture may contain.
      *
      * @return The maximum number of strokes.
      */
     public static int getMaxStrokeCount() {
         return MAX_STROKE_COUNT;
     }

     /**
      * Get the upper limit on a gesture's duration.
      *
      * @return The maximum duration in milliseconds.
      */
     public static long getMaxGestureDuration() {
         return MAX_GESTURE_DURATION_MS;
     }

     private GestureDescription() {}

     private GestureDescription(List<StrokeDescription> strokes) {
         mStrokes.addAll(strokes);
     }

     /**
      * Get the number of stroke in the gesture.
      *
      * @return the number of strokes in this gesture
      */
     public int getStrokeCount() {
         return mStrokes.size();
     }

     /**
      * Read a stroke from the gesture
      *
      * @param index the index of the stroke
      *
      * @return A description of the stroke.
      */
     public StrokeDescription getStroke(@IntRange(from = 0) int index) {
         return mStrokes.get(index);
     }

     /**
      * Return the smallest key point (where a path starts or ends) that is at least a specified
      * offset
      * @param offset the minimum start time
      * @return The next key time that is at least the offset or -1 if one can't be found
      */
     private long getNextKeyPointAtLeast(long offset) {
         long nextKeyPoint = Long.MAX_VALUE;
         for (int i = 0; i < mStrokes.size(); i++) {
             long thisStartTime = mStrokes.get(i).mStartTime;
             if ((thisStartTime < nextKeyPoint) && (thisStartTime >= offset)) {
                 nextKeyPoint = thisStartTime;
             }
             long thisEndTime = mStrokes.get(i).mEndTime;
             if ((thisEndTime < nextKeyPoint) && (thisEndTime >= offset)) {
                 nextKeyPoint = thisEndTime;
             }
         }
         return (nextKeyPoint == Long.MAX_VALUE) ? -1L : nextKeyPoint;
     }

     /**
      * Get the points that correspond to a particular moment in time.
      * @param time The time of interest
      * @param touchPoints An array to hold the current touch points. Must be preallocated to at
      * least the number of paths in the gesture to prevent going out of bounds
      * @return The number of points found, and thus the number of elements set in each array
      */
     private int getPointsForTime(long time, TouchPoint[] touchPoints) {
         int numPointsFound = 0;
         for (int i = 0; i < mStrokes.size(); i++) {
             StrokeDescription strokeDescription = mStrokes.get(i);
             if (strokeDescription.hasPointForTime(time)) {
                 touchPoints[numPointsFound].mPathIndex = i;
                 touchPoints[numPointsFound].mIsStartOfPath = (time == strokeDescription.mStartTime);
                 touchPoints[numPointsFound].mIsEndOfPath = (time == strokeDescription.mEndTime);
                 strokeDescription.getPosForTime(time, mTempPos);
                 touchPoints[numPointsFound].mX = Math.round(mTempPos[0]);
                 touchPoints[numPointsFound].mY = Math.round(mTempPos[1]);
                 numPointsFound++;
             }
         }
         return numPointsFound;
     }

     // Total duration assumes that the gesture starts at 0; waiting around to start a gesture
     // counts against total duration
     private static long getTotalDuration(List<StrokeDescription> paths) {
         long latestEnd = Long.MIN_VALUE;
         for (int i = 0; i < paths.size(); i++) {
             StrokeDescription path = paths.get(i);
             latestEnd = Math.max(latestEnd, path.mEndTime);
         }
         return Math.max(latestEnd, 0);
     }

     /**
      * Builder for a {@code GestureDescription}
      */
     public static class Builder {

         private final List<StrokeDescription> mStrokes = new ArrayList<>();

         /**
          * Add a stroke to the gesture description. Up to
          * {@link GestureDescription#getMaxStrokeCount()} paths may be
          * added to a gesture, and the total gesture duration (earliest path start time to latest
          * path end time) may not exceed {@link GestureDescription#getMaxGestureDuration()}.
          *
          * @param strokeDescription the stroke to add.
          *
          * @return this
          */
         public Builder addStroke(@NonNull StrokeDescription strokeDescription) {
             if (mStrokes.size() >= MAX_STROKE_COUNT) {
                 throw new IllegalStateException(
                         "Attempting to add too many strokes to a gesture");
             }

             mStrokes.add(strokeDescription);

             if (getTotalDuration(mStrokes) > MAX_GESTURE_DURATION_MS) {
                 mStrokes.remove(strokeDescription);
                 throw new IllegalStateException(
                         "Gesture would exceed maximum duration with new stroke");
             }
             return this;
         }

         public GestureDescription build() {
             if (mStrokes.size() == 0) {
                 throw new IllegalStateException("Gestures must have at least one stroke");
             }
             return new GestureDescription(mStrokes);
         }
     }

     /**
      * Immutable description of stroke that can be part of a gesture.
      */
     public static class StrokeDescription {
         Path mPath;
         long mStartTime;
         long mEndTime;
         private float mTimeToLengthConversion;
         private PathMeasure mPathMeasure;
         // The tap location is only set for zero-length paths
         float[] mTapLocation;

         /**
          * @param path The path to follow. Must have exactly one contour. The bounds of the path
          * must not be negative. The path must not be empty. If the path has zero length
          * (for example, a single {@code moveTo()}), the stroke is a touch that doesn't move.
          * @param startTime The time, in milliseconds, from the time the gesture starts to the
          * time the stroke should start. Must not be negative.
          * @param duration The duration, in milliseconds, the stroke takes to traverse the path.
          * Must not be negative.
          */
         public StrokeDescription(@NonNull Path path,
                 @IntRange(from = 0) long startTime,
                 @IntRange(from = 0) long duration) {
             if (duration <= 0) {
                 throw new IllegalArgumentException("Duration must be positive");
             }
             if (startTime < 0) {
                 throw new IllegalArgumentException("Start time must not be negative");
             }
             RectF bounds = new RectF();
             path.computeBounds(bounds, false /* unused */);
             if ((bounds.bottom < 0) || (bounds.top < 0) || (bounds.right < 0)
                     || (bounds.left < 0)) {
                 throw new IllegalArgumentException("Path bounds must not be negative");
             }
             if (path.isEmpty()) {
                 throw new IllegalArgumentException("Path is empty");
             }
             mPath = new Path(path);
             mPathMeasure = new PathMeasure(path, false);
             if (mPathMeasure.getLength() == 0) {
                 // Treat zero-length paths as taps
                 Path tempPath = new Path(path);
                 tempPath.lineTo(-1, -1);
                 mTapLocation = new float[2];
                 PathMeasure pathMeasure = new PathMeasure(tempPath, false);
                 pathMeasure.getPosTan(0, mTapLocation, null);
             }
             if (mPathMeasure.nextContour()) {
                 throw new IllegalArgumentException("Path has more than one contour");
             }
             /*
              * Calling nextContour has moved mPathMeasure off the first contour, which is the only
              * one we care about. Set the path again to go back to the first contour.
              */
             mPathMeasure.setPath(mPath, false);
             mStartTime = startTime;
             mEndTime = startTime + duration;
             mTimeToLengthConversion = getLength() / duration;
         }

         /**
          * Retrieve a copy of the path for this stroke
          *
          * @return A copy of the path
          */
         public Path getPath() {
             return new Path(mPath);
         }

         /**
          * Get the stroke's start time
          *
          * @return the start time for this stroke.
          */
         public long getStartTime() {
             return mStartTime;
         }

         /**
          * Get the stroke's duration
          *
          * @return the duration for this stroke
          */
         public long getDuration() {
             return mEndTime - mStartTime;
         }

         float getLength() {
             return mPathMeasure.getLength();
         }

         /* Assumes hasPointForTime returns true */
         boolean getPosForTime(long time, float[] pos) {
             if (mTapLocation != null) {
                 pos[0] = mTapLocation[0];
                 pos[1] = mTapLocation[1];
                 return true;
             }
             if (time == mEndTime) {
                 // Close to the end time, roundoff can be a problem
                 return mPathMeasure.getPosTan(getLength(), pos, null);
             }
             float length = mTimeToLengthConversion * ((float) (time - mStartTime));
             return mPathMeasure.getPosTan(length, pos, null);
         }

         boolean hasPointForTime(long time) {
             return ((time >= mStartTime) && (time <= mEndTime));
         }
     }

     private static class TouchPoint {
         int mPathIndex;
         boolean mIsStartOfPath;
         boolean mIsEndOfPath;
         float mX;
         float mY;

         void copyFrom(TouchPoint other) {
             mPathIndex = other.mPathIndex;
             mIsStartOfPath = other.mIsStartOfPath;
             mIsEndOfPath = other.mIsEndOfPath;
             mX = other.mX;
             mY = other.mY;
         }
     }

     /**
      * Class to convert a GestureDescription to a series of MotionEvents.
      */
     static class MotionEventGenerator {
         /**
          * Constants used to initialize all MotionEvents
          */
         private static final int EVENT_META_STATE = 0;
         private static final int EVENT_BUTTON_STATE = 0;
         private static final int EVENT_DEVICE_ID = 0;
         private static final int EVENT_EDGE_FLAGS = 0;
         private static final int EVENT_SOURCE = InputDevice.SOURCE_TOUCHSCREEN;
         private static final int EVENT_FLAGS = 0;
         private static final float EVENT_X_PRECISION = 1;
         private static final float EVENT_Y_PRECISION = 1;

         /* Lazily-created scratch memory for processing touches */
         private static TouchPoint[] sCurrentTouchPoints;
         private static TouchPoint[] sLastTouchPoints;
         private static PointerCoords[] sPointerCoords;
         private static PointerProperties[] sPointerProps;

         static List<MotionEvent> getMotionEventsFromGestureDescription(
                 GestureDescription description, int sampleTimeMs) {
             final List<MotionEvent> motionEvents = new ArrayList<>();

             // Point data at each time we generate an event for
             final TouchPoint[] currentTouchPoints =
                     getCurrentTouchPoints(description.getStrokeCount());
             // Point data sent in last touch event
             int lastTouchPointSize = 0;
             final TouchPoint[] lastTouchPoints =
                     getLastTouchPoints(description.getStrokeCount());

             /* Loop through each time slice where there are touch points */
             long timeSinceGestureStart = 0;
             long nextKeyPointTime = description.getNextKeyPointAtLeast(timeSinceGestureStart);
             while (nextKeyPointTime >= 0) {
                 timeSinceGestureStart = (lastTouchPointSize == 0) ? nextKeyPointTime
                         : Math.min(nextKeyPointTime, timeSinceGestureStart + sampleTimeMs);
                 int currentTouchPointSize = description.getPointsForTime(timeSinceGestureStart,
                         currentTouchPoints);

                 appendMoveEventIfNeeded(motionEvents, lastTouchPoints, lastTouchPointSize,
                         currentTouchPoints, currentTouchPointSize, timeSinceGestureStart);
                 lastTouchPointSize = appendUpEvents(motionEvents, lastTouchPoints,
                         lastTouchPointSize, currentTouchPoints, currentTouchPointSize,
                         timeSinceGestureStart);
                 lastTouchPointSize = appendDownEvents(motionEvents, lastTouchPoints,
                         lastTouchPointSize, currentTouchPoints, currentTouchPointSize,
                         timeSinceGestureStart);

                 /* Move to next time slice */
                 nextKeyPointTime = description.getNextKeyPointAtLeast(timeSinceGestureStart + 1);
             }
             return motionEvents;
         }

         private static TouchPoint[] getCurrentTouchPoints(int requiredCapacity) {
             if ((sCurrentTouchPoints == null) || (sCurrentTouchPoints.length < requiredCapacity)) {
                 sCurrentTouchPoints = new TouchPoint[requiredCapacity];
                 for (int i = 0; i < requiredCapacity; i++) {
                     sCurrentTouchPoints[i] = new TouchPoint();
                 }
             }
             return sCurrentTouchPoints;
         }

         private static TouchPoint[] getLastTouchPoints(int requiredCapacity) {
             if ((sLastTouchPoints == null) || (sLastTouchPoints.length < requiredCapacity)) {
                 sLastTouchPoints = new TouchPoint[requiredCapacity];
                 for (int i = 0; i < requiredCapacity; i++) {
                     sLastTouchPoints[i] = new TouchPoint();
                 }
             }
             return sLastTouchPoints;
         }

         private static PointerCoords[] getPointerCoords(int requiredCapacity) {
             if ((sPointerCoords == null) || (sPointerCoords.length < requiredCapacity)) {
                 sPointerCoords = new PointerCoords[requiredCapacity];
                 for (int i = 0; i < requiredCapacity; i++) {
                     sPointerCoords[i] = new PointerCoords();
                 }
             }
             return sPointerCoords;
         }

         private static PointerProperties[] getPointerProps(int requiredCapacity) {
             if ((sPointerProps == null) || (sPointerProps.length < requiredCapacity)) {
                 sPointerProps = new PointerProperties[requiredCapacity];
                 for (int i = 0; i < requiredCapacity; i++) {
                     sPointerProps[i] = new PointerProperties();
                 }
             }
             return sPointerProps;
         }

         private static void appendMoveEventIfNeeded(List<MotionEvent> motionEvents,
                 TouchPoint[] lastTouchPoints, int lastTouchPointsSize,
                 TouchPoint[] currentTouchPoints, int currentTouchPointsSize, long currentTime) {
             /* Look for pointers that have moved */
             boolean moveFound = false;
             for (int i = 0; i < currentTouchPointsSize; i++) {
                 int lastPointsIndex = findPointByPathIndex(lastTouchPoints, lastTouchPointsSize,
                         currentTouchPoints[i].mPathIndex);
                 if (lastPointsIndex >= 0) {
                     moveFound |= (lastTouchPoints[lastPointsIndex].mX != currentTouchPoints[i].mX)
                             || (lastTouchPoints[lastPointsIndex].mY != currentTouchPoints[i].mY);
                     lastTouchPoints[lastPointsIndex].copyFrom(currentTouchPoints[i]);
                 }
             }

             if (moveFound) {
                 long downTime = motionEvents.get(motionEvents.size() - 1).getDownTime();
                 motionEvents.add(obtainMotionEvent(downTime, currentTime, MotionEvent.ACTION_MOVE,
                         lastTouchPoints, lastTouchPointsSize));
             }
         }

         private static int appendUpEvents(List<MotionEvent> motionEvents,
                 TouchPoint[] lastTouchPoints, int lastTouchPointsSize,
                 TouchPoint[] currentTouchPoints, int currentTouchPointsSize, long currentTime) {
             /* Look for a pointer at the end of its path */
             for (int i = 0; i < currentTouchPointsSize; i++) {
                 if (currentTouchPoints[i].mIsEndOfPath) {
                     int indexOfUpEvent = findPointByPathIndex(lastTouchPoints, lastTouchPointsSize,
                             currentTouchPoints[i].mPathIndex);
                     if (indexOfUpEvent < 0) {
                         continue; // Should not happen
                     }
                     long downTime = motionEvents.get(motionEvents.size() - 1).getDownTime();
                     int action = (lastTouchPointsSize == 1) ? MotionEvent.ACTION_UP
                             : MotionEvent.ACTION_POINTER_UP;
                     action |= indexOfUpEvent << MotionEvent.ACTION_POINTER_INDEX_SHIFT;
                     motionEvents.add(obtainMotionEvent(downTime, currentTime, action,
                             lastTouchPoints, lastTouchPointsSize));
                     /* Remove this point from lastTouchPoints */
                     for (int j = indexOfUpEvent; j < lastTouchPointsSize - 1; j++) {
                         lastTouchPoints[j].copyFrom(lastTouchPoints[j+1]);
                     }
                     lastTouchPointsSize--;
                 }
             }
             return lastTouchPointsSize;
         }

         private static int appendDownEvents(List<MotionEvent> motionEvents,
                 TouchPoint[] lastTouchPoints, int lastTouchPointsSize,
                 TouchPoint[] currentTouchPoints, int currentTouchPointsSize, long currentTime) {
             /* Look for a pointer that is just starting */
             for (int i = 0; i < currentTouchPointsSize; i++) {
                 if (currentTouchPoints[i].mIsStartOfPath) {
                     /* Add the point to last coords and use the new array to generate the event */
                     lastTouchPoints[lastTouchPointsSize++].copyFrom(currentTouchPoints[i]);
                     int action = (lastTouchPointsSize == 1) ? MotionEvent.ACTION_DOWN
                             : MotionEvent.ACTION_POINTER_DOWN;
                     long downTime = (action == MotionEvent.ACTION_DOWN) ? currentTime :
                             motionEvents.get(motionEvents.size() - 1).getDownTime();
                     action |= i << MotionEvent.ACTION_POINTER_INDEX_SHIFT;
                     motionEvents.add(obtainMotionEvent(downTime, currentTime, action,
                             lastTouchPoints, lastTouchPointsSize));
                 }
             }
             return lastTouchPointsSize;
         }

         private static MotionEvent obtainMotionEvent(long downTime, long eventTime, int action,
                 TouchPoint[] touchPoints, int touchPointsSize) {
             PointerCoords[] pointerCoords = getPointerCoords(touchPointsSize);
             PointerProperties[] pointerProperties = getPointerProps(touchPointsSize);
             for (int i = 0; i < touchPointsSize; i++) {
                 pointerProperties[i].id = touchPoints[i].mPathIndex;
                 pointerProperties[i].toolType = MotionEvent.TOOL_TYPE_UNKNOWN;
                 pointerCoords[i].clear();
                 pointerCoords[i].pressure = 1.0f;
                 pointerCoords[i].size = 1.0f;
                 pointerCoords[i].x = touchPoints[i].mX;
                 pointerCoords[i].y = touchPoints[i].mY;
             }
             return MotionEvent.obtain(downTime, eventTime, action, touchPointsSize,
                     pointerProperties, pointerCoords, EVENT_META_STATE, EVENT_BUTTON_STATE,
                     EVENT_X_PRECISION, EVENT_Y_PRECISION, EVENT_DEVICE_ID, EVENT_EDGE_FLAGS,
                     EVENT_SOURCE, EVENT_FLAGS);
         }

         private static int findPointByPathIndex(TouchPoint[] touchPoints, int touchPointsSize,
                 int pathIndex) {
             for (int i = 0; i < touchPointsSize; i++) {
                 if (touchPoints[i].mPathIndex == pathIndex) {
                     return i;
                 }
             }
             return -1;
         }
     }
 }
	/*
	* Copyright (C) 2015 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.
	*/

	package android.accessibilityservice;

	import android.annotation.IntRange;
	import android.annotation.NonNull;
	import android.graphics.Path;
	import android.graphics.PathMeasure;
	import android.graphics.RectF;
	import android.view.InputDevice;
	import android.view.MotionEvent;
	import android.view.MotionEvent.PointerCoords;
	import android.view.MotionEvent.PointerProperties;

	import java.util.ArrayList;
	import java.util.List;

	/**
	* Accessibility services with the
	* {@link android.R.styleable#AccessibilityService_canPerformGestures} property can dispatch
	* gestures. This class describes those gestures. Gestures are made up of one or more strokes.
	* Gestures are immutable once built.
	* <p>
	* Spatial dimensions throughout are in screen pixels. Time is measured in milliseconds.
	*/
	public final class GestureDescription {
	/** Gestures may contain no more than this many strokes */
	private static final int MAX_STROKE_COUNT = 10;

	/**
	* Upper bound on total gesture duration. Nearly all gestures will be much shorter.
	*/
	private static final long MAX_GESTURE_DURATION_MS = 60 * 1000;

	private final List<StrokeDescription> mStrokes = new ArrayList<>();
	private final float[] mTempPos = new float[2];

	/**
	* Get the upper limit for the number of strokes a gesture may contain.
	*
	* @return The maximum number of strokes.
	*/
	public static int getMaxStrokeCount() {
	return MAX_STROKE_COUNT;
	}

	/**
	* Get the upper limit on a gesture's duration.
	*
	* @return The maximum duration in milliseconds.
	*/
	public static long getMaxGestureDuration() {
	return MAX_GESTURE_DURATION_MS;
	}

	private GestureDescription() {}

	private GestureDescription(List<StrokeDescription> strokes) {
	mStrokes.addAll(strokes);
	}

	/**
	* Get the number of stroke in the gesture.
	*
	* @return the number of strokes in this gesture
	*/
	public int getStrokeCount() {
	return mStrokes.size();
	}

	/**
	* Read a stroke from the gesture
	*
	* @param index the index of the stroke
	*
	* @return A description of the stroke.
	*/
	public StrokeDescription getStroke(@IntRange(from = 0) int index) {
	return mStrokes.get(index);
	}

	/**
	* Return the smallest key point (where a path starts or ends) that is at least a specified
	* offset
	* @param offset the minimum start time
	* @return The next key time that is at least the offset or -1 if one can't be found
	*/
	private long getNextKeyPointAtLeast(long offset) {
	long nextKeyPoint = Long.MAX_VALUE;
	for (int i = 0; i < mStrokes.size(); i++) {
	long thisStartTime = mStrokes.get(i).mStartTime;
	if ((thisStartTime < nextKeyPoint) && (thisStartTime >= offset)) {
	nextKeyPoint = thisStartTime;
	}
	long thisEndTime = mStrokes.get(i).mEndTime;
	if ((thisEndTime < nextKeyPoint) && (thisEndTime >= offset)) {
	nextKeyPoint = thisEndTime;
	}
	}
	return (nextKeyPoint == Long.MAX_VALUE) ? -1L : nextKeyPoint;
	}

	/**
	* Get the points that correspond to a particular moment in time.
	* @param time The time of interest
	* @param touchPoints An array to hold the current touch points. Must be preallocated to at
	* least the number of paths in the gesture to prevent going out of bounds
	* @return The number of points found, and thus the number of elements set in each array
	*/
	private int getPointsForTime(long time, TouchPoint[] touchPoints) {
	int numPointsFound = 0;
	for (int i = 0; i < mStrokes.size(); i++) {
	StrokeDescription strokeDescription = mStrokes.get(i);
	if (strokeDescription.hasPointForTime(time)) {
	touchPoints[numPointsFound].mPathIndex = i;
	touchPoints[numPointsFound].mIsStartOfPath = (time == strokeDescription.mStartTime);
	touchPoints[numPointsFound].mIsEndOfPath = (time == strokeDescription.mEndTime);
	strokeDescription.getPosForTime(time, mTempPos);
	touchPoints[numPointsFound].mX = Math.round(mTempPos[0]);
	touchPoints[numPointsFound].mY = Math.round(mTempPos[1]);
	numPointsFound++;
	}
	}
	return numPointsFound;
	}

	// Total duration assumes that the gesture starts at 0; waiting around to start a gesture
	// counts against total duration
	private static long getTotalDuration(List<StrokeDescription> paths) {
	long latestEnd = Long.MIN_VALUE;
	for (int i = 0; i < paths.size(); i++) {
	StrokeDescription path = paths.get(i);
	latestEnd = Math.max(latestEnd, path.mEndTime);
	}
	return Math.max(latestEnd, 0);
	}

	/**
	* Builder for a {@code GestureDescription}
	*/
	public static class Builder {

	private final List<StrokeDescription> mStrokes = new ArrayList<>();

	/**
	* Add a stroke to the gesture description. Up to
	* {@link GestureDescription#getMaxStrokeCount()} paths may be
	* added to a gesture, and the total gesture duration (earliest path start time to latest
	* path end time) may not exceed {@link GestureDescription#getMaxGestureDuration()}.
	*
	* @param strokeDescription the stroke to add.
	*
	* @return this
	*/
	public Builder addStroke(@NonNull StrokeDescription strokeDescription) {
	if (mStrokes.size() >= MAX_STROKE_COUNT) {
	throw new IllegalStateException(
	"Attempting to add too many strokes to a gesture");
	}

	mStrokes.add(strokeDescription);

	if (getTotalDuration(mStrokes) > MAX_GESTURE_DURATION_MS) {
	mStrokes.remove(strokeDescription);
	throw new IllegalStateException(
	"Gesture would exceed maximum duration with new stroke");
	}
	return this;
	}

	public GestureDescription build() {
	if (mStrokes.size() == 0) {
	throw new IllegalStateException("Gestures must have at least one stroke");
	}
	return new GestureDescription(mStrokes);
	}
	}

	/**
	* Immutable description of stroke that can be part of a gesture.
	*/
	public static class StrokeDescription {
	Path mPath;
	long mStartTime;
	long mEndTime;
	private float mTimeToLengthConversion;
	private PathMeasure mPathMeasure;
	// The tap location is only set for zero-length paths
	float[] mTapLocation;

	/**
	* @param path The path to follow. Must have exactly one contour. The bounds of the path
	* must not be negative. The path must not be empty. If the path has zero length
	* (for example, a single {@code moveTo()}), the stroke is a touch that doesn't move.
	* @param startTime The time, in milliseconds, from the time the gesture starts to the
	* time the stroke should start. Must not be negative.
	* @param duration The duration, in milliseconds, the stroke takes to traverse the path.
	* Must not be negative.
	*/
	public StrokeDescription(@NonNull Path path,
	@IntRange(from = 0) long startTime,
	@IntRange(from = 0) long duration) {
	if (duration <= 0) {
	throw new IllegalArgumentException("Duration must be positive");
	}
	if (startTime < 0) {
	throw new IllegalArgumentException("Start time must not be negative");
	}
	RectF bounds = new RectF();
	path.computeBounds(bounds, false /* unused */);
	if ((bounds.bottom < 0) \|\| (bounds.top < 0) \|\| (bounds.right < 0)
	\|\| (bounds.left < 0)) {
	throw new IllegalArgumentException("Path bounds must not be negative");
	}
	if (path.isEmpty()) {
	throw new IllegalArgumentException("Path is empty");
	}
	mPath = new Path(path);
	mPathMeasure = new PathMeasure(path, false);
	if (mPathMeasure.getLength() == 0) {
	// Treat zero-length paths as taps
	Path tempPath = new Path(path);
	tempPath.lineTo(-1, -1);
	mTapLocation = new float[2];
	PathMeasure pathMeasure = new PathMeasure(tempPath, false);
	pathMeasure.getPosTan(0, mTapLocation, null);
	}
	if (mPathMeasure.nextContour()) {
	throw new IllegalArgumentException("Path has more than one contour");
	}
	/*
	* Calling nextContour has moved mPathMeasure off the first contour, which is the only
	* one we care about. Set the path again to go back to the first contour.
	*/
	mPathMeasure.setPath(mPath, false);
	mStartTime = startTime;
	mEndTime = startTime + duration;
	mTimeToLengthConversion = getLength() / duration;
	}

	/**
	* Retrieve a copy of the path for this stroke
	*
	* @return A copy of the path
	*/
	public Path getPath() {
	return new Path(mPath);
	}

	/**
	* Get the stroke's start time
	*
	* @return the start time for this stroke.
	*/
	public long getStartTime() {
	return mStartTime;
	}

	/**
	* Get the stroke's duration
	*
	* @return the duration for this stroke
	*/
	public long getDuration() {
	return mEndTime - mStartTime;
	}

	float getLength() {
	return mPathMeasure.getLength();
	}

	/* Assumes hasPointForTime returns true */
	boolean getPosForTime(long time, float[] pos) {
	if (mTapLocation != null) {
	pos[0] = mTapLocation[0];
	pos[1] = mTapLocation[1];
	return true;
	}
	if (time == mEndTime) {
	// Close to the end time, roundoff can be a problem
	return mPathMeasure.getPosTan(getLength(), pos, null);
	}
	float length = mTimeToLengthConversion * ((float) (time - mStartTime));
	return mPathMeasure.getPosTan(length, pos, null);
	}

	boolean hasPointForTime(long time) {
	return ((time >= mStartTime) && (time <= mEndTime));
	}
	}

	private static class TouchPoint {
	int mPathIndex;
	boolean mIsStartOfPath;
	boolean mIsEndOfPath;
	float mX;
	float mY;

	void copyFrom(TouchPoint other) {
	mPathIndex = other.mPathIndex;
	mIsStartOfPath = other.mIsStartOfPath;
	mIsEndOfPath = other.mIsEndOfPath;
	mX = other.mX;
	mY = other.mY;
	}
	}

	/**
	* Class to convert a GestureDescription to a series of MotionEvents.
	*/
	static class MotionEventGenerator {
	/**
	* Constants used to initialize all MotionEvents
	*/
	private static final int EVENT_META_STATE = 0;
	private static final int EVENT_BUTTON_STATE = 0;
	private static final int EVENT_DEVICE_ID = 0;
	private static final int EVENT_EDGE_FLAGS = 0;
	private static final int EVENT_SOURCE = InputDevice.SOURCE_TOUCHSCREEN;
	private static final int EVENT_FLAGS = 0;
	private static final float EVENT_X_PRECISION = 1;
	private static final float EVENT_Y_PRECISION = 1;

	/* Lazily-created scratch memory for processing touches */
	private static TouchPoint[] sCurrentTouchPoints;
	private static TouchPoint[] sLastTouchPoints;
	private static PointerCoords[] sPointerCoords;
	private static PointerProperties[] sPointerProps;

	static List<MotionEvent> getMotionEventsFromGestureDescription(
	GestureDescription description, int sampleTimeMs) {
	final List<MotionEvent> motionEvents = new ArrayList<>();

	// Point data at each time we generate an event for
	final TouchPoint[] currentTouchPoints =
	getCurrentTouchPoints(description.getStrokeCount());
	// Point data sent in last touch event
	int lastTouchPointSize = 0;
	final TouchPoint[] lastTouchPoints =
	getLastTouchPoints(description.getStrokeCount());

	/* Loop through each time slice where there are touch points */
	long timeSinceGestureStart = 0;
	long nextKeyPointTime = description.getNextKeyPointAtLeast(timeSinceGestureStart);
	while (nextKeyPointTime >= 0) {
	timeSinceGestureStart = (lastTouchPointSize == 0) ? nextKeyPointTime
	: Math.min(nextKeyPointTime, timeSinceGestureStart + sampleTimeMs);
	int currentTouchPointSize = description.getPointsForTime(timeSinceGestureStart,
	currentTouchPoints);

	appendMoveEventIfNeeded(motionEvents, lastTouchPoints, lastTouchPointSize,
	currentTouchPoints, currentTouchPointSize, timeSinceGestureStart);
	lastTouchPointSize = appendUpEvents(motionEvents, lastTouchPoints,
	lastTouchPointSize, currentTouchPoints, currentTouchPointSize,
	timeSinceGestureStart);
	lastTouchPointSize = appendDownEvents(motionEvents, lastTouchPoints,
	lastTouchPointSize, currentTouchPoints, currentTouchPointSize,
	timeSinceGestureStart);

	/* Move to next time slice */
	nextKeyPointTime = description.getNextKeyPointAtLeast(timeSinceGestureStart + 1);
	}
	return motionEvents;
	}

	private static TouchPoint[] getCurrentTouchPoints(int requiredCapacity) {
	if ((sCurrentTouchPoints == null) \|\| (sCurrentTouchPoints.length < requiredCapacity)) {
	sCurrentTouchPoints = new TouchPoint[requiredCapacity];
	for (int i = 0; i < requiredCapacity; i++) {
	sCurrentTouchPoints[i] = new TouchPoint();
	}
	}
	return sCurrentTouchPoints;
	}

	private static TouchPoint[] getLastTouchPoints(int requiredCapacity) {
	if ((sLastTouchPoints == null) \|\| (sLastTouchPoints.length < requiredCapacity)) {
	sLastTouchPoints = new TouchPoint[requiredCapacity];
	for (int i = 0; i < requiredCapacity; i++) {
	sLastTouchPoints[i] = new TouchPoint();
	}
	}
	return sLastTouchPoints;
	}

	private static PointerCoords[] getPointerCoords(int requiredCapacity) {
	if ((sPointerCoords == null) \|\| (sPointerCoords.length < requiredCapacity)) {
	sPointerCoords = new PointerCoords[requiredCapacity];
	for (int i = 0; i < requiredCapacity; i++) {
	sPointerCoords[i] = new PointerCoords();
	}
	}
	return sPointerCoords;
	}

	private static PointerProperties[] getPointerProps(int requiredCapacity) {
	if ((sPointerProps == null) \|\| (sPointerProps.length < requiredCapacity)) {
	sPointerProps = new PointerProperties[requiredCapacity];
	for (int i = 0; i < requiredCapacity; i++) {
	sPointerProps[i] = new PointerProperties();
	}
	}
	return sPointerProps;
	}

	private static void appendMoveEventIfNeeded(List<MotionEvent> motionEvents,
	TouchPoint[] lastTouchPoints, int lastTouchPointsSize,
	TouchPoint[] currentTouchPoints, int currentTouchPointsSize, long currentTime) {
	/* Look for pointers that have moved */
	boolean moveFound = false;
	for (int i = 0; i < currentTouchPointsSize; i++) {
	int lastPointsIndex = findPointByPathIndex(lastTouchPoints, lastTouchPointsSize,
	currentTouchPoints[i].mPathIndex);
	if (lastPointsIndex >= 0) {
	moveFound \|= (lastTouchPoints[lastPointsIndex].mX != currentTouchPoints[i].mX)
	\|\| (lastTouchPoints[lastPointsIndex].mY != currentTouchPoints[i].mY);
	lastTouchPoints[lastPointsIndex].copyFrom(currentTouchPoints[i]);
	}
	}

	if (moveFound) {
	long downTime = motionEvents.get(motionEvents.size() - 1).getDownTime();
	motionEvents.add(obtainMotionEvent(downTime, currentTime, MotionEvent.ACTION_MOVE,
	lastTouchPoints, lastTouchPointsSize));
	}
	}

	private static int appendUpEvents(List<MotionEvent> motionEvents,
	TouchPoint[] lastTouchPoints, int lastTouchPointsSize,
	TouchPoint[] currentTouchPoints, int currentTouchPointsSize, long currentTime) {
	/* Look for a pointer at the end of its path */
	for (int i = 0; i < currentTouchPointsSize; i++) {
	if (currentTouchPoints[i].mIsEndOfPath) {
	int indexOfUpEvent = findPointByPathIndex(lastTouchPoints, lastTouchPointsSize,
	currentTouchPoints[i].mPathIndex);
	if (indexOfUpEvent < 0) {
	continue; // Should not happen
	}
	long downTime = motionEvents.get(motionEvents.size() - 1).getDownTime();
	int action = (lastTouchPointsSize == 1) ? MotionEvent.ACTION_UP
	: MotionEvent.ACTION_POINTER_UP;
	action \|= indexOfUpEvent << MotionEvent.ACTION_POINTER_INDEX_SHIFT;
	motionEvents.add(obtainMotionEvent(downTime, currentTime, action,
	lastTouchPoints, lastTouchPointsSize));
	/* Remove this point from lastTouchPoints */
	for (int j = indexOfUpEvent; j < lastTouchPointsSize - 1; j++) {
	lastTouchPoints[j].copyFrom(lastTouchPoints[j+1]);
	}
	lastTouchPointsSize--;
	}
	}
	return lastTouchPointsSize;
	}

	private static int appendDownEvents(List<MotionEvent> motionEvents,
	TouchPoint[] lastTouchPoints, int lastTouchPointsSize,
	TouchPoint[] currentTouchPoints, int currentTouchPointsSize, long currentTime) {
	/* Look for a pointer that is just starting */
	for (int i = 0; i < currentTouchPointsSize; i++) {
	if (currentTouchPoints[i].mIsStartOfPath) {
	/* Add the point to last coords and use the new array to generate the event */
	lastTouchPoints[lastTouchPointsSize++].copyFrom(currentTouchPoints[i]);
	int action = (lastTouchPointsSize == 1) ? MotionEvent.ACTION_DOWN
	: MotionEvent.ACTION_POINTER_DOWN;
	long downTime = (action == MotionEvent.ACTION_DOWN) ? currentTime :
	motionEvents.get(motionEvents.size() - 1).getDownTime();
	action \|= i << MotionEvent.ACTION_POINTER_INDEX_SHIFT;
	motionEvents.add(obtainMotionEvent(downTime, currentTime, action,
	lastTouchPoints, lastTouchPointsSize));
	}
	}
	return lastTouchPointsSize;
	}

	private static MotionEvent obtainMotionEvent(long downTime, long eventTime, int action,
	TouchPoint[] touchPoints, int touchPointsSize) {
	PointerCoords[] pointerCoords = getPointerCoords(touchPointsSize);
	PointerProperties[] pointerProperties = getPointerProps(touchPointsSize);
	for (int i = 0; i < touchPointsSize; i++) {
	pointerProperties[i].id = touchPoints[i].mPathIndex;
	pointerProperties[i].toolType = MotionEvent.TOOL_TYPE_UNKNOWN;
	pointerCoords[i].clear();
	pointerCoords[i].pressure = 1.0f;
	pointerCoords[i].size = 1.0f;
	pointerCoords[i].x = touchPoints[i].mX;
	pointerCoords[i].y = touchPoints[i].mY;
	}
	return MotionEvent.obtain(downTime, eventTime, action, touchPointsSize,
	pointerProperties, pointerCoords, EVENT_META_STATE, EVENT_BUTTON_STATE,
	EVENT_X_PRECISION, EVENT_Y_PRECISION, EVENT_DEVICE_ID, EVENT_EDGE_FLAGS,
	EVENT_SOURCE, EVENT_FLAGS);
	}

	private static int findPointByPathIndex(TouchPoint[] touchPoints, int touchPointsSize,
	int pathIndex) {
	for (int i = 0; i < touchPointsSize; i++) {
	if (touchPoints[i].mPathIndex == pathIndex) {
	return i;
	}
	}
	return -1;
	}
	}
	}