/*
* 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 com.android.server.accessibility;
import android.accessibilityservice.IAccessibilityServiceClient;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.os.RemoteException;
import android.os.SystemClock;
import android.util.Slog;
import android.util.SparseArray;
import android.view.InputDevice;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.WindowManagerPolicy;
import android.view.accessibility.AccessibilityEvent;
import com.android.internal.os.SomeArgs;
import com.android.server.accessibility.AccessibilityManagerService.Service;
import java.util.List;
/**
* Injects MotionEvents to permit {@code AccessibilityService}s to touch the screen on behalf of
* users.
*
* All methods except {@code injectEvents} must be called only from the main thread.
*/
public class MotionEventInjector implements EventStreamTransformation {
private static final String LOG_TAG = "MotionEventInjector";
private static final int MESSAGE_SEND_MOTION_EVENT = 1;
private static final int MESSAGE_INJECT_EVENTS = 2;
private static final int MAX_POINTERS = 11; // Non-binding maximum
private final Handler mHandler;
private final SparseArray<Boolean> mOpenGesturesInProgress = new SparseArray<>();
// These two arrays must be the same length
private MotionEvent.PointerProperties[] mPointerProperties =
new MotionEvent.PointerProperties[MAX_POINTERS];
private MotionEvent.PointerCoords[] mPointerCoords =
new MotionEvent.PointerCoords[MAX_POINTERS];
private EventStreamTransformation mNext;
private IAccessibilityServiceClient mServiceInterfaceForCurrentGesture;
private int mSequenceForCurrentGesture;
private int mSourceOfInjectedGesture = InputDevice.SOURCE_UNKNOWN;
private boolean mIsDestroyed = false;
/**
* @param looper A looper on the main thread to use for dispatching new events
*/
public MotionEventInjector(Looper looper) {
mHandler = new Handler(looper, new Callback());
}
/**
* Schedule a series of events for injection. These events must comprise a complete, valid
* sequence. All gestures currently in progress will be cancelled, and all {@code downTime}
* and {@code eventTime} fields will be offset by the current time.
*
* @param events The events to inject. Must all be from the same source.
* @param serviceInterface The interface to call back with a result when the gesture is
* either complete or cancelled.
*/
public void injectEvents(List<MotionEvent> events,
IAccessibilityServiceClient serviceInterface, int sequence) {
SomeArgs args = SomeArgs.obtain();
args.arg1 = events;
args.arg2 = serviceInterface;
args.argi1 = sequence;
mHandler.sendMessage(mHandler.obtainMessage(MESSAGE_INJECT_EVENTS, args));
}
@Override
public void onMotionEvent(MotionEvent event, MotionEvent rawEvent, int policyFlags) {
cancelAnyPendingInjectedEvents();
sendMotionEventToNext(event, rawEvent, policyFlags);
}
@Override
public void onKeyEvent(KeyEvent event, int policyFlags) {
if (mNext != null) {
mNext.onKeyEvent(event, policyFlags);
}
}
@Override
public void onAccessibilityEvent(AccessibilityEvent event) {
if (mNext != null) {
mNext.onAccessibilityEvent(event);
}
}
@Override
public void setNext(EventStreamTransformation next) {
mNext = next;
}
@Override
public void clearEvents(int inputSource) {
/*
* Reset state for motion events passing through so we won't send a cancel event for
* them.
*/
if (!mHandler.hasMessages(MESSAGE_SEND_MOTION_EVENT)) {
mOpenGesturesInProgress.put(inputSource, false);
}
}
@Override
public void onDestroy() {
cancelAnyPendingInjectedEvents();
mIsDestroyed = true;
}
private void injectEventsMainThread(List<MotionEvent> events,
IAccessibilityServiceClient serviceInterface, int sequence) {
if (mIsDestroyed) {
try {
serviceInterface.onPerformGestureResult(sequence, false);
} catch (RemoteException re) {
Slog.e(LOG_TAG, "Error sending status with mIsDestroyed to " + serviceInterface,
re);
}
return;
}
cancelAnyPendingInjectedEvents();
mSourceOfInjectedGesture = events.get(0).getSource();
cancelAnyGestureInProgress(mSourceOfInjectedGesture);
mServiceInterfaceForCurrentGesture = serviceInterface;
mSequenceForCurrentGesture = sequence;
if (mNext == null) {
notifyService(false);
return;
}
long startTime = SystemClock.uptimeMillis();
for (int i = 0; i < events.size(); i++) {
MotionEvent event = events.get(i);
int numPointers = event.getPointerCount();
if (numPointers > mPointerCoords.length) {
mPointerCoords = new MotionEvent.PointerCoords[numPointers];
mPointerProperties = new MotionEvent.PointerProperties[numPointers];
}
for (int j = 0; j < numPointers; j++) {
if (mPointerCoords[j] == null) {
mPointerCoords[j] = new MotionEvent.PointerCoords();
mPointerProperties[j] = new MotionEvent.PointerProperties();
}
event.getPointerCoords(j, mPointerCoords[j]);
event.getPointerProperties(j, mPointerProperties[j]);
}
/*
* MotionEvent doesn't have a setEventTime() method (it carries around history data,
* which could become inconsistent), so we need to obtain a new one.
*/
MotionEvent offsetEvent = MotionEvent.obtain(startTime + event.getDownTime(),
startTime + event.getEventTime(), event.getAction(), numPointers,
mPointerProperties, mPointerCoords, event.getMetaState(),
event.getButtonState(), event.getXPrecision(), event.getYPrecision(),
event.getDeviceId(), event.getEdgeFlags(), event.getSource(),
event.getFlags());
Message message = mHandler.obtainMessage(MESSAGE_SEND_MOTION_EVENT, offsetEvent);
mHandler.sendMessageDelayed(message, event.getEventTime());
}
}
private void sendMotionEventToNext(MotionEvent event, MotionEvent rawEvent,
int policyFlags) {
if (mNext != null) {
mNext.onMotionEvent(event, rawEvent, policyFlags);
if (event.getActionMasked() == MotionEvent.ACTION_DOWN) {
mOpenGesturesInProgress.put(event.getSource(), true);
}
if ((event.getActionMasked() == MotionEvent.ACTION_UP)
|| (event.getActionMasked() == MotionEvent.ACTION_CANCEL)) {
mOpenGesturesInProgress.put(event.getSource(), false);
}
}
}
private void cancelAnyGestureInProgress(int source) {
if ((mNext != null) && mOpenGesturesInProgress.get(source, false)) {
long now = SystemClock.uptimeMillis();
MotionEvent cancelEvent =
MotionEvent.obtain(now, now, MotionEvent.ACTION_CANCEL, 0.0f, 0.0f, 0);
sendMotionEventToNext(cancelEvent, cancelEvent,
WindowManagerPolicy.FLAG_PASS_TO_USER);
}
}
private void cancelAnyPendingInjectedEvents() {
if (mHandler.hasMessages(MESSAGE_SEND_MOTION_EVENT)) {
cancelAnyGestureInProgress(mSourceOfInjectedGesture);
mHandler.removeMessages(MESSAGE_SEND_MOTION_EVENT);
notifyService(false);
}
}
private void notifyService(boolean success) {
try {
mServiceInterfaceForCurrentGesture.onPerformGestureResult(
mSequenceForCurrentGesture, success);
} catch (RemoteException re) {
Slog.e(LOG_TAG, "Error sending motion event injection status to "
+ mServiceInterfaceForCurrentGesture, re);
}
}
private class Callback implements Handler.Callback {
@Override
public boolean handleMessage(Message message) {
if (message.what == MESSAGE_INJECT_EVENTS) {
SomeArgs args = (SomeArgs) message.obj;
injectEventsMainThread((List<MotionEvent>) args.arg1,
(IAccessibilityServiceClient) args.arg2, args.argi1);
args.recycle();
return true;
}
if (message.what != MESSAGE_SEND_MOTION_EVENT) {
throw new IllegalArgumentException("Unknown message: " + message.what);
}
MotionEvent motionEvent = (MotionEvent) message.obj;
sendMotionEventToNext(motionEvent, motionEvent,
WindowManagerPolicy.FLAG_PASS_TO_USER);
// If the message queue is now empty, then this gesture is complete
if (!mHandler.hasMessages(MESSAGE_SEND_MOTION_EVENT)) {
notifyService(true);
}
return true;
}
}
}