AccessibilityService.java revision 0846e29d0b5640cfad4496c8484fb9aaa2ba4ccf
1/* 2 * Copyright (C) 2009 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17package android.accessibilityservice; 18 19import android.app.Service; 20import android.content.Context; 21import android.content.Intent; 22import android.content.res.Configuration; 23import android.os.IBinder; 24import android.os.Looper; 25import android.os.Message; 26import android.os.RemoteException; 27import android.util.LocaleUtil; 28import android.util.Log; 29import android.view.View; 30import android.view.accessibility.AccessibilityEvent; 31import android.view.accessibility.AccessibilityInteractionClient; 32import android.view.accessibility.AccessibilityNodeInfo; 33 34import com.android.internal.os.HandlerCaller; 35 36import java.util.Locale; 37 38/** 39 * An accessibility service runs in the background and receives callbacks by the system 40 * when {@link AccessibilityEvent}s are fired. Such events denote some state transition 41 * in the user interface, for example, the focus has changed, a button has been clicked, 42 * etc. Such a service can optionally request the capability for querying the content 43 * of the active window. Development of an accessibility service requires extending this 44 * class and implementing its abstract methods. 45 * 46 * <div class="special reference"> 47 * <h3>Developer Guides</h3> 48 * <p>For more information about creating AccessibilityServices, read the 49 * <a href="{@docRoot}guide/topics/ui/accessibility/index.html">Accessibility</a> 50 * developer guide.</p> 51 * </div> 52 * 53 * <h3>Lifecycle</h3> 54 * <p> 55 * The lifecycle of an accessibility service is managed exclusively by the system and 56 * follows the established service life cycle. Additionally, starting or stopping an 57 * accessibility service is triggered exclusively by an explicit user action through 58 * enabling or disabling it in the device settings. After the system binds to a service it 59 * calls {@link AccessibilityService#onServiceConnected()}. This method can be 60 * overriden by clients that want to perform post binding setup. 61 * </p> 62 * <h3>Declaration</h3> 63 * <p> 64 * An accessibility is declared as any other service in an AndroidManifest.xml but it 65 * must also specify that it handles the "android.accessibilityservice.AccessibilityService" 66 * {@link android.content.Intent}. Failure to declare this intent will cause the system to 67 * ignore the accessibility service. Following is an example declaration: 68 * </p> 69 * <pre> <service android:name=".MyAccessibilityService"> 70 * <intent-filter> 71 * <action android:name="android.accessibilityservice.AccessibilityService" /> 72 * </intent-filter> 73 * . . . 74 * </service></pre> 75 * <h3>Configuration</h3> 76 * <p> 77 * An accessibility service can be configured to receive specific types of accessibility events, 78 * listen only to specific packages, get events from each type only once in a given time frame, 79 * retrieve window content, specify a settings activity, etc. 80 * </p> 81 * <p> 82 * There are two approaches for configuring an accessibility service: 83 * </p> 84 * <ul> 85 * <li> 86 * Providing a {@link #SERVICE_META_DATA meta-data} entry in the manifest when declaring 87 * the service. A service declaration with a meta-data tag is presented below: 88 * <pre> <service android:name=".MyAccessibilityService"> 89 * <intent-filter> 90 * <action android:name="android.accessibilityservice.AccessibilityService" /> 91 * </intent-filter> 92 * <meta-data android:name="android.accessibilityservice" android:resource="@xml/accessibilityservice" /> 93 * </service></pre> 94 * <p class="note"> 95 * <strong>Note:</strong> This approach enables setting all properties. 96 * </p> 97 * <p> 98 * For more details refer to {@link #SERVICE_META_DATA} and 99 * <code><{@link android.R.styleable#AccessibilityService accessibility-service}></code>. 100 * </p> 101 * </li> 102 * <li> 103 * Calling {@link AccessibilityService#setServiceInfo(AccessibilityServiceInfo)}. Note 104 * that this method can be called any time to dynamically change the service configuration. 105 * <p class="note"> 106 * <strong>Note:</strong> This approach enables setting only dynamically configurable properties: 107 * {@link AccessibilityServiceInfo#eventTypes}, 108 * {@link AccessibilityServiceInfo#feedbackType}, 109 * {@link AccessibilityServiceInfo#flags}, 110 * {@link AccessibilityServiceInfo#notificationTimeout}, 111 * {@link AccessibilityServiceInfo#packageNames} 112 * </p> 113 * <p> 114 * For more details refer to {@link AccessibilityServiceInfo}. 115 * </p> 116 * </li> 117 * </ul> 118 * <h3>Retrieving window content</h3> 119 * <p> 120 * A service can specify in its declaration that it can retrieve the active window 121 * content which is represented as a tree of {@link AccessibilityNodeInfo}. Note that 122 * declaring this capability requires that the service declares its configuration via 123 * an XML resource referenced by {@link #SERVICE_META_DATA}. 124 * </p> 125 * <p> 126 * For security purposes an accessibility service can retrieve only the content of the 127 * currently active window. The currently active window is defined as the window from 128 * which was fired the last event of the following types: 129 * {@link AccessibilityEvent#TYPE_WINDOW_STATE_CHANGED}, 130 * {@link AccessibilityEvent#TYPE_VIEW_HOVER_ENTER}, 131 * {@link AccessibilityEvent#TYPE_VIEW_HOVER_EXIT}, 132 * In other words, the last window that was shown or the last window that the user has touched 133 * during touch exploration. 134 * </p> 135 * <p> 136 * The entry point for retrieving window content is through calling 137 * {@link AccessibilityEvent#getSource() AccessibilityEvent.getSource()} of the last received 138 * event of the above types or a previous event from the same window 139 * (see {@link AccessibilityEvent#getWindowId() AccessibilityEvent.getWindowId()}). Invoking 140 * this method will return an {@link AccessibilityNodeInfo} that can be used to traverse the 141 * window content which represented as a tree of such objects. 142 * </p> 143 * <p class="note"> 144 * <strong>Note</strong> An accessibility service may have requested to be notified for 145 * a subset of the event types, thus be unaware that the active window has changed. Therefore 146 * accessibility service that would like to retrieve window content should: 147 * <ul> 148 * <li> 149 * Register for all event types with no notification timeout and keep track for the active 150 * window by calling {@link AccessibilityEvent#getWindowId()} of the last received event and 151 * compare this with the {@link AccessibilityNodeInfo#getWindowId()} before calling retrieval 152 * methods on the latter. 153 * </li> 154 * <li> 155 * Prepare that a retrieval method on {@link AccessibilityNodeInfo} may fail since the 156 * active window has changed and the service did not get the accessibility event yet. Note 157 * that it is possible to have a retrieval method failing even adopting the strategy 158 * specified in the previous bullet because the accessibility event dispatch is asynchronous 159 * and crosses process boundaries. 160 * </li> 161 * </ul> 162 * </p> 163 * <h3>Notification strategy</h3> 164 * <p> 165 * For each feedback type only one accessibility service is notified. Services are notified 166 * in the order of registration. Hence, if two services are registered for the same 167 * feedback type in the same package the first one wins. It is possible however, to 168 * register a service as the default one for a given feedback type. In such a case this 169 * service is invoked if no other service was interested in the event. In other words, default 170 * services do not compete with other services and are notified last regardless of the 171 * registration order. This enables "generic" accessibility services that work reasonably 172 * well with most applications to coexist with "polished" ones that are targeted for 173 * specific applications. 174 * </p> 175 * <p class="note"> 176 * <strong>Note:</strong> The event notification timeout is useful to avoid propagating 177 * events to the client too frequently since this is accomplished via an expensive 178 * interprocess call. One can think of the timeout as a criteria to determine when 179 * event generation has settled down.</p> 180 * <h3>Event types</h3> 181 * <ul> 182 * <li>{@link AccessibilityEvent#TYPE_VIEW_CLICKED} 183 * <li>{@link AccessibilityEvent#TYPE_VIEW_LONG_CLICKED} 184 * <li>{@link AccessibilityEvent#TYPE_VIEW_FOCUSED} 185 * <li>{@link AccessibilityEvent#TYPE_VIEW_SELECTED} 186 * <li>{@link AccessibilityEvent#TYPE_VIEW_TEXT_CHANGED} 187 * <li>{@link AccessibilityEvent#TYPE_WINDOW_STATE_CHANGED} 188 * <li>{@link AccessibilityEvent#TYPE_NOTIFICATION_STATE_CHANGED} 189 * <li>{@link AccessibilityEvent#TYPE_TOUCH_EXPLORATION_GESTURE_START} 190 * <li>{@link AccessibilityEvent#TYPE_TOUCH_EXPLORATION_GESTURE_END} 191 * <li>{@link AccessibilityEvent#TYPE_VIEW_HOVER_ENTER} 192 * <li>{@link AccessibilityEvent#TYPE_VIEW_HOVER_EXIT} 193 * <li>{@link AccessibilityEvent#TYPE_VIEW_SCROLLED} 194 * <li>{@link AccessibilityEvent#TYPE_VIEW_TEXT_SELECTION_CHANGED} 195 * <li>{@link AccessibilityEvent#TYPE_WINDOW_CONTENT_CHANGED} 196 * </ul> 197 * <h3>Feedback types</h3> 198 * <ul> 199 * <li>{@link AccessibilityServiceInfo#FEEDBACK_AUDIBLE} 200 * <li>{@link AccessibilityServiceInfo#FEEDBACK_HAPTIC} 201 * <li>{@link AccessibilityServiceInfo#FEEDBACK_AUDIBLE} 202 * <li>{@link AccessibilityServiceInfo#FEEDBACK_VISUAL} 203 * <li>{@link AccessibilityServiceInfo#FEEDBACK_GENERIC} 204 * </ul> 205 * @see AccessibilityEvent 206 * @see AccessibilityServiceInfo 207 * @see android.view.accessibility.AccessibilityManager 208 */ 209public abstract class AccessibilityService extends Service { 210 211 /** 212 * The user has performed a swipe up gesture on the touch screen. 213 */ 214 public static final int GESTURE_SWIPE_UP = 1; 215 216 /** 217 * The user has performed a swipe down gesture on the touch screen. 218 */ 219 public static final int GESTURE_SWIPE_DOWN = 2; 220 221 /** 222 * The user has performed a swipe left gesture on the touch screen. 223 */ 224 public static final int GESTURE_SWIPE_LEFT = 3; 225 226 /** 227 * The user has performed a swipe right gesture on the touch screen. 228 */ 229 public static final int GESTURE_SWIPE_RIGHT = 4; 230 231 /** 232 * The user has performed a swipe left and right gesture on the touch screen. 233 */ 234 public static final int GESTURE_SWIPE_LEFT_AND_RIGHT = 5; 235 236 /** 237 * The user has performed a swipe right and left gesture on the touch screen. 238 */ 239 public static final int GESTURE_SWIPE_RIGHT_AND_LEFT = 6; 240 241 /** 242 * The user has performed a swipe up and down gesture on the touch screen. 243 */ 244 public static final int GESTURE_SWIPE_UP_AND_DOWN = 7; 245 246 /** 247 * The user has performed a swipe down and up gesture on the touch screen. 248 */ 249 public static final int GESTURE_SWIPE_DOWN_AND_UP = 8; 250 251 /** 252 * The user has performed a clockwise circle gesture on the touch screen. 253 */ 254 public static final int GESTURE_CLOCKWISE_CIRCLE = 9; 255 256 /** 257 * The user has performed a counter clockwise circle gesture on the touch screen. 258 */ 259 public static final int GESTURE_COUNTER_CLOCKWISE_CIRCLE = 10; 260 261 /** 262 * The user has performed a left and up gesture on the touch screen. 263 */ 264 public static final int GESTURE_SWIPE_LEFT_AND_UP = 11; 265 266 /** 267 * The user has performed a left and down gesture on the touch screen. 268 */ 269 public static final int GESTURE_SWIPE_LEFT_AND_DOWN = 12; 270 271 /** 272 * The user has performed a right and up gesture on the touch screen. 273 */ 274 public static final int GESTURE_SWIPE_RIGHT_AND_UP = 13; 275 276 /** 277 * The user has performed a right and down gesture on the touch screen. 278 */ 279 public static final int GESTURE_SWIPE_RIGHT_AND_DOWN = 14; 280 281 /** 282 * The user has performed an up and left gesture on the touch screen. 283 */ 284 public static final int GESTURE_SWIPE_UP_AND_LEFT = 15; 285 286 /** 287 * The user has performed an up and right gesture on the touch screen. 288 */ 289 public static final int GESTURE_SWIPE_UP_AND_RIGHT = 16; 290 291 /** 292 * The user has performed an down and left gesture on the touch screen. 293 */ 294 public static final int GESTURE_SWIPE_DOWN_AND_LEFT = 17; 295 296 /** 297 * The user has performed an down and right gesture on the touch screen. 298 */ 299 public static final int GESTURE_SWIPE_DOWN_AND_RIGHT = 18; 300 301 /** 302 * The {@link Intent} that must be declared as handled by the service. 303 */ 304 public static final String SERVICE_INTERFACE = 305 "android.accessibilityservice.AccessibilityService"; 306 307 /** 308 * Name under which an AccessibilityService component publishes information 309 * about itself. This meta-data must reference an XML resource containing an 310 * <code><{@link android.R.styleable#AccessibilityService accessibility-service}></code> 311 * tag. This is a a sample XML file configuring an accessibility service: 312 * <pre> <accessibility-service 313 * android:accessibilityEventTypes="typeViewClicked|typeViewFocused" 314 * android:packageNames="foo.bar, foo.baz" 315 * android:accessibilityFeedbackType="feedbackSpoken" 316 * android:notificationTimeout="100" 317 * android:accessibilityFlags="flagDefault" 318 * android:settingsActivity="foo.bar.TestBackActivity" 319 * android:canRetrieveWindowContent="true" 320 * . . . 321 * /></pre> 322 */ 323 public static final String SERVICE_META_DATA = "android.accessibilityservice"; 324 325 /** 326 * Action to go back. 327 */ 328 public static final int GLOBAL_ACTION_BACK = 1; 329 330 /** 331 * Action to go home. 332 */ 333 public static final int GLOBAL_ACTION_HOME = 2; 334 335 /** 336 * Action to open the recents. 337 */ 338 public static final int GLOBAL_ACTION_RECENTS = 3; 339 340 /** 341 * Action to open the notifications. 342 */ 343 public static final int GLOBAL_ACTION_NOTIFICATIONS = 4; 344 345 private static final int UNDEFINED = -1; 346 347 private static final String LOG_TAG = "AccessibilityService"; 348 349 interface Callbacks { 350 public void onAccessibilityEvent(AccessibilityEvent event); 351 public void onInterrupt(); 352 public void onServiceConnected(); 353 public void onSetConnectionId(int connectionId); 354 public void onGesture(int gestureId); 355 } 356 357 private int mConnectionId; 358 359 private AccessibilityServiceInfo mInfo; 360 361 private int mLayoutDirection; 362 363 /** 364 * Callback for {@link android.view.accessibility.AccessibilityEvent}s. 365 * 366 * @param event An event. 367 */ 368 public abstract void onAccessibilityEvent(AccessibilityEvent event); 369 370 /** 371 * Callback for interrupting the accessibility feedback. 372 */ 373 public abstract void onInterrupt(); 374 375 /** 376 * This method is a part of the {@link AccessibilityService} lifecycle and is 377 * called after the system has successfully bound to the service. If is 378 * convenient to use this method for setting the {@link AccessibilityServiceInfo}. 379 * 380 * @see AccessibilityServiceInfo 381 * @see #setServiceInfo(AccessibilityServiceInfo) 382 */ 383 protected void onServiceConnected() { 384 385 } 386 387 /** 388 * Called by the system when the user performs a specific gesture on the 389 * touch screen. 390 * 391 * @param gestureId The unique id of the performed gesture. 392 * 393 * @see #GESTURE_SWIPE_UP 394 * @see #GESTURE_SWIPE_DOWN 395 * @see #GESTURE_SWIPE_LEFT 396 * @see #GESTURE_SWIPE_RIGHT 397 * @see #GESTURE_SWIPE_UP_AND_DOWN 398 * @see #GESTURE_SWIPE_DOWN_AND_UP 399 * @see #GESTURE_SWIPE_LEFT_AND_RIGHT 400 * @see #GESTURE_SWIPE_RIGHT_AND_LEFT 401 * @see #GESTURE_CLOCKWISE_CIRCLE 402 * @see #GESTURE_COUNTER_CLOCKWISE_CIRCLE 403 */ 404 protected void onGesture(int gestureId) { 405 // TODO: Describe the default gesture processing in the javaDoc once it is finalized. 406 407 // Global actions. 408 switch (gestureId) { 409 case GESTURE_SWIPE_DOWN_AND_LEFT: { 410 performGlobalAction(GLOBAL_ACTION_BACK); 411 } return; 412 case GESTURE_SWIPE_DOWN_AND_RIGHT: { 413 performGlobalAction(GLOBAL_ACTION_HOME); 414 } return; 415 case GESTURE_SWIPE_UP_AND_LEFT: { 416 performGlobalAction(GLOBAL_ACTION_RECENTS); 417 } return; 418 case GESTURE_SWIPE_UP_AND_RIGHT: { 419 performGlobalAction(GLOBAL_ACTION_NOTIFICATIONS); 420 } return; 421 } 422 423 // Cache the id to avoid locking 424 final int connectionId = mConnectionId; 425 if (connectionId == UNDEFINED) { 426 throw new IllegalStateException("AccessibilityService not connected." 427 + " Did you receive a call of onServiceConnected()?"); 428 } 429 AccessibilityNodeInfo root = getRootInActiveWindow(); 430 if (root == null) { 431 return; 432 } 433 434 AccessibilityNodeInfo current = root.findFocus(AccessibilityNodeInfo.FOCUS_ACCESSIBILITY); 435 if (current == null) { 436 current = root; 437 } 438 439 // Local actions. 440 AccessibilityNodeInfo next = null; 441 switch (gestureId) { 442 case GESTURE_SWIPE_UP: { 443 next = current.focusSearch(View.ACCESSIBILITY_FOCUS_OUT); 444 } break; 445 case GESTURE_SWIPE_DOWN: { 446 next = current.focusSearch(View.ACCESSIBILITY_FOCUS_IN); 447 } break; 448 case GESTURE_SWIPE_LEFT: { 449 if (mLayoutDirection == View.LAYOUT_DIRECTION_LTR) { 450 next = current.focusSearch(View.ACCESSIBILITY_FOCUS_BACKWARD); 451 } else { // LAYOUT_DIRECTION_RTL 452 next = current.focusSearch(View.ACCESSIBILITY_FOCUS_FORWARD); 453 } 454 } break; 455 case GESTURE_SWIPE_RIGHT: { 456 if (mLayoutDirection == View.LAYOUT_DIRECTION_LTR) { 457 next = current.focusSearch(View.ACCESSIBILITY_FOCUS_FORWARD); 458 } else { // LAYOUT_DIRECTION_RTL 459 next = current.focusSearch(View.ACCESSIBILITY_FOCUS_BACKWARD); 460 } 461 } break; 462 case GESTURE_SWIPE_UP_AND_DOWN: { 463 next = current.focusSearch(View.ACCESSIBILITY_FOCUS_UP); 464 } break; 465 case GESTURE_SWIPE_DOWN_AND_UP: { 466 next = current.focusSearch(View.ACCESSIBILITY_FOCUS_DOWN); 467 } break; 468 case GESTURE_SWIPE_LEFT_AND_RIGHT: { 469 next = current.focusSearch(View.ACCESSIBILITY_FOCUS_LEFT); 470 } break; 471 case GESTURE_SWIPE_RIGHT_AND_LEFT: { 472 next = current.focusSearch(View.ACCESSIBILITY_FOCUS_RIGHT); 473 } break; 474 } 475 if (next != null && !next.equals(current)) { 476 next.performAction(AccessibilityNodeInfo.ACTION_ACCESSIBILITY_FOCUS); 477 } 478 } 479 480 /** 481 * Gets the root node in the currently active window if this service 482 * can retrieve window content. 483 * 484 * @return The root node if this service can retrieve window content. 485 */ 486 public AccessibilityNodeInfo getRootInActiveWindow() { 487 return AccessibilityInteractionClient.getInstance() 488 .findAccessibilityNodeInfoByAccessibilityId(mConnectionId, 489 AccessibilityNodeInfo.ACTIVE_WINDOW_ID, AccessibilityNodeInfo.ROOT_NODE_ID, 490 AccessibilityNodeInfo.FLAG_PREFETCH_DESCENDANTS); 491 } 492 493 /** 494 * Performs a global action. Such an action can be performed 495 * at any moment regardless of the current application or user 496 * location in that application. For example going back, going 497 * home, opening recents, etc. 498 * 499 * @param action The action to perform. 500 * @return Whether the action was successfully performed. 501 * 502 * @see #GLOBAL_ACTION_BACK 503 * @see #GLOBAL_ACTION_HOME 504 * @see #GLOBAL_ACTION_NOTIFICATIONS 505 * @see #GLOBAL_ACTION_RECENTS 506 */ 507 public final boolean performGlobalAction(int action) { 508 IAccessibilityServiceConnection connection = 509 AccessibilityInteractionClient.getInstance().getConnection(mConnectionId); 510 if (connection != null) { 511 try { 512 return connection.perfromGlobalAction(action); 513 } catch (RemoteException re) { 514 Log.w(LOG_TAG, "Error while calling performGlobalAction", re); 515 } 516 } 517 return false; 518 } 519 520 /** 521 * Gets the an {@link AccessibilityServiceInfo} describing this 522 * {@link AccessibilityService}. This method is useful if one wants 523 * to change some of the dynamically configurable properties at 524 * runtime. 525 * 526 * @return The accessibility service info. 527 * 528 * @see AccessibilityNodeInfo 529 */ 530 public final AccessibilityServiceInfo getServiceInfo() { 531 IAccessibilityServiceConnection connection = 532 AccessibilityInteractionClient.getInstance().getConnection(mConnectionId); 533 if (connection != null) { 534 try { 535 return connection.getServiceInfo(); 536 } catch (RemoteException re) { 537 Log.w(LOG_TAG, "Error while getting AccessibilityServiceInfo", re); 538 } 539 } 540 return null; 541 } 542 543 /** 544 * Sets the {@link AccessibilityServiceInfo} that describes this service. 545 * <p> 546 * Note: You can call this method any time but the info will be picked up after 547 * the system has bound to this service and when this method is called thereafter. 548 * 549 * @param info The info. 550 */ 551 public final void setServiceInfo(AccessibilityServiceInfo info) { 552 mInfo = info; 553 sendServiceInfo(); 554 } 555 556 /** 557 * Sets the {@link AccessibilityServiceInfo} for this service if the latter is 558 * properly set and there is an {@link IAccessibilityServiceConnection} to the 559 * AccessibilityManagerService. 560 */ 561 private void sendServiceInfo() { 562 IAccessibilityServiceConnection connection = 563 AccessibilityInteractionClient.getInstance().getConnection(mConnectionId); 564 if (mInfo != null && connection != null) { 565 try { 566 connection.setServiceInfo(mInfo); 567 mInfo = null; 568 AccessibilityInteractionClient.getInstance().clearCache(); 569 } catch (RemoteException re) { 570 Log.w(LOG_TAG, "Error while setting AccessibilityServiceInfo", re); 571 } 572 } 573 } 574 575 @Override 576 public void onCreate() { 577 Locale locale = getResources().getConfiguration().locale; 578 mLayoutDirection = LocaleUtil.getLayoutDirectionFromLocale(locale); 579 } 580 581 @Override 582 public void onConfigurationChanged(Configuration configuration) { 583 super.onConfigurationChanged(configuration); 584 mLayoutDirection = LocaleUtil.getLayoutDirectionFromLocale(configuration.locale); 585 } 586 587 /** 588 * Implement to return the implementation of the internal accessibility 589 * service interface. 590 */ 591 @Override 592 public final IBinder onBind(Intent intent) { 593 return new IAccessibilityServiceClientWrapper(this, getMainLooper(), new Callbacks() { 594 @Override 595 public void onServiceConnected() { 596 AccessibilityService.this.onServiceConnected(); 597 } 598 599 @Override 600 public void onInterrupt() { 601 AccessibilityService.this.onInterrupt(); 602 } 603 604 @Override 605 public void onAccessibilityEvent(AccessibilityEvent event) { 606 AccessibilityService.this.onAccessibilityEvent(event); 607 } 608 609 @Override 610 public void onSetConnectionId( int connectionId) { 611 mConnectionId = connectionId; 612 } 613 614 @Override 615 public void onGesture(int gestureId) { 616 AccessibilityService.this.onGesture(gestureId); 617 } 618 }); 619 } 620 621 /** 622 * Implements the internal {@link IAccessibilityServiceClient} interface to convert 623 * incoming calls to it back to calls on an {@link AccessibilityService}. 624 */ 625 static class IAccessibilityServiceClientWrapper extends IAccessibilityServiceClient.Stub 626 implements HandlerCaller.Callback { 627 628 static final int NO_ID = -1; 629 630 private static final int DO_SET_SET_CONNECTION = 10; 631 private static final int DO_ON_INTERRUPT = 20; 632 private static final int DO_ON_ACCESSIBILITY_EVENT = 30; 633 private static final int DO_ON_GESTURE = 40; 634 635 private final HandlerCaller mCaller; 636 637 private final Callbacks mCallback; 638 639 public IAccessibilityServiceClientWrapper(Context context, Looper looper, 640 Callbacks callback) { 641 mCallback = callback; 642 mCaller = new HandlerCaller(context, looper, this); 643 } 644 645 public void setConnection(IAccessibilityServiceConnection connection, int connectionId) { 646 Message message = mCaller.obtainMessageIO(DO_SET_SET_CONNECTION, connectionId, 647 connection); 648 mCaller.sendMessage(message); 649 } 650 651 public void onInterrupt() { 652 Message message = mCaller.obtainMessage(DO_ON_INTERRUPT); 653 mCaller.sendMessage(message); 654 } 655 656 public void onAccessibilityEvent(AccessibilityEvent event) { 657 Message message = mCaller.obtainMessageO(DO_ON_ACCESSIBILITY_EVENT, event); 658 mCaller.sendMessage(message); 659 } 660 661 public void onGesture(int gestureId) { 662 Message message = mCaller.obtainMessageI(DO_ON_GESTURE, gestureId); 663 mCaller.sendMessage(message); 664 } 665 666 public void executeMessage(Message message) { 667 switch (message.what) { 668 case DO_ON_ACCESSIBILITY_EVENT : 669 AccessibilityEvent event = (AccessibilityEvent) message.obj; 670 if (event != null) { 671 AccessibilityInteractionClient.getInstance().onAccessibilityEvent(event); 672 mCallback.onAccessibilityEvent(event); 673 event.recycle(); 674 } 675 return; 676 case DO_ON_INTERRUPT : 677 mCallback.onInterrupt(); 678 return; 679 case DO_SET_SET_CONNECTION : 680 final int connectionId = message.arg1; 681 IAccessibilityServiceConnection connection = 682 (IAccessibilityServiceConnection) message.obj; 683 if (connection != null) { 684 AccessibilityInteractionClient.getInstance().addConnection(connectionId, 685 connection); 686 mCallback.onSetConnectionId(connectionId); 687 mCallback.onServiceConnected(); 688 } else { 689 AccessibilityInteractionClient.getInstance().removeConnection(connectionId); 690 mCallback.onSetConnectionId(AccessibilityInteractionClient.NO_ID); 691 } 692 return; 693 case DO_ON_GESTURE : 694 final int gestureId = message.arg1; 695 mCallback.onGesture(gestureId); 696 return; 697 default : 698 Log.w(LOG_TAG, "Unknown message type " + message.what); 699 } 700 } 701 } 702} 703