下面列出了android.view.MotionEvent#TOOL_TYPE_FINGER 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
Device(final int aDevice) {
mDevice = aDevice;
mProperties = new MotionEvent.PointerProperties[1];
mProperties[0] = new MotionEvent.PointerProperties();
mProperties[0].id = 0;
mProperties[0].toolType = MotionEvent.TOOL_TYPE_FINGER;
mCoords = new MotionEvent.PointerCoords[1];
mCoords[0] = new MotionEvent.PointerCoords();
mMouseOutCoords = new MotionEvent.PointerCoords[1];
for (MotionEvent.PointerCoords[] coords : Arrays.asList(mCoords, mMouseOutCoords)) {
coords[0] = new MotionEvent.PointerCoords();
coords[0].toolMajor = 2;
coords[0].toolMinor = 2;
coords[0].touchMajor = 2;
coords[0].touchMinor = 2;
}
mMouseOutCoords[0].x = -10;
mMouseOutCoords[0].y = -10;
}
private static int actionToToolType(final W3CItemModel item) {
if (item.parameters != null && item.parameters.pointerType != null) {
switch (item.parameters.pointerType) {
case POINTER_TYPE_MOUSE:
return MotionEvent.TOOL_TYPE_MOUSE;
case POINTER_TYPE_PEN:
return MotionEvent.TOOL_TYPE_STYLUS;
case POINTER_TYPE_TOUCH:
return MotionEvent.TOOL_TYPE_FINGER;
default:
// use default
break;
}
}
return MotionEvent.TOOL_TYPE_FINGER;
}
private static MotionEvent.PointerProperties[] getPointerProperties(int inputDevice) {
MotionEvent.PointerProperties[] pointerProperties = {new MotionEvent.PointerProperties()};
pointerProperties[0].clear();
pointerProperties[0].id = 0;
switch (inputDevice) {
case InputDevice.SOURCE_MOUSE:
pointerProperties[0].toolType = MotionEvent.TOOL_TYPE_MOUSE;
break;
case InputDevice.SOURCE_STYLUS:
pointerProperties[0].toolType = MotionEvent.TOOL_TYPE_STYLUS;
break;
case InputDevice.SOURCE_TOUCHSCREEN:
pointerProperties[0].toolType = MotionEvent.TOOL_TYPE_FINGER;
break;
default:
pointerProperties[0].toolType = MotionEvent.TOOL_TYPE_UNKNOWN;
break;
}
return pointerProperties;
}
/**
* Returns a human-readable string describing the type of touch that triggered a MotionEvent.
*/
private static String getTouchType(MotionEvent e){
String touchTypeDescription = " ";
int touchType = e.getToolType(0);
switch (touchType) {
case MotionEvent.TOOL_TYPE_FINGER:
touchTypeDescription += "(finger)";
break;
case MotionEvent.TOOL_TYPE_STYLUS:
touchTypeDescription += "(stylus, ";
//Get some additional information about the stylus touch
float stylusPressure = e.getPressure();
touchTypeDescription += "pressure: " + stylusPressure;
if(Build.VERSION.SDK_INT >= 21) {
touchTypeDescription += ", buttons pressed: " + getButtonsPressed(e);
}
touchTypeDescription += ")";
break;
case MotionEvent.TOOL_TYPE_ERASER:
touchTypeDescription += "(eraser)";
break;
case MotionEvent.TOOL_TYPE_MOUSE:
touchTypeDescription += "(mouse)";
break;
default:
touchTypeDescription += "(unknown tool)";
break;
}
return touchTypeDescription;
}
public Pointer(int id, Point point) {
prop = new PointerProperties();
prop.id = id;
prop.toolType = MotionEvent.TOOL_TYPE_FINGER;
coords = new PointerCoords();
coords.pressure = 1;
coords.size = 1;
coords.x = point.x;
coords.y = point.y;
}
public void handleTouch(MotionEvent event) {
Log.d("touchEvent", event.getToolType(0) + ":" + event.getActionMasked());
if(event.getToolType(0) == MotionEvent.TOOL_TYPE_FINGER) {
if(event.getAction() == MotionEvent.ACTION_MOVE) {
buildMoveEvent(event);
} else if(event.getAction() == MotionEvent.ACTION_DOWN && changeTouchEvent){
buildMoveEvent(event);
} else if(event.getAction() == MotionEvent.ACTION_UP && changeTouchEvent){
buildMoveEvent(event);
}
}
}
public Pointer(int id, Point point) {
prop = new PointerProperties();
prop.id = id;
prop.toolType = MotionEvent.TOOL_TYPE_FINGER;
coords = new PointerCoords();
coords.pressure = 1;
coords.size = 1;
coords.x = point.x;
coords.y = point.y;
}
/**
* Returns a human-readable string describing the type of touch that triggered a MotionEvent.
*/
private static String getTouchType(MotionEvent e){
String touchTypeDescription = " ";
int touchType = e.getToolType(0);
switch (touchType) {
case MotionEvent.TOOL_TYPE_FINGER:
touchTypeDescription += "(finger)";
break;
case MotionEvent.TOOL_TYPE_STYLUS:
touchTypeDescription += "(stylus, ";
//Get some additional information about the stylus touch
float stylusPressure = e.getPressure();
touchTypeDescription += "pressure: " + stylusPressure;
if(Build.VERSION.SDK_INT >= 21) {
touchTypeDescription += ", buttons pressed: " + getButtonsPressed(e);
}
touchTypeDescription += ")";
break;
case MotionEvent.TOOL_TYPE_ERASER:
touchTypeDescription += "(eraser)";
break;
case MotionEvent.TOOL_TYPE_MOUSE:
touchTypeDescription += "(mouse)";
break;
default:
touchTypeDescription += "(unknown tool)";
break;
}
return touchTypeDescription;
}
TouchPointer(int startX, int startY, int deltaX, int deltaY,
int id, float scale, int scaledTouchSlop) {
mStartX = startX * scale;
mStartY = startY * scale;
float scaledDeltaX = deltaX * scale;
float scaledDeltaY = deltaY * scale;
if (scaledDeltaX != 0 || scaledDeltaY != 0) {
// The touch handler only considers a pointer as moving once
// it's been moved by more than scaledTouchSlop pixels. We
// thus increase the delta distance so the move is actually
// registered as covering the specified distance.
float distance = (float)Math.sqrt(scaledDeltaX * scaledDeltaX +
scaledDeltaY * scaledDeltaY);
mDeltaX = scaledDeltaX * (1 + scaledTouchSlop / distance);
mDeltaY = scaledDeltaY * (1 + scaledTouchSlop / distance);
}
else {
mDeltaX = scaledDeltaX;
mDeltaY = scaledDeltaY;
}
if (deltaX != 0 || deltaY != 0) {
mStepX = mDeltaX / Math.abs(mDeltaX + mDeltaY);
mStepY = mDeltaY / Math.abs(mDeltaX + mDeltaY);
} else {
mStepX = 0;
mStepY = 0;
}
mProperties = new PointerProperties();
mProperties.id = id;
mProperties.toolType = MotionEvent.TOOL_TYPE_FINGER;
mCoords = new PointerCoords();
mCoords.x = mStartX;
mCoords.y = mStartY;
mCoords.pressure = 1.0f;
}
TouchPointer(int startX, int startY, int deltaX, int deltaY,
int id, float scale, int scaledTouchSlop) {
mStartX = startX * scale;
mStartY = startY * scale;
float scaledDeltaX = deltaX * scale;
float scaledDeltaY = deltaY * scale;
if (scaledDeltaX != 0 || scaledDeltaY != 0) {
// The touch handler only considers a pointer as moving once
// it's been moved by more than scaledTouchSlop pixels. We
// thus increase the delta distance so the move is actually
// registered as covering the specified distance.
float distance = (float)Math.sqrt(scaledDeltaX * scaledDeltaX +
scaledDeltaY * scaledDeltaY);
mDeltaX = scaledDeltaX * (1 + scaledTouchSlop / distance);
mDeltaY = scaledDeltaY * (1 + scaledTouchSlop / distance);
}
else {
mDeltaX = scaledDeltaX;
mDeltaY = scaledDeltaY;
}
if (deltaX != 0 || deltaY != 0) {
mStepX = mDeltaX / Math.abs(mDeltaX + mDeltaY);
mStepY = mDeltaY / Math.abs(mDeltaX + mDeltaY);
} else {
mStepX = 0;
mStepY = 0;
}
mProperties = new PointerProperties();
mProperties.id = id;
mProperties.toolType = MotionEvent.TOOL_TYPE_FINGER;
mCoords = new PointerCoords();
mCoords.x = mStartX;
mCoords.y = mStartY;
mCoords.pressure = 1.0f;
}
/**
* Performs a multi-touch gesture
*
* Takes a series of touch coordinates for at least 2 pointers. Each pointer must have
* all of its touch steps defined in an array of {@link PointerCoords}. By having the ability
* to specify the touch points along the path of a pointer, the caller is able to specify
* complex gestures like circles, irregular shapes etc, where each pointer may take a
* different path.
*
* To create a single point on a pointer's touch path
* <code>
* PointerCoords p = new PointerCoords();
* p.x = stepX;
* p.y = stepY;
* p.pressure = 1;
* p.size = 1;
* </code>
* @param touches each array of {@link PointerCoords} constitute a single pointer's touch path.
* Multiple {@link PointerCoords} arrays constitute multiple pointers, each with its own
* path. Each {@link PointerCoords} in an array constitute a point on a pointer's path.
* @return <code>true</code> if all points on all paths are injected successfully, <code>false
* </code>otherwise
* @since API Level 18
*/
public boolean performMultiPointerGesture(PointerCoords[] ... touches) {
boolean ret = true;
if (touches.length < 2) {
throw new IllegalArgumentException("Must provide coordinates for at least 2 pointers");
}
// Get the pointer with the max steps to inject.
int maxSteps = 0;
for (int x = 0; x < touches.length; x++)
maxSteps = (maxSteps < touches[x].length) ? touches[x].length : maxSteps;
// specify the properties for each pointer as finger touch
PointerProperties[] properties = new PointerProperties[touches.length];
PointerCoords[] pointerCoords = new PointerCoords[touches.length];
for (int x = 0; x < touches.length; x++) {
PointerProperties prop = new PointerProperties();
prop.id = x;
prop.toolType = MotionEvent.TOOL_TYPE_FINGER;
properties[x] = prop;
// for each pointer set the first coordinates for touch down
pointerCoords[x] = touches[x][0];
}
// Touch down all pointers
long downTime = SystemClock.uptimeMillis();
MotionEvent event;
event = MotionEvent.obtain(downTime, SystemClock.uptimeMillis(), MotionEvent.ACTION_DOWN, 1,
properties, pointerCoords, 0, 0, 1, 1, 0, 0, InputDevice.SOURCE_TOUCHSCREEN, 0);
ret &= injectEventSync(event);
for (int x = 1; x < touches.length; x++) {
event = MotionEvent.obtain(downTime, SystemClock.uptimeMillis(),
getPointerAction(MotionEvent.ACTION_POINTER_DOWN, x), x + 1, properties,
pointerCoords, 0, 0, 1, 1, 0, 0, InputDevice.SOURCE_TOUCHSCREEN, 0);
ret &= injectEventSync(event);
}
// Move all pointers
for (int i = 1; i < maxSteps - 1; i++) {
// for each pointer
for (int x = 0; x < touches.length; x++) {
// check if it has coordinates to move
if (touches[x].length > i)
pointerCoords[x] = touches[x][i];
else
pointerCoords[x] = touches[x][touches[x].length - 1];
}
event = MotionEvent.obtain(downTime, SystemClock.uptimeMillis(),
MotionEvent.ACTION_MOVE, touches.length, properties, pointerCoords, 0, 0, 1, 1,
0, 0, InputDevice.SOURCE_TOUCHSCREEN, 0);
ret &= injectEventSync(event);
SystemClock.sleep(MOTION_EVENT_INJECTION_DELAY_MILLIS);
}
// For each pointer get the last coordinates
for (int x = 0; x < touches.length; x++)
pointerCoords[x] = touches[x][touches[x].length - 1];
// touch up
for (int x = 1; x < touches.length; x++) {
event = MotionEvent.obtain(downTime, SystemClock.uptimeMillis(),
getPointerAction(MotionEvent.ACTION_POINTER_UP, x), x + 1, properties,
pointerCoords, 0, 0, 1, 1, 0, 0, InputDevice.SOURCE_TOUCHSCREEN, 0);
ret &= injectEventSync(event);
}
Log.i(LOG_TAG, "x " + pointerCoords[0].x);
// first to touch down is last up
event = MotionEvent.obtain(downTime, SystemClock.uptimeMillis(), MotionEvent.ACTION_UP, 1,
properties, pointerCoords, 0, 0, 1, 1, 0, 0, InputDevice.SOURCE_TOUCHSCREEN, 0);
ret &= injectEventSync(event);
return ret;
}
static boolean isFingerEvent(@NonNull MotionEvent e) {
return e.getToolType(0) == MotionEvent.TOOL_TYPE_FINGER;
}
public void generateTapGesture(int numTaps, PointF... points)
{
MotionEvent event;
long downTime = SystemClock.uptimeMillis();
long eventTime = SystemClock.uptimeMillis();
// pointer 1
float x1 = points[0].x;
float y1 = points[0].y;
float x2 = 0;
float y2 = 0;
if (points.length == 2)
{
// pointer 2
x2 = points[1].x;
y2 = points[1].y;
}
PointerCoords[] pointerCoords = new PointerCoords[points.length];
PointerCoords pc1 = new PointerCoords();
pc1.x = x1;
pc1.y = y1;
pc1.pressure = 1;
pc1.size = 1;
pointerCoords[0] = pc1;
PointerCoords pc2 = new PointerCoords();
if (points.length == 2)
{
pc2.x = x2;
pc2.y = y2;
pc2.pressure = 1;
pc2.size = 1;
pointerCoords[1] = pc2;
}
PointerProperties[] pointerProperties = new PointerProperties[points.length];
PointerProperties pp1 = new PointerProperties();
pp1.id = 0;
pp1.toolType = MotionEvent.TOOL_TYPE_FINGER;
pointerProperties[0] = pp1;
PointerProperties pp2 = new PointerProperties();
if (points.length == 2)
{
pp2.id = 1;
pp2.toolType = MotionEvent.TOOL_TYPE_FINGER;
pointerProperties[1] = pp2;
}
int i = 0;
while (i != numTaps)
{
event = MotionEvent.obtain(downTime, eventTime,
MotionEvent.ACTION_DOWN, points.length, pointerProperties,
pointerCoords, 0, 0, 1, 1, 0, 0,
InputDevice.SOURCE_TOUCHSCREEN, 0);
_instrument.sendPointerSync(event);
if (points.length == 2)
{
event = MotionEvent
.obtain(downTime,
eventTime,
MotionEvent.ACTION_POINTER_DOWN
+ (pp2.id << MotionEvent.ACTION_POINTER_INDEX_SHIFT),
points.length, pointerProperties,
pointerCoords, 0, 0, 1, 1, 0, 0,
InputDevice.SOURCE_TOUCHSCREEN, 0);
_instrument.sendPointerSync(event);
eventTime += EVENT_TIME_INTERVAL_MS;
event = MotionEvent
.obtain(downTime,
eventTime,
MotionEvent.ACTION_POINTER_UP
+ (pp2.id << MotionEvent.ACTION_POINTER_INDEX_SHIFT),
points.length, pointerProperties,
pointerCoords, 0, 0, 1, 1, 0, 0,
InputDevice.SOURCE_TOUCHSCREEN, 0);
_instrument.sendPointerSync(event);
}
eventTime += EVENT_TIME_INTERVAL_MS;
event = MotionEvent.obtain(downTime, eventTime,
MotionEvent.ACTION_UP, points.length, pointerProperties,
pointerCoords, 0, 0, 1, 1, 0, 0,
InputDevice.SOURCE_TOUCHSCREEN, 0);
_instrument.sendPointerSync(event);
i++;
}
}
public void generateSwipeGesture(PointF startPoint1, PointF startPoint2,
PointF endPoint1, PointF endPoint2)
{
long downTime = SystemClock.uptimeMillis();
long eventTime = SystemClock.uptimeMillis();
float startX1 = startPoint1.x;
float startY1 = startPoint1.y;
float startX2 = startPoint2.x;
float startY2 = startPoint2.y;
float endX1 = endPoint1.x;
float endY1 = endPoint1.y;
float endX2 = endPoint2.x;
float endY2 = endPoint2.y;
// pointer 1
float x1 = startX1;
float y1 = startY1;
// pointer 2
float x2 = startX2;
float y2 = startY2;
PointerCoords[] pointerCoords = new PointerCoords[2];
PointerCoords pc1 = new PointerCoords();
PointerCoords pc2 = new PointerCoords();
pc1.x = x1;
pc1.y = y1;
pc1.pressure = 1;
pc1.size = 1;
pc2.x = x2;
pc2.y = y2;
pc2.pressure = 1;
pc2.size = 1;
pointerCoords[0] = pc1;
pointerCoords[1] = pc2;
PointerProperties[] pointerProperties = new PointerProperties[2];
PointerProperties pp1 = new PointerProperties();
PointerProperties pp2 = new PointerProperties();
pp1.id = 0;
pp1.toolType = MotionEvent.TOOL_TYPE_FINGER;
pp2.id = 1;
pp2.toolType = MotionEvent.TOOL_TYPE_FINGER;
pointerProperties[0] = pp1;
pointerProperties[1] = pp2;
MotionEvent event;
// send the initial touches
event = MotionEvent.obtain(downTime, eventTime,
MotionEvent.ACTION_DOWN, 1, pointerProperties, pointerCoords,
0, 0, // metaState, buttonState
1, // x precision
1, // y precision
0, 0, 0, 0); // deviceId, edgeFlags, source, flags
_instrument.sendPointerSync(event);
event = MotionEvent.obtain(downTime, eventTime,
MotionEvent.ACTION_POINTER_DOWN
+ (pp2.id << MotionEvent.ACTION_POINTER_INDEX_SHIFT),
2, pointerProperties, pointerCoords, 0, 0, 1, 1, 0, 0, 0, 0);
_instrument.sendPointerSync(event);
int numMoves = GESTURE_DURATION_MS / EVENT_TIME_INTERVAL_MS;
float stepX1 = (endX1 - startX1) / numMoves;
float stepY1 = (endY1 - startY1) / numMoves;
float stepX2 = (endX2 - startX2) / numMoves;
float stepY2 = (endY2 - startY2) / numMoves;
// send the zoom
for (int i = 0; i < numMoves; i++)
{
eventTime += EVENT_TIME_INTERVAL_MS;
pointerCoords[0].x += stepX1;
pointerCoords[0].y += stepY1;
pointerCoords[1].x += stepX2;
pointerCoords[1].y += stepY2;
event = MotionEvent.obtain(downTime, eventTime,
MotionEvent.ACTION_MOVE, 2, pointerProperties,
pointerCoords, 0, 0, 1, 1, 0, 0, 0, 0);
_instrument.sendPointerSync(event);
}
}
private void injectTouchEvent(int buttonId, int event, int x, int y)
{
final View view = obtainTargetView();
if (view == null) return;
final Activity activity = obtainActivity();
if (activity == null) return;
int viewLocation[] = new int[2];
view.getLocationOnScreen(viewLocation);
MotionEvent.PointerProperties pp = new MotionEvent.PointerProperties();
pp.toolType = MotionEvent.TOOL_TYPE_FINGER;
pp.id = 0;
MotionEvent.PointerProperties[] pps = new MotionEvent.PointerProperties[]{pp};
MotionEvent.PointerCoords pc = new MotionEvent.PointerCoords();
pc.size = 1;
pc.pressure = 1;
pc.x = x - viewLocation[0];
pc.y = y - viewLocation[1];
MotionEvent.PointerCoords[] pcs = new MotionEvent.PointerCoords[]{pc};
long t = SystemClock.uptimeMillis();
final MotionEvent e = MotionEvent.obtain(
t, // long downTime
t + 100, // long eventTime
event, // int action
pps.length, // int pointerCount
pps, // MotionEvent.PointerProperties[] pointerProperties
pcs, // MotionEvent.PointerCoords[] pointerCoords
0, // int metaState
0, // int buttonState
1, // float xPrecision
1, // float yPrecision
1, // int deviceId
0, // int edgeFlags
InputDevice.SOURCE_TOUCHSCREEN, //int source
0 // int flags
);
activity.runOnUiThread(new Runnable() {
public void run() {
view.dispatchTouchEvent(e);
}
});
}
/**
* Performs a multi-touch gesture
*
* Takes a series of touch coordinates for at least 2 pointers. Each pointer must have
* all of its touch steps defined in an array of {@link PointerCoords}. By having the ability
* to specify the touch points along the path of a pointer, the caller is able to specify
* complex gestures like circles, irregular shapes etc, where each pointer may take a
* different path.
*
* To create a single point on a pointer's touch path
* <code>
* PointerCoords p = new PointerCoords();
* p.x = stepX;
* p.y = stepY;
* p.pressure = 1;
* p.size = 1;
* </code>
* @param touches each array of {@link PointerCoords} constitute a single pointer's touch path.
* Multiple {@link PointerCoords} arrays constitute multiple pointers, each with its own
* path. Each {@link PointerCoords} in an array constitute a point on a pointer's path.
* @return <code>true</code> if all points on all paths are injected successfully, <code>false
* </code>otherwise
* @since API Level 18
*/
public boolean performMultiPointerGesture(PointerCoords[]... touches) {
boolean ret = true;
if (touches.length < 2) {
throw new IllegalArgumentException("Must provide coordinates for at least 2 pointers");
}
// Get the pointer with the max steps to inject.
int maxSteps = 0;
for (int x = 0; x < touches.length; x++)
maxSteps = (maxSteps < touches[x].length) ? touches[x].length : maxSteps;
// specify the properties for each pointer as finger touch
PointerProperties[] properties = new PointerProperties[touches.length];
PointerCoords[] pointerCoords = new PointerCoords[touches.length];
for (int x = 0; x < touches.length; x++) {
PointerProperties prop = new PointerProperties();
prop.id = x;
prop.toolType = MotionEvent.TOOL_TYPE_FINGER;
properties[x] = prop;
// for each pointer set the first coordinates for touch down
pointerCoords[x] = touches[x][0];
}
// Touch down all pointers
long downTime = SystemClock.uptimeMillis();
MotionEvent event;
event = MotionEvent.obtain(downTime, SystemClock.uptimeMillis(), MotionEvent.ACTION_DOWN, 1, properties, pointerCoords, 0, 0, 1, 1, 0, 0, InputDevice.SOURCE_TOUCHSCREEN, 0);
ret &= injectEventSync(event);
for (int x = 1; x < touches.length; x++) {
event = MotionEvent.obtain(downTime, SystemClock.uptimeMillis(), getPointerAction(MotionEvent.ACTION_POINTER_DOWN, x), x + 1, properties, pointerCoords, 0, 0, 1, 1, 0, 0,
InputDevice.SOURCE_TOUCHSCREEN, 0);
ret &= injectEventSync(event);
}
// Move all pointers
for (int i = 1; i < maxSteps - 1; i++) {
// for each pointer
for (int x = 0; x < touches.length; x++) {
// check if it has coordinates to move
if (touches[x].length > i)
pointerCoords[x] = touches[x][i];
else
pointerCoords[x] = touches[x][touches[x].length - 1];
}
event = MotionEvent.obtain(downTime, SystemClock.uptimeMillis(), MotionEvent.ACTION_MOVE, touches.length, properties, pointerCoords, 0, 0, 1, 1, 0, 0, InputDevice.SOURCE_TOUCHSCREEN, 0);
ret &= injectEventSync(event);
SystemClock.sleep(MOTION_EVENT_INJECTION_DELAY_MILLIS);
}
// For each pointer get the last coordinates
for (int x = 0; x < touches.length; x++)
pointerCoords[x] = touches[x][touches[x].length - 1];
// touch up
for (int x = 1; x < touches.length; x++) {
event = MotionEvent.obtain(downTime, SystemClock.uptimeMillis(), getPointerAction(MotionEvent.ACTION_POINTER_UP, x), x + 1, properties, pointerCoords, 0, 0, 1, 1, 0, 0,
InputDevice.SOURCE_TOUCHSCREEN, 0);
ret &= injectEventSync(event);
}
Log.i(LOG_TAG, "x " + pointerCoords[0].x);
// first to touch down is last up
event = MotionEvent.obtain(downTime, SystemClock.uptimeMillis(), MotionEvent.ACTION_UP, 1, properties, pointerCoords, 0, 0, 1, 1, 0, 0, InputDevice.SOURCE_TOUCHSCREEN, 0);
ret &= injectEventSync(event);
return ret;
}
List<MotionEvent> convertTouchEvent(OnTouchEvent onTouchEvent){
List<MotionEvent> motionEventList = new ArrayList<MotionEvent>();
List<TouchEvent> touchEventList = onTouchEvent.getEvent();
if (touchEventList == null || touchEventList.size() == 0) return null;
TouchType touchType = onTouchEvent.getType();
if (touchType == null) { return null; }
if(sdlMotionEvent == null) {
if (touchType == TouchType.BEGIN) {
sdlMotionEvent = new SdlMotionEvent();
} else{
return null;
}
}
SdlMotionEvent.Pointer pointer;
MotionEvent motionEvent;
for (TouchEvent touchEvent : touchEventList) {
if (touchEvent == null || touchEvent.getId() == null) {
continue;
}
List<TouchCoord> touchCoordList = touchEvent.getTouchCoordinates();
if (touchCoordList == null || touchCoordList.size() == 0) {
continue;
}
TouchCoord touchCoord = touchCoordList.get(touchCoordList.size() - 1);
if (touchCoord == null) {
continue;
}
int motionEventAction = sdlMotionEvent.getMotionEventAction(touchType, touchEvent);
long downTime = sdlMotionEvent.downTime;
long eventTime = sdlMotionEvent.eventTime;
pointer = sdlMotionEvent.getPointerById(touchEvent.getId());
if (pointer != null) {
pointer.setCoords(touchCoord.getX() * touchScalar[0], touchCoord.getY() * touchScalar[1]);
}
MotionEvent.PointerProperties[] pointerProperties = new MotionEvent.PointerProperties[sdlMotionEvent.pointers.size()];
MotionEvent.PointerCoords[] pointerCoords = new MotionEvent.PointerCoords[sdlMotionEvent.pointers.size()];
for (int i = 0; i < sdlMotionEvent.pointers.size(); i++) {
pointerProperties[i] = new MotionEvent.PointerProperties();
pointerProperties[i].id = sdlMotionEvent.getPointerByIndex(i).id;
pointerProperties[i].toolType = MotionEvent.TOOL_TYPE_FINGER;
pointerCoords[i] = new MotionEvent.PointerCoords();
pointerCoords[i].x = sdlMotionEvent.getPointerByIndex(i).x;
pointerCoords[i].y = sdlMotionEvent.getPointerByIndex(i).y;
pointerCoords[i].orientation = 0;
pointerCoords[i].pressure = 1.0f;
pointerCoords[i].size = 1;
}
motionEvent = MotionEvent.obtain(downTime, eventTime, motionEventAction,
sdlMotionEvent.pointers.size(), pointerProperties, pointerCoords, 0, 0, 1,
1, 0, 0, InputDevice.SOURCE_TOUCHSCREEN, 0);
motionEventList.add(motionEvent);
if(motionEventAction == MotionEvent.ACTION_UP || motionEventAction == MotionEvent.ACTION_CANCEL){
//If the motion event should be finished we should clear our reference
sdlMotionEvent.pointers.clear();
sdlMotionEvent = null;
break;
} else if((motionEventAction & MotionEvent.ACTION_MASK) == MotionEvent.ACTION_POINTER_UP){
sdlMotionEvent.removePointerById(touchEvent.getId());
}
}
return motionEventList;
}