services/accessibility/java/com/android/server/accessibility/MotionEventInjector.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 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;
         }
     }
 }
	/*
	* 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;
	}
	}
	}