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 17 package android.view.accessibility; 18 19 import android.accessibilityservice.AccessibilityServiceInfo; 20 import android.accessibilityservice.AccessibilityServiceInfo.FeedbackType; 21 import android.annotation.NonNull; 22 import android.annotation.Nullable; 23 import android.content.Context; 24 import android.content.pm.ServiceInfo; 25 import android.os.Handler; 26 import android.view.IWindow; 27 import android.view.View; 28 import android.view.accessibility.AccessibilityEvent.EventType; 29 30 import java.util.Collections; 31 import java.util.List; 32 33 /** 34 * System level service that serves as an event dispatch for {@link AccessibilityEvent}s. 35 * Such events are generated when something notable happens in the user interface, 36 * for example an {@link android.app.Activity} starts, the focus or selection of a 37 * {@link android.view.View} changes etc. Parties interested in handling accessibility 38 * events implement and register an accessibility service which extends 39 * {@code android.accessibilityservice.AccessibilityService}. 40 * 41 * @see AccessibilityEvent 42 * @see android.content.Context#getSystemService 43 */ 44 @SuppressWarnings("UnusedDeclaration") 45 public final class AccessibilityManager { 46 47 private static AccessibilityManager sInstance = new AccessibilityManager(null, null, 0); 48 49 50 /** 51 * Listener for the accessibility state. 52 */ 53 public interface AccessibilityStateChangeListener { 54 55 /** 56 * Called back on change in the accessibility state. 57 * 58 * @param enabled Whether accessibility is enabled. 59 */ 60 public void onAccessibilityStateChanged(boolean enabled); 61 } 62 63 /** 64 * Listener for the system touch exploration state. To listen for changes to 65 * the touch exploration state on the device, implement this interface and 66 * register it with the system by calling 67 * {@link #addTouchExplorationStateChangeListener}. 68 */ 69 public interface TouchExplorationStateChangeListener { 70 71 /** 72 * Called when the touch exploration enabled state changes. 73 * 74 * @param enabled Whether touch exploration is enabled. 75 */ 76 public void onTouchExplorationStateChanged(boolean enabled); 77 } 78 79 /** 80 * Listener for the system high text contrast state. To listen for changes to 81 * the high text contrast state on the device, implement this interface and 82 * register it with the system by calling 83 * {@link #addHighTextContrastStateChangeListener}. 84 */ 85 public interface HighTextContrastChangeListener { 86 87 /** 88 * Called when the high text contrast enabled state changes. 89 * 90 * @param enabled Whether high text contrast is enabled. 91 */ 92 public void onHighTextContrastStateChanged(boolean enabled); 93 } 94 95 /** 96 * Policy to inject behavior into the accessibility manager. 97 * 98 * @hide 99 */ 100 public interface AccessibilityPolicy { 101 /** 102 * Checks whether accessibility is enabled. 103 * 104 * @param accessibilityEnabled Whether the accessibility layer is enabled. 105 * @return whether accessibility is enabled. 106 */ 107 boolean isEnabled(boolean accessibilityEnabled); 108 109 /** 110 * Notifies the policy for an accessibility event. 111 * 112 * @param event The event. 113 * @param accessibilityEnabled Whether the accessibility layer is enabled. 114 * @param relevantEventTypes The events relevant events. 115 * @return The event to dispatch or null. 116 */ 117 @Nullable AccessibilityEvent onAccessibilityEvent(@NonNull AccessibilityEvent event, 118 boolean accessibilityEnabled, @EventType int relevantEventTypes); 119 120 /** 121 * Gets the list of relevant events. 122 * 123 * @param relevantEventTypes The relevant events. 124 * @return The relevant events to report. 125 */ 126 @EventType int getRelevantEventTypes(@EventType int relevantEventTypes); 127 128 /** 129 * Gets the list of installed services to report. 130 * 131 * @param installedService The installed services. 132 * @return The services to report. 133 */ 134 @NonNull List<AccessibilityServiceInfo> getInstalledAccessibilityServiceList( 135 @Nullable List<AccessibilityServiceInfo> installedService); 136 137 /** 138 * Gets the list of enabled accessibility services. 139 * 140 * @param feedbackTypeFlags The feedback type to query for. 141 * @param enabledService The enabled services. 142 * @return The services to report. 143 */ 144 @Nullable List<AccessibilityServiceInfo> getEnabledAccessibilityServiceList( 145 @FeedbackType int feedbackTypeFlags, 146 @Nullable List<AccessibilityServiceInfo> enabledService); 147 } 148 149 private final IAccessibilityManagerClient.Stub mClient = 150 new IAccessibilityManagerClient.Stub() { 151 public void setState(int state) { 152 } 153 154 public void notifyServicesStateChanged(long updatedUiTimeout) { 155 } 156 157 public void setRelevantEventTypes(int eventTypes) { 158 } 159 }; 160 161 /** 162 * Get an AccessibilityManager instance (create one if necessary). 163 * 164 */ 165 public static AccessibilityManager getInstance(Context context) { 166 return sInstance; 167 } 168 169 /** 170 * Create an instance. 171 * 172 * @param context A {@link Context}. 173 */ 174 public AccessibilityManager(Context context, IAccessibilityManager service, int userId) { 175 } 176 177 public IAccessibilityManagerClient getClient() { 178 return mClient; 179 } 180 181 /** 182 * Returns if the {@link AccessibilityManager} is enabled. 183 * 184 * @return True if this {@link AccessibilityManager} is enabled, false otherwise. 185 */ 186 public boolean isEnabled() { 187 return false; 188 } 189 190 /** 191 * Returns if the touch exploration in the system is enabled. 192 * 193 * @return True if touch exploration is enabled, false otherwise. 194 */ 195 public boolean isTouchExplorationEnabled() { 196 return true; 197 } 198 199 /** 200 * Returns if the high text contrast in the system is enabled. 201 * <p> 202 * <strong>Note:</strong> You need to query this only if you application is 203 * doing its own rendering and does not rely on the platform rendering pipeline. 204 * </p> 205 * 206 */ 207 public boolean isHighTextContrastEnabled() { 208 return false; 209 } 210 211 /** 212 * Sends an {@link AccessibilityEvent}. 213 */ 214 public void sendAccessibilityEvent(AccessibilityEvent event) { 215 } 216 217 /** 218 * Returns whether there are observers registered for this event type. If 219 * this method returns false you shuold not generate events of this type 220 * to conserve resources. 221 * 222 * @param type The event type. 223 * @return Whether the event is being observed. 224 */ 225 public boolean isObservedEventType(@AccessibilityEvent.EventType int type) { 226 return false; 227 } 228 229 /** 230 * Requests interruption of the accessibility feedback from all accessibility services. 231 */ 232 public void interrupt() { 233 } 234 235 /** 236 * Returns the {@link ServiceInfo}s of the installed accessibility services. 237 * 238 * @return An unmodifiable list with {@link ServiceInfo}s. 239 */ 240 @Deprecated 241 public List<ServiceInfo> getAccessibilityServiceList() { 242 return Collections.emptyList(); 243 } 244 245 public List<AccessibilityServiceInfo> getInstalledAccessibilityServiceList() { 246 return Collections.emptyList(); 247 } 248 249 /** 250 * Returns the {@link AccessibilityServiceInfo}s of the enabled accessibility services 251 * for a given feedback type. 252 * 253 * @param feedbackTypeFlags The feedback type flags. 254 * @return An unmodifiable list with {@link AccessibilityServiceInfo}s. 255 * 256 * @see AccessibilityServiceInfo#FEEDBACK_AUDIBLE 257 * @see AccessibilityServiceInfo#FEEDBACK_GENERIC 258 * @see AccessibilityServiceInfo#FEEDBACK_HAPTIC 259 * @see AccessibilityServiceInfo#FEEDBACK_SPOKEN 260 * @see AccessibilityServiceInfo#FEEDBACK_VISUAL 261 */ 262 public List<AccessibilityServiceInfo> getEnabledAccessibilityServiceList( 263 int feedbackTypeFlags) { 264 return Collections.emptyList(); 265 } 266 267 /** 268 * Registers an {@link AccessibilityStateChangeListener} for changes in 269 * the global accessibility state of the system. 270 * 271 * @param listener The listener. 272 * @return True if successfully registered. 273 */ 274 public boolean addAccessibilityStateChangeListener( 275 AccessibilityStateChangeListener listener) { 276 return true; 277 } 278 279 /** 280 * Registers an {@link AccessibilityStateChangeListener} for changes in 281 * the global accessibility state of the system. If the listener has already been registered, 282 * the handler used to call it back is updated. 283 * 284 * @param listener The listener. 285 * @param handler The handler on which the listener should be called back, or {@code null} 286 * for a callback on the process's main handler. 287 */ 288 public void addAccessibilityStateChangeListener( 289 @NonNull AccessibilityStateChangeListener listener, @Nullable Handler handler) {} 290 291 public boolean removeAccessibilityStateChangeListener( 292 AccessibilityStateChangeListener listener) { 293 return true; 294 } 295 296 /** 297 * Registers a {@link TouchExplorationStateChangeListener} for changes in 298 * the global touch exploration state of the system. 299 * 300 * @param listener The listener. 301 * @return True if successfully registered. 302 */ 303 public boolean addTouchExplorationStateChangeListener( 304 @NonNull TouchExplorationStateChangeListener listener) { 305 return true; 306 } 307 308 /** 309 * Registers an {@link TouchExplorationStateChangeListener} for changes in 310 * the global touch exploration state of the system. If the listener has already been 311 * registered, the handler used to call it back is updated. 312 * 313 * @param listener The listener. 314 * @param handler The handler on which the listener should be called back, or {@code null} 315 * for a callback on the process's main handler. 316 */ 317 public void addTouchExplorationStateChangeListener( 318 @NonNull TouchExplorationStateChangeListener listener, @Nullable Handler handler) {} 319 320 /** 321 * Unregisters a {@link TouchExplorationStateChangeListener}. 322 * 323 * @param listener The listener. 324 * @return True if successfully unregistered. 325 */ 326 public boolean removeTouchExplorationStateChangeListener( 327 @NonNull TouchExplorationStateChangeListener listener) { 328 return true; 329 } 330 331 /** 332 * Registers a {@link HighTextContrastChangeListener} for changes in 333 * the global high text contrast state of the system. 334 * 335 * @param listener The listener. 336 * 337 * @hide 338 */ 339 public void addHighTextContrastStateChangeListener( 340 @NonNull HighTextContrastChangeListener listener, @Nullable Handler handler) {} 341 342 /** 343 * Unregisters a {@link HighTextContrastChangeListener}. 344 * 345 * @param listener The listener. 346 * 347 * @hide 348 */ 349 public void removeHighTextContrastStateChangeListener( 350 @NonNull HighTextContrastChangeListener listener) {} 351 352 /** 353 * Sets the current state and notifies listeners, if necessary. 354 * 355 * @param stateFlags The state flags. 356 */ 357 private void setStateLocked(int stateFlags) { 358 } 359 360 public int addAccessibilityInteractionConnection(IWindow windowToken, 361 IAccessibilityInteractionConnection connection) { 362 return View.NO_ID; 363 } 364 365 public void removeAccessibilityInteractionConnection(IWindow windowToken) { 366 } 367 368 } 369
