For more information about creating AccessibilityServices, read the * Accessibility * developer guide.
** The lifecycle of an accessibility service is managed exclusively by the system and * follows the established service life cycle. Starting an accessibility service is triggered * exclusively by the user explicitly turning the service on in device settings. After the system * binds to a service, it calls {@link AccessibilityService#onServiceConnected()}. This method can * be overridden by clients that want to perform post binding setup. *
** An accessibility service stops either when the user turns it off in device settings or when * it calls {@link AccessibilityService#disableSelf()}. *
** An accessibility is declared as any other service in an AndroidManifest.xml, but it * must do two things: *
<service android:name=".MyAccessibilityService" * android:permission="android.permission.BIND_ACCESSIBILITY_SERVICE"> * <intent-filter> * <action android:name="android.accessibilityservice.AccessibilityService" /> * </intent-filter> * . . . * </service>*
* An accessibility service can be configured to receive specific types of accessibility events, * listen only to specific packages, get events from each type only once in a given time frame, * retrieve window content, specify a settings activity, etc. *
** There are two approaches for configuring an accessibility service: *
*<service android:name=".MyAccessibilityService"> * <intent-filter> * <action android:name="android.accessibilityservice.AccessibilityService" /> * </intent-filter> * <meta-data android:name="android.accessibilityservice" android:resource="@xml/accessibilityservice" /> * </service>*
* Note: This approach enables setting all properties. *
*
* For more details refer to {@link #SERVICE_META_DATA} and
* <{@link android.R.styleable#AccessibilityService accessibility-service}>.
*
* Note: This approach enables setting only dynamically configurable properties: * {@link AccessibilityServiceInfo#eventTypes}, * {@link AccessibilityServiceInfo#feedbackType}, * {@link AccessibilityServiceInfo#flags}, * {@link AccessibilityServiceInfo#notificationTimeout}, * {@link AccessibilityServiceInfo#packageNames} *
** For more details refer to {@link AccessibilityServiceInfo}. *
** A service can specify in its declaration that it can retrieve window * content which is represented as a tree of {@link AccessibilityWindowInfo} and * {@link AccessibilityNodeInfo} objects. Note that * declaring this capability requires that the service declares its configuration via * an XML resource referenced by {@link #SERVICE_META_DATA}. *
** Window content may be retrieved with * {@link AccessibilityEvent#getSource() AccessibilityEvent.getSource()}, * {@link AccessibilityService#findFocus(int)}, * {@link AccessibilityService#getWindows()}, or * {@link AccessibilityService#getRootInActiveWindow()}. *
** Note An accessibility service may have requested to be notified for * a subset of the event types, and thus be unaware when the node hierarchy has changed. It is also * possible for a node to contain outdated information because the window content may change at any * time. *
** All accessibility services are notified of all events they have requested, regardless of their * feedback type. *
** Note: The event notification timeout is useful to avoid propagating * events to the client too frequently since this is accomplished via an expensive * interprocess call. One can think of the timeout as a criteria to determine when * event generation has settled down.
*<{@link android.R.styleable#AccessibilityService accessibility-service}>
* tag. This is a sample XML file configuring an accessibility service:
* <accessibility-service
* android:accessibilityEventTypes="typeViewClicked|typeViewFocused"
* android:packageNames="foo.bar, foo.baz"
* android:accessibilityFeedbackType="feedbackSpoken"
* android:notificationTimeout="100"
* android:accessibilityFlags="flagDefault"
* android:settingsActivity="foo.bar.TestBackActivity"
* android:canRetrieveWindowContent="true"
* android:canRequestTouchExplorationMode="true"
* . . .
* />
*/
public static final String SERVICE_META_DATA = "android.accessibilityservice";
/**
* Action to go back.
*/
public static final int GLOBAL_ACTION_BACK = 1;
/**
* Action to go home.
*/
public static final int GLOBAL_ACTION_HOME = 2;
/**
* Action to toggle showing the overview of recent apps. Will fail on platforms that don't
* show recent apps.
*/
public static final int GLOBAL_ACTION_RECENTS = 3;
/**
* Action to open the notifications.
*/
public static final int GLOBAL_ACTION_NOTIFICATIONS = 4;
/**
* Action to open the quick settings.
*/
public static final int GLOBAL_ACTION_QUICK_SETTINGS = 5;
/**
* Action to open the power long-press dialog.
*/
public static final int GLOBAL_ACTION_POWER_DIALOG = 6;
/**
* Action to toggle docking the current app's window
*/
public static final int GLOBAL_ACTION_TOGGLE_SPLIT_SCREEN = 7;
/**
* Action to lock the screen
*/
public static final int GLOBAL_ACTION_LOCK_SCREEN = 8;
/**
* Action to take a screenshot
*/
public static final int GLOBAL_ACTION_TAKE_SCREENSHOT = 9;
/**
* Action to send the KEYCODE_HEADSETHOOK KeyEvent, which is used to answer/hang up calls and
* play/stop media
* @hide
*/
public static final int GLOBAL_ACTION_KEYCODE_HEADSETHOOK = 10;
/**
* Action to trigger the Accessibility Button
* @hide
*/
public static final int GLOBAL_ACTION_ACCESSIBILITY_BUTTON = 11;
/**
* Action to bring up the Accessibility Button's chooser menu
* @hide
*/
public static final int GLOBAL_ACTION_ACCESSIBILITY_BUTTON_CHOOSER = 12;
/**
* Action to trigger the Accessibility Shortcut. This shortcut has a hardware trigger and can
* be activated by holding down the two volume keys.
* @hide
*/
public static final int GLOBAL_ACTION_ACCESSIBILITY_SHORTCUT = 13;
/**
* Action to show Launcher's all apps.
* @hide
*/
public static final int GLOBAL_ACTION_ACCESSIBILITY_ALL_APPS = 14;
private static final String LOG_TAG = "AccessibilityService";
/**
* Interface used by IAccessibilityServiceClientWrapper to call the service from its main
* thread.
* @hide
*/
public interface Callbacks {
void onAccessibilityEvent(AccessibilityEvent event);
void onInterrupt();
void onServiceConnected();
void init(int connectionId, IBinder windowToken);
/** The detected gesture information for different displays */
boolean onGesture(AccessibilityGestureEvent gestureInfo);
boolean onKeyEvent(KeyEvent event);
/** Magnification changed callbacks for different displays */
void onMagnificationChanged(int displayId, @NonNull Region region,
float scale, float centerX, float centerY);
void onSoftKeyboardShowModeChanged(int showMode);
void onPerformGestureResult(int sequence, boolean completedSuccessfully);
void onFingerprintCapturingGesturesChanged(boolean active);
void onFingerprintGesture(int gesture);
/** Accessbility button clicked callbacks for different displays */
void onAccessibilityButtonClicked(int displayId);
void onAccessibilityButtonAvailabilityChanged(boolean available);
/** This is called when the system action list is changed. */
void onSystemActionsChanged();
}
/**
* Annotations for Soft Keyboard show modes so tools can catch invalid show modes.
* @hide
*/
@Retention(RetentionPolicy.SOURCE)
@IntDef(prefix = { "SHOW_MODE_" }, value = {
SHOW_MODE_AUTO,
SHOW_MODE_HIDDEN,
SHOW_MODE_IGNORE_HARD_KEYBOARD
})
public @interface SoftKeyboardShowMode {}
/**
* Allow the system to control when the soft keyboard is shown.
* @see SoftKeyboardController
*/
public static final int SHOW_MODE_AUTO = 0;
/**
* Never show the soft keyboard.
* @see SoftKeyboardController
*/
public static final int SHOW_MODE_HIDDEN = 1;
/**
* Allow the soft keyboard to be shown, even if a hard keyboard is connected
* @see SoftKeyboardController
*/
public static final int SHOW_MODE_IGNORE_HARD_KEYBOARD = 2;
/**
* Mask used to cover the show modes supported in public API
* @hide
*/
public static final int SHOW_MODE_MASK = 0x03;
/**
* Bit used to hold the old value of the hard IME setting to restore when a service is shut
* down.
* @hide
*/
public static final int SHOW_MODE_HARD_KEYBOARD_ORIGINAL_VALUE = 0x20000000;
/**
* Bit for show mode setting to indicate that the user has overridden the hard keyboard
* behavior.
* @hide
*/
public static final int SHOW_MODE_HARD_KEYBOARD_OVERRIDDEN = 0x40000000;
/**
* Annotations for error codes of taking screenshot.
* @hide
*/
@Retention(RetentionPolicy.SOURCE)
@IntDef(prefix = { "TAKE_SCREENSHOT_" }, value = {
ERROR_TAKE_SCREENSHOT_INTERNAL_ERROR,
ERROR_TAKE_SCREENSHOT_NO_ACCESSIBILITY_ACCESS,
ERROR_TAKE_SCREENSHOT_INTERVAL_TIME_SHORT,
ERROR_TAKE_SCREENSHOT_INVALID_DISPLAY
})
public @interface ScreenshotErrorCode {}
/**
* The status of taking screenshot is success.
* @hide
*/
public static final int TAKE_SCREENSHOT_SUCCESS = 0;
/**
* The status of taking screenshot is failure and the reason is internal error.
*/
public static final int ERROR_TAKE_SCREENSHOT_INTERNAL_ERROR = 1;
/**
* The status of taking screenshot is failure and the reason is no accessibility access.
*/
public static final int ERROR_TAKE_SCREENSHOT_NO_ACCESSIBILITY_ACCESS = 2;
/**
* The status of taking screenshot is failure and the reason is that too little time has
* elapsed since the last screenshot.
*/
public static final int ERROR_TAKE_SCREENSHOT_INTERVAL_TIME_SHORT = 3;
/**
* The status of taking screenshot is failure and the reason is invalid display Id.
*/
public static final int ERROR_TAKE_SCREENSHOT_INVALID_DISPLAY = 4;
/**
* The interval time of calling
* {@link AccessibilityService#takeScreenshot(int, Executor, Consumer)} API.
* @hide
*/
@TestApi
public static final int ACCESSIBILITY_TAKE_SCREENSHOT_REQUEST_INTERVAL_TIMES_MS = 1000;
/** @hide */
public static final String KEY_ACCESSIBILITY_SCREENSHOT_STATUS =
"screenshot_status";
/** @hide */
public static final String KEY_ACCESSIBILITY_SCREENSHOT_HARDWAREBUFFER =
"screenshot_hardwareBuffer";
/** @hide */
public static final String KEY_ACCESSIBILITY_SCREENSHOT_COLORSPACE =
"screenshot_colorSpace";
/** @hide */
public static final String KEY_ACCESSIBILITY_SCREENSHOT_TIMESTAMP =
"screenshot_timestamp";
private int mConnectionId = AccessibilityInteractionClient.NO_ID;
@UnsupportedAppUsage
private AccessibilityServiceInfo mInfo;
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P, trackingBug = 115609023)
private IBinder mWindowToken;
private WindowManager mWindowManager;
/** List of magnification controllers, mapping from displayId -> MagnificationController. */
private final SparseArray* Note: To receive gestures an accessibility service must * request that the device is in touch exploration mode by setting the * {@link AccessibilityServiceInfo#FLAG_REQUEST_TOUCH_EXPLORATION_MODE} * flag. *
* Note: The default implementation calls {@link #onGesture(int)} when the * touch screen is default display. * * @param gestureEvent The information of gesture. * * @return Whether the gesture was handled. * */ public boolean onGesture(@NonNull AccessibilityGestureEvent gestureEvent) { if (gestureEvent.getDisplayId() == Display.DEFAULT_DISPLAY) { onGesture(gestureEvent.getGestureId()); } return false; } /** * Callback that allows an accessibility service to observe the key events * before they are passed to the rest of the system. This means that the events * are first delivered here before they are passed to the device policy, the * input method, or applications. *
* Note: It is important that key events are handled in such * a way that the event stream that would be passed to the rest of the system * is well-formed. For example, handling the down event but not the up event * and vice versa would generate an inconsistent event stream. *
** Note: The key events delivered in this method are copies * and modifying them will have no effect on the events that will be passed * to the system. This method is intended to perform purely filtering * functionality. *
* * @param event The event to be processed. This event is owned by the caller and cannot be used * after this method returns. Services wishing to use the event after this method returns should * make a copy. * @return If true then the event will be consumed and not delivered to * applications, otherwise it will be delivered as usual. */ protected boolean onKeyEvent(KeyEvent event) { return false; } /** * Gets the windows on the screen of the default display. This method returns only the windows * that a sighted user can interact with, as opposed to all windows. * For example, if there is a modal dialog shown and the user cannot touch * anything behind it, then only the modal window will be reported * (assuming it is the top one). For convenience the returned windows * are ordered in a descending layer order, which is the windows that * are on top are reported first. Since the user can always * interact with the window that has input focus by typing, the focused * window is always returned (even if covered by a modal window). *
* Note: In order to access the windows your service has * to declare the capability to retrieve window content by setting the * {@link android.R.styleable#AccessibilityService_canRetrieveWindowContent} * property in its meta-data. For details refer to {@link #SERVICE_META_DATA}. * Also the service has to opt-in to retrieve the interactive windows by * setting the {@link AccessibilityServiceInfo#FLAG_RETRIEVE_INTERACTIVE_WINDOWS} * flag. *
* * @return The windows if there are windows and the service is can retrieve * them, otherwise an empty list. */ public List* Note: In order to access the windows your service has * to declare the capability to retrieve window content by setting the * {@link android.R.styleable#AccessibilityService_canRetrieveWindowContent} * property in its meta-data. For details refer to {@link #SERVICE_META_DATA}. * Also the service has to opt-in to retrieve the interactive windows by * setting the {@link AccessibilityServiceInfo#FLAG_RETRIEVE_INTERACTIVE_WINDOWS} * flag. *
* * @return The windows of all displays if there are windows and the service is can retrieve * them, otherwise an empty list. The key of SparseArray is display ID. */ @NonNull public final SparseArray* The currently active window is defined as the window that most recently fired one * of the following events: * {@link AccessibilityEvent#TYPE_WINDOW_STATE_CHANGED}, * {@link AccessibilityEvent#TYPE_VIEW_HOVER_ENTER}, * {@link AccessibilityEvent#TYPE_VIEW_HOVER_EXIT}. * In other words, the last window shown that also has input focus. *
** Note: In order to access the root node your service has * to declare the capability to retrieve window content by setting the * {@link android.R.styleable#AccessibilityService_canRetrieveWindowContent} * property in its meta-data. For details refer to {@link #SERVICE_META_DATA}. *
* * @return The root node if this service can retrieve window content. */ public AccessibilityNodeInfo getRootInActiveWindow() { return AccessibilityInteractionClient.getInstance().getRootInActiveWindow(mConnectionId); } /** * Disables the service. After calling this method, the service will be disabled and settings * will show that it is turned off. */ public final void disableSelf() { final IAccessibilityServiceConnection connection = AccessibilityInteractionClient.getInstance().getConnection(mConnectionId); if (connection != null) { try { connection.disableSelf(); } catch (RemoteException re) { throw new RuntimeException(re); } } } @Override public Context createDisplayContext(Display display) { final Context context = super.createDisplayContext(display); final int displayId = display.getDisplayId(); setDefaultTokenInternal(context, displayId); return context; } private void setDefaultTokenInternal(Context context, int displayId) { final WindowManagerImpl wm = (WindowManagerImpl) context.getSystemService(WINDOW_SERVICE); final IAccessibilityServiceConnection connection = AccessibilityInteractionClient.getInstance().getConnection(mConnectionId); IBinder token = null; if (connection != null) { synchronized (mLock) { try { token = connection.getOverlayWindowToken(displayId); } catch (RemoteException re) { Log.w(LOG_TAG, "Failed to get window token", re); re.rethrowFromSystemServer(); } } wm.setDefaultToken(token); } } /** * Returns the magnification controller, which may be used to query and * modify the state of display magnification. ** Note: In order to control magnification, your service * must declare the capability by setting the * {@link android.R.styleable#AccessibilityService_canControlMagnification} * property in its meta-data. For more information, see * {@link #SERVICE_META_DATA}. * * @return the magnification controller */ @NonNull public final MagnificationController getMagnificationController() { return getMagnificationController(Display.DEFAULT_DISPLAY); } /** * Returns the magnification controller of specified logical display, which may be used to * query and modify the state of display magnification. *
* Note: In order to control magnification, your service * must declare the capability by setting the * {@link android.R.styleable#AccessibilityService_canControlMagnification} * property in its meta-data. For more information, see * {@link #SERVICE_META_DATA}. * * @param displayId The logic display id, use {@link Display#DEFAULT_DISPLAY} for * default display. * @return the magnification controller * * @hide */ @NonNull public final MagnificationController getMagnificationController(int displayId) { synchronized (mLock) { MagnificationController controller = mMagnificationControllers.get(displayId); if (controller == null) { controller = new MagnificationController(this, mLock, displayId); mMagnificationControllers.put(displayId, controller); } return controller; } } /** * Get the controller for fingerprint gestures. This feature requires {@link * AccessibilityServiceInfo#CAPABILITY_CAN_REQUEST_FINGERPRINT_GESTURES}. * *Note: The service must be connected before this method is called. * * @return The controller for fingerprint gestures, or {@code null} if gestures are unavailable. */ @RequiresPermission(android.Manifest.permission.USE_FINGERPRINT) public final @NonNull FingerprintGestureController getFingerprintGestureController() { if (mFingerprintGestureController == null) { mFingerprintGestureController = new FingerprintGestureController( AccessibilityInteractionClient.getInstance().getConnection(mConnectionId)); } return mFingerprintGestureController; } /** * Dispatch a gesture to the touch screen. Any gestures currently in progress, whether from * the user, this service, or another service, will be cancelled. *
* The gesture will be dispatched as if it were performed directly on the screen by a user, so * the events may be affected by features such as magnification and explore by touch. *
** Note: In order to dispatch gestures, your service * must declare the capability by setting the * {@link android.R.styleable#AccessibilityService_canPerformGestures} * property in its meta-data. For more information, see * {@link #SERVICE_META_DATA}. *
* * @param gesture The gesture to dispatch * @param callback The object to call back when the status of the gesture is known. If * {@code null}, no status is reported. * @param handler The handler on which to call back the {@code callback} object. If * {@code null}, the object is called back on the service's main thread. * * @return {@code true} if the gesture is dispatched, {@code false} if not. */ public final boolean dispatchGesture(@NonNull GestureDescription gesture, @Nullable GestureResultCallback callback, @Nullable Handler handler) { final IAccessibilityServiceConnection connection = AccessibilityInteractionClient.getInstance().getConnection( mConnectionId); if (connection == null) { return false; } List* Note: If the service is not yet connected (e.g. * {@link AccessibilityService#onServiceConnected()} has not yet been * called) or the service has been disconnected, this method will * return a default value of {@code 1.0f}. * * @return the current magnification scale */ public float getScale() { final IAccessibilityServiceConnection connection = AccessibilityInteractionClient.getInstance().getConnection( mService.mConnectionId); if (connection != null) { try { return connection.getMagnificationScale(mDisplayId); } catch (RemoteException re) { Log.w(LOG_TAG, "Failed to obtain scale", re); re.rethrowFromSystemServer(); } } return 1.0f; } /** * Returns the unscaled screen-relative X coordinate of the focal * center of the magnified region. This is the point around which * zooming occurs and is guaranteed to lie within the magnified * region. *
* Note: If the service is not yet connected (e.g. * {@link AccessibilityService#onServiceConnected()} has not yet been * called) or the service has been disconnected, this method will * return a default value of {@code 0.0f}. * * @return the unscaled screen-relative X coordinate of the center of * the magnified region */ public float getCenterX() { final IAccessibilityServiceConnection connection = AccessibilityInteractionClient.getInstance().getConnection( mService.mConnectionId); if (connection != null) { try { return connection.getMagnificationCenterX(mDisplayId); } catch (RemoteException re) { Log.w(LOG_TAG, "Failed to obtain center X", re); re.rethrowFromSystemServer(); } } return 0.0f; } /** * Returns the unscaled screen-relative Y coordinate of the focal * center of the magnified region. This is the point around which * zooming occurs and is guaranteed to lie within the magnified * region. *
* Note: If the service is not yet connected (e.g. * {@link AccessibilityService#onServiceConnected()} has not yet been * called) or the service has been disconnected, this method will * return a default value of {@code 0.0f}. * * @return the unscaled screen-relative Y coordinate of the center of * the magnified region */ public float getCenterY() { final IAccessibilityServiceConnection connection = AccessibilityInteractionClient.getInstance().getConnection( mService.mConnectionId); if (connection != null) { try { return connection.getMagnificationCenterY(mDisplayId); } catch (RemoteException re) { Log.w(LOG_TAG, "Failed to obtain center Y", re); re.rethrowFromSystemServer(); } } return 0.0f; } /** * Returns the region of the screen currently active for magnification. Changes to * magnification scale and center only affect this portion of the screen. The rest of the * screen, for example input methods, cannot be magnified. This region is relative to the * unscaled screen and is independent of the scale and center point. *
* The returned region will be empty if magnification is not active. Magnification is active * if magnification gestures are enabled or if a service is running that can control * magnification. *
* Note: If the service is not yet connected (e.g. * {@link AccessibilityService#onServiceConnected()} has not yet been * called) or the service has been disconnected, this method will * return an empty region. * * @return the region of the screen currently active for magnification, or an empty region * if magnification is not active. */ @NonNull public Region getMagnificationRegion() { final IAccessibilityServiceConnection connection = AccessibilityInteractionClient.getInstance().getConnection( mService.mConnectionId); if (connection != null) { try { return connection.getMagnificationRegion(mDisplayId); } catch (RemoteException re) { Log.w(LOG_TAG, "Failed to obtain magnified region", re); re.rethrowFromSystemServer(); } } return Region.obtain(); } /** * Resets magnification scale and center to their default (e.g. no * magnification) values. *
* Note: If the service is not yet connected (e.g. * {@link AccessibilityService#onServiceConnected()} has not yet been * called) or the service has been disconnected, this method will have * no effect and return {@code false}. * * @param animate {@code true} to animate from the current scale and * center or {@code false} to reset the scale and center * immediately * @return {@code true} on success, {@code false} on failure */ public boolean reset(boolean animate) { final IAccessibilityServiceConnection connection = AccessibilityInteractionClient.getInstance().getConnection( mService.mConnectionId); if (connection != null) { try { return connection.resetMagnification(mDisplayId, animate); } catch (RemoteException re) { Log.w(LOG_TAG, "Failed to reset", re); re.rethrowFromSystemServer(); } } return false; } /** * Sets the magnification scale. *
* Note: If the service is not yet connected (e.g. * {@link AccessibilityService#onServiceConnected()} has not yet been * called) or the service has been disconnected, this method will have * no effect and return {@code false}. * * @param scale the magnification scale to set, must be >= 1 and <= 8 * @param animate {@code true} to animate from the current scale or * {@code false} to set the scale immediately * @return {@code true} on success, {@code false} on failure */ public boolean setScale(float scale, boolean animate) { final IAccessibilityServiceConnection connection = AccessibilityInteractionClient.getInstance().getConnection( mService.mConnectionId); if (connection != null) { try { return connection.setMagnificationScaleAndCenter(mDisplayId, scale, Float.NaN, Float.NaN, animate); } catch (RemoteException re) { Log.w(LOG_TAG, "Failed to set scale", re); re.rethrowFromSystemServer(); } } return false; } /** * Sets the center of the magnified viewport. *
* Note: If the service is not yet connected (e.g. * {@link AccessibilityService#onServiceConnected()} has not yet been * called) or the service has been disconnected, this method will have * no effect and return {@code false}. * * @param centerX the unscaled screen-relative X coordinate on which to * center the viewport * @param centerY the unscaled screen-relative Y coordinate on which to * center the viewport * @param animate {@code true} to animate from the current viewport * center or {@code false} to set the center immediately * @return {@code true} on success, {@code false} on failure */ public boolean setCenter(float centerX, float centerY, boolean animate) { final IAccessibilityServiceConnection connection = AccessibilityInteractionClient.getInstance().getConnection( mService.mConnectionId); if (connection != null) { try { return connection.setMagnificationScaleAndCenter(mDisplayId, Float.NaN, centerX, centerY, animate); } catch (RemoteException re) { Log.w(LOG_TAG, "Failed to set center", re); re.rethrowFromSystemServer(); } } return false; } /** * Listener for changes in the state of magnification. */ public interface OnMagnificationChangedListener { /** * Called when the magnified region, scale, or center changes. * * @param controller the magnification controller * @param region the magnification region * @param scale the new scale * @param centerX the new X coordinate, in unscaled coordinates, around which * magnification is focused * @param centerY the new Y coordinate, in unscaled coordinates, around which * magnification is focused */ void onMagnificationChanged(@NonNull MagnificationController controller, @NonNull Region region, float scale, float centerX, float centerY); } } /** * Returns the soft keyboard controller, which may be used to query and modify the soft keyboard * show mode. * * @return the soft keyboard controller */ @NonNull public final SoftKeyboardController getSoftKeyboardController() { synchronized (mLock) { if (mSoftKeyboardController == null) { mSoftKeyboardController = new SoftKeyboardController(this, mLock); } return mSoftKeyboardController; } } private void onSoftKeyboardShowModeChanged(int showMode) { if (mSoftKeyboardController != null) { mSoftKeyboardController.dispatchSoftKeyboardShowModeChanged(showMode); } } /** * Used to control, query, and listen for changes to the soft keyboard show mode. *
* Accessibility services may request to override the decisions normally made about whether or * not the soft keyboard is shown. *
* If multiple services make conflicting requests, the last request is honored. A service may * register a listener to find out if the mode has changed under it. *
* If the user takes action to override the behavior behavior requested by an accessibility * service, the user's request takes precendence, the show mode will be reset to * {@link AccessibilityService#SHOW_MODE_AUTO}, and services will no longer be able to control * that aspect of the soft keyboard's behavior. *
* Note: Because soft keyboards are independent apps, the framework does not have total control
* over their behavior. They may choose to show themselves, or not, without regard to requests
* made here. So the framework will make a best effort to deliver the behavior requested, but
* cannot guarantee success.
*
* @see AccessibilityService#SHOW_MODE_AUTO
* @see AccessibilityService#SHOW_MODE_HIDDEN
* @see AccessibilityService#SHOW_MODE_IGNORE_HARD_KEYBOARD
*/
public static final class SoftKeyboardController {
private final AccessibilityService mService;
/**
* Map of listeners to their handlers. Lazily created when adding the first
* soft keyboard change listener.
*/
private ArrayMap
* Note: If the service is not yet connected (e.g.
* {@link AccessibilityService#onServiceConnected()} has not yet been called) or the
* service has been disconnected, this method will have no effect and return {@code false}.
*
* @param showMode the new show mode for the soft keyboard
* @return {@code true} on success
*
* @see AccessibilityService#SHOW_MODE_AUTO
* @see AccessibilityService#SHOW_MODE_HIDDEN
* @see AccessibilityService#SHOW_MODE_IGNORE_HARD_KEYBOARD
*/
public boolean setShowMode(@SoftKeyboardShowMode int showMode) {
final IAccessibilityServiceConnection connection =
AccessibilityInteractionClient.getInstance().getConnection(
mService.mConnectionId);
if (connection != null) {
try {
return connection.setSoftKeyboardShowMode(showMode);
} catch (RemoteException re) {
Log.w(LOG_TAG, "Failed to set soft keyboard behavior", re);
re.rethrowFromSystemServer();
}
}
return false;
}
/**
* Listener for changes in the soft keyboard show mode.
*/
public interface OnShowModeChangedListener {
/**
* Called when the soft keyboard behavior changes. The default show mode is
* {@code SHOW_MODE_AUTO}, where the soft keyboard is shown when a text input field is
* focused. An AccessibilityService can also request the show mode
* {@code SHOW_MODE_HIDDEN}, where the soft keyboard is never shown.
*
* @param controller the soft keyboard controller
* @param showMode the current soft keyboard show mode
*/
void onShowModeChanged(@NonNull SoftKeyboardController controller,
@SoftKeyboardShowMode int showMode);
}
/**
* Switches the current IME for the user for whom the service is enabled. The change will
* persist until the current IME is explicitly changed again, and may persist beyond the
* life cycle of the requesting service.
*
* @param imeId The ID of the input method to make current. This IME must be installed and
* enabled.
* @return {@code true} if the current input method was successfully switched to the input
* method by {@code imeId},
* {@code false} if the input method specified is not installed, not enabled, or
* otherwise not available to become the current IME
*
* @see android.view.inputmethod.InputMethodInfo#getId()
*/
public boolean switchToInputMethod(@NonNull String imeId) {
final IAccessibilityServiceConnection connection =
AccessibilityInteractionClient.getInstance().getConnection(
mService.mConnectionId);
if (connection != null) {
try {
return connection.switchToInputMethod(imeId);
} catch (RemoteException re) {
throw new RuntimeException(re);
}
}
return false;
}
}
/**
* Returns the controller for the accessibility button within the system's navigation area.
* This instance may be used to query the accessibility button's state and register listeners
* for interactions with and state changes for the accessibility button when
* {@link AccessibilityServiceInfo#FLAG_REQUEST_ACCESSIBILITY_BUTTON} is set.
*
* Note: Not all devices are capable of displaying the accessibility button
* within a navigation area, and as such, use of this class should be considered only as an
* optional feature or shortcut on supported device implementations.
*
* Note: Not all devices are capable of displaying the accessibility button
* within a navigation area, and as such, use of this class should be considered only as an
* optional feature or shortcut on supported device implementations.
*
* System actions that correspond to the global action constants will have matching action IDs.
* For example, an with id {@link #GLOBAL_ACTION_BACK} will perform the back action.
*
* These actions should be called by {@link #performGlobalAction}.
*
* Note: In order to access the windows your service has
* to declare the capability to retrieve window content by setting the
* {@link android.R.styleable#AccessibilityService_canRetrieveWindowContent}
* property in its meta-data. For details refer to {@link #SERVICE_META_DATA}.
* Also the service has to opt-in to retrieve the interactive windows by
* setting the {@link AccessibilityServiceInfo#FLAG_RETRIEVE_INTERACTIVE_WINDOWS}
* flag. Otherwise, the search will be performed only in the active window.
*
* Note: If the view with {@link AccessibilityNodeInfo#FOCUS_INPUT}
* is on an embedded view hierarchy which is embedded in a {@link SurfaceView} via
* {@link SurfaceView#setChildSurfacePackage}, there is a limitation that this API
* won't be able to find the node for the view. It's because views don't know about
* the embedded hierarchies. Instead, you could traverse all the nodes to find the
* focus.
*
* Note: You can call this method any time but the info will be picked up after
* the system has bound to this service and when this method is called thereafter.
*
* @param info The info.
*/
public final void setServiceInfo(AccessibilityServiceInfo info) {
mInfo = info;
sendServiceInfo();
}
/**
* Sets the {@link AccessibilityServiceInfo} for this service if the latter is
* properly set and there is an {@link IAccessibilityServiceConnection} to the
* AccessibilityManagerService.
*/
private void sendServiceInfo() {
IAccessibilityServiceConnection connection =
AccessibilityInteractionClient.getInstance().getConnection(mConnectionId);
if (mInfo != null && connection != null) {
try {
connection.setServiceInfo(mInfo);
mInfo = null;
AccessibilityInteractionClient.getInstance().clearCache();
} catch (RemoteException re) {
Log.w(LOG_TAG, "Error while setting AccessibilityServiceInfo", re);
re.rethrowFromSystemServer();
}
}
}
@Override
public Object getSystemService(@ServiceName @NonNull String name) {
if (getBaseContext() == null) {
throw new IllegalStateException(
"System services not available to Activities before onCreate()");
}
// Guarantee that we always return the same window manager instance.
if (WINDOW_SERVICE.equals(name)) {
if (mWindowManager == null) {
mWindowManager = (WindowManager) getBaseContext().getSystemService(name);
}
return mWindowManager;
}
return super.getSystemService(name);
}
/**
* Takes a screenshot of the specified display and returns it via an
* {@link AccessibilityService.ScreenshotResult}. You can use {@link Bitmap#wrapHardwareBuffer}
* to construct the bitmap from the ScreenshotResult's payload.
*
* Note: In order to take screenshot your service has
* to declare the capability to take screenshot by setting the
* {@link android.R.styleable#AccessibilityService_canTakeScreenshot}
* property in its meta-data. For details refer to {@link #SERVICE_META_DATA}.
*
* Note: The application should call {@link HardwareBuffer#close()} when
* the buffer is no longer needed to free the underlying resources.
*