Redirecting...

Designing for Performance diff --git a/docs/html/guide/practices/design/accessibility.html b/docs/html/guide/practices/design/accessibility.html new file mode 100644 index 0000000..0fa7b32 --- /dev/null +++ b/docs/html/guide/practices/design/accessibility.html @@ -0,0 +1,11 @@ + + + +Redirecting... + + +

You should be redirected. Please click here.

+ + \ No newline at end of file diff --git a/docs/html/guide/practices/design/accessibility.jd b/docs/html/guide/practices/design/accessibility.jd deleted file mode 100644 index 72da04e..0000000 --- a/docs/html/guide/practices/design/accessibility.jd +++ /dev/null @@ -1,352 +0,0 @@ -page.title=Designing for Accessibility -@jd:body - - -

- -

Quickview

To make your application more accessible, you should make sure your UI is navigable -using a directional controller and your widgets provide content descriptions
If you implement a custom view, you should ensure that it delivers the appropriate -accessibility events during user interaction

- -

In this document

Allow Navigation with a Directional Controller -
1. Controlling focus order
2. Clicking with a directional controller
-
Label Your Input Widgets
Follow Android UI Best Practices
Send Accessibility Events from Custom View Components
Test Your Application’s Accessibility

- -

Key classes

{@link android.view.accessibility.AccessibilityEvent}
{@link android.view.accessibility.AccessibilityEventSource}

- -

Related samples

Accessibility Service

- -

- - - -

Many Android users have disabilities that require them to interact with their Android devices in -different ways. These include users who have visual, physical or age-related disabilities that -prevent them from fully using or seeing a touchscreen.

- -

Android provides an accessibility layer that helps these users navigate their Android-powered -devices more easily. Android's accessibility services provide things like text-to-speech, haptic -feedback, and trackball/d-pad navigation that augment the user experience.

- -

Your application should follow the guidelines in this document to ensure that it provides a -good experience for users with disabilities. Following these two basic rules will solve most -access-related problems:

- -

Make all of your user interface controls accessible with a trackball or directional -controller (d-pad).
Label your {@link android.widget.ImageButton}, {@link android.widget.EditText}, and other input -widgets using the {@code -android:contentDescription} attribute.

- - - - - -

Many Android devices come with some sort of directional controller, such as:

A clickable trackball that users can move in any direction
A clickable d-pad that allows users to navigate in four directions.
Arrow keys and an OK button that’s equivalent to clicking a trackball or d-pad.

- -

All of these directional controllers allow users to navigate the screen without using the -touchscreen. On some devices, a user can also navigate to the top or bottom of a list by holding -down the alt key while pressing a discrete key for up or down.

- -

A directional controller is the primary means of navigation for users with visual or some -physical impairments (and also for users without impairments when using devices that don't -have a touchscreen). You should verify that all UI controls in your application are -accessible without using the touchscreen and that clicking with the center button (or OK button) has -the same effect as touching the controls on the touchscreen.

- -

A UI control (also called a "widget") is accessible using directional controls when it's -"focusable" property is "true." This means that users can focus on the widget using the directional -controls and then interact with it. Widgets provided by the Android APIs are focusable by default -and visually indicate focus by changing the widget visual appearance in some way.

- -

Android provides several APIs that let you control whether a widget is focusable and even -request that a widget be given focus. Such methods include:

- -

{@link android.view.View#setFocusable setFocusable()}
{@link android.view.View#isFocusable isFocusable()}
{@link android.view.View#requestFocus requestFocus()}

- -

When working with a view that is not focusable by default, you can make it focusable from the XML -layout file by setting the {@code -android:focusable} attribute to {@code "true"}.

- - - -

Controlling focus order

- -

When the user navigates in any direction using the directional controls, focus is passed from one -view to another, as determined by the focus ordering. The ordering of the focus movement is based on -an algorithm that finds the nearest neighbor in a given direction. In rare cases, the default -algorithm may not match the order that you intended for your UI. In these situations, you can -provide explicit overrides to the ordering using the following XML attributes in the layout -file:

- -

{@code android:nextFocusDown}: Defines the next view to receive focus when the user navigates down.; Defines the next view to receive focus when the user navigates left.
{@code android:nextFocusRight}: Defines the next view to receive focus when the user navigates right.
{@code android:nextFocusUp}: Defines the next view to receive focus when the user navigates up.

- -

For example, here is an XML layout that contains a focusable {@link android.widget.TextView}. -While the {@link android.widget.TextView} is located to the right of the {@link -android.widget.EditText}, it can now be reached by pressing the down arrow when focus is on the -{@link android.widget.EditText}:

- -

-<LinearLayout android:orientation="horizontal"
-              ... >
-    <EditText android:id="@+id/edit"
-              android:nextFocusDown=”@+id/text”
-              ... />
-    <TextView android:id="@+id/text"
-              android:focusable=”true”
-              android:text="Hello, I am a focusable TextView"
-              android:nextFocusUp=”@id/edit”
-              ... />
-</LinearLayout>
-

- -

When modifying this ordering, be sure that the navigation works as expected in all directions -from each widget and when navigating in reverse (to get back to where you came from).

- -

You can also modify the focus ordering at runtime, using methods in the {@link -android.view.View} class, such as {@link android.view.View#setNextFocusDownId -setNextFocusDownId()} and {@link android.view.View#setNextFocusRightId -setNextFocusRightId()}.

- - -

Clicking with a directional controller

- -

On most devices, clicking a view using a directional controller sends a {@link -android.view.KeyEvent} with {@link android.view.KeyEvent#KEYCODE_DPAD_CENTER} to the view currently -in focus. Make sure this event has the same effect as touching the view on the touchscreen. All -standard Android views already handle {@link android.view.KeyEvent#KEYCODE_DPAD_CENTER} -appropriately.

- -

If possible, also treat the {@link android.view.KeyEvent#KEYCODE_ENTER} event the same as -{@link android.view.KeyEvent#KEYCODE_DPAD_CENTER}. That makes interaction much easier from a full -keyboard.

- - - - -

Label Your Input Widgets

- -

Many input widgets rely on visual cues to inform the user of their meaning. For example, a -notepad application might use an {@link android.widget.ImageButton} with a picture of a plus sign to -indicate that the user can add a new note. Or, an {@link android.widget.EditText} may have -a label near it that indicates its purpose. When a visually impaired user accesses your -application, these visual cues are often useless.

- -

To provide textual information about these widgets (as an alternative to the visual cues), you -should use the {@code android:contentDescription} attribute. The text you provide in this attribute -is not visible on the screen, but if a user has enabled accessibility speech tools then the -description in this attribute is read aloud to the user.

- -

You should set the {@code -android:contentDescription} attribute on every {@link android.widget.ImageButton}, {@link -android.widget.EditText}, {@link android.widget.CheckBox}, and on any other input widgets that might -benefit users with extra information.

- -

For example, the following {@link android.widget.ImageButton} sets the content description for -the plus button to the {@code add_note} string resource, which might be defined in English as -“Add note":

- -

-<ImageButton
-    android:id=”@+id/add_entry_button”
-    android:src=”@drawable/plus”
-    android:contentDescription=”@string/add_note”/>
-

- -

This way, when using speech accessibility tools, the user hears "Add note" when focused on -this widget.

- - - -

Follow Android UI Best Practices

- -

You can make it easier for users to learn how to use your application by developing a user -interface that complies with Android's standard interaction patterns, instead of creating your own -or using interaction patterns from another platform. This consistency is especially important for -many disabled users, as they may have less contextual information available to try to understand -your application’s interface.

- -

Specifically, you should:

- -

Use the platform's built-in widgets and layouts whenever possible, as these views provide -accessibility support by default.
Use the Options Menu as an -alternative to complex touchscreen tasks.
Make sure the BACK button correctly moves the user back one logical step in the task's back stack or the -activity's back stack of fragments (when performing fragment -transactions), as appropriate.

- - - -

Send Accessibility Events from Custom View Components

- -

If your application requires that you create a custom view component, you may need to -do some additional work to ensure that your view is accessible. Specifically, you should make sure -that your view implements the {@link android.view.accessibility.AccessibilityEventSource} -interface and emits {@link android.view.accessibility.AccessibilityEvent}s at the proper times, -and that each {@link android.view.accessibility.AccessibilityEvent} contains relevant information -about the state of the view.

- -

Events are emitted whenever something notable happens in the user interface. Currently, there -are five types of accessibility events that a view should send to the system as the user interacts -with it:

- -

{@link android.view.accessibility.AccessibilityEvent#TYPE_VIEW_CLICKED}: Indicates that the user clicked on the view (for example, the user selects a button).
{@link android.view.accessibility.AccessibilityEvent#TYPE_VIEW_LONG_CLICKED}: Indicates that the user performed a long press on the view.
{@link android.view.accessibility.AccessibilityEvent#TYPE_VIEW_SELECTED}: Indicates that the user selected an item from within the view. This is usually used in the -context of an {@link android.widget.AdapterView}.
{@link android.view.accessibility.AccessibilityEvent#TYPE_VIEW_FOCUSED}: Indicates that the user moved the focus to the view.
{@link android.view.accessibility.AccessibilityEvent#TYPE_VIEW_TEXT_CHANGED}: Indicates that the text or contents of the view changed.

- - -

The basic {@link android.view.View} class implements {@link -android.view.accessibility.AccessibilityEventSource} and emits these events at the proper time in -the standard cases. Your custom view should extend from {@link android.view.View} (or one of its -subclasses) to take advantage of these default implementations.

- -

Depending on the specifics of your custom view, your view may need to emit one of these events at -a different time than the default {@link android.view.View} implementation. To do so, simply call -{@link android.view.accessibility.AccessibilityEventSource#sendAccessibilityEvent -sendAccessibilityEvent()} with the specific event type at the correct time.

- -

For example, say you are implementing a custom slider bar that allows the user to select a -numeric value by pressing the left or right arrows. This view should emit an event of type {@link -android.view.accessibility.AccessibilityEvent#TYPE_VIEW_TEXT_CHANGED} whenever the slider value -changes:

- -

-@Override
-public boolean onKeyUp (int keyCode, KeyEvent event) {
-  if (keyCode == KeyEvent.KEYCODE_DPAD_LEFT) {
-    mCurrentValue--;
-    sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_TEXT_CHANGED);
-    return true;
-  }
-  ...
-}
-

- -

Each {@link android.view.accessibility.AccessibilityEvent} has a set of required properties that -describe the current state of the view. These properties include things like the view’s class name, -text and checked state. The specific properties required for each event type are described in the -{@link android.view.accessibility.AccessibilityEvent} documentation. The {@link android.view.View} -implementation will fill in default values for these properties. Most of these values, like the -class name and event timestamp, will not need to be changed. However, depending on the specifics of -your custom view, you may want to provide a different value for one or more of the properties. For -example, your view may have additional state information that you want to add to the event text.

- -

The {@link android.view.View#dispatchPopulateAccessibilityEvent -dispatchPopulateAccessibilityEvent()} method in {@link android.view.View} provides a hook for making -changes to the {@link android.view.accessibility.AccessibilityEvent} object before it is -emitted.

- -

In the above slider bar example, the view should add the current value of the slider bar to the -text of the event:

- -

-@Override
-public boolean dispatchPopulateAccessibilityEvent(final AccessibilityEvent event) {
-  super.dispatchPopulateAccessibilityEvent(event);
-  if (!isShown()) {
-    return false;
-  }
-  CharSequence text = String.valueOf(mCurrentValue);
-  if (text.length() > AccessibilityEvent.MAX_TEXT_LENGTH) {
-    text = text.subSequence(0, AccessiblityEvent.MAX_TEXT_LENGTH);
-  }
-  event.getText().add(text);
-  return true;
-}
-

- - -

Test Your Application’s Accessibility

- -

You can simulate the experience for many users by enabling an accessibility service that speaks -as you move around the screen. One such service is TalkBack, by the -Eyes-Free Project. It comes preinstalled on many -Android-powered devices, but is also available for free from the Google Play store.

- -

This service requires that you have a text-to-speech engine installed on your phone. You can -verify if you have one installed in the Text-to-speech settings menu by selecting -Listen to an example. If you do not hear anything spoken, install the required -voice data by selecting Install voice data.

- -

Once text-to-speech is functioning correctly, you can enable TalkBack (or another accessibility -service) in the Accessibility settings menu. Enable both -Accessibility and TalkBack. As you navigate about the device, you -should now hear spoken feedback.

- -

You can now attempt to use your application as a blind user would. As you move around using only -the directional controller, make sure that the spoken feedback you hear makes sense and is -sufficient to navigate the application without any visual cues.

diff --git a/docs/html/guide/topics/ui/accessibility/apps.jd b/docs/html/guide/topics/ui/accessibility/apps.jd new file mode 100644 index 0000000..ff34be6 --- /dev/null +++ b/docs/html/guide/topics/ui/accessibility/apps.jd @@ -0,0 +1,570 @@ +page.title=Making Applications Accessible +parent.title=Accessibility +parent.link=index.html +@jd:body + +

+ +

In this document

Labeling User Interface Elements
Enabling Focus Navigation +
1. Enabling view focus
2. Controlling focus order
+
Building Accessible Custom Views +
+
Testing Accessibility +
1. Testing audible feedback
2. Testing focus navigation
+

+ +

Key classes

{@link android.view.accessibility.AccessibilityEvent}
{@link android.view.accessibility.AccessibilityNodeInfo}
{@link android.support.v4.view.accessibility.AccessibilityNodeInfoCompat}
{@link android.view.View.AccessibilityDelegate}
{@link android.support.v4.view.AccessibilityDelegateCompat}

+ +

Labeling User Interface Elements

+ +

Many user interface controls rely on visual cues to inform users of their meaning. For +example, a note-taking application might use an {@link android.widget.ImageButton} with a +picture of a plus sign to indicate that the user can add a new note. Or, an {@link +android.widget.EditText} component may have a label near it that indicates its purpose. When a user +with impaired vision accesses your application, these visual cues are often useless.

+ +

To provide textual information about interface controls (as an alternative to the visual cues), +use the +{@code android:contentDescription} attribute. The text you provide in this attribute is not +visible on the screen, but if a user has enabled accessibility services that provide audible +prompts, then the description in this attribute is read aloud to the user.

+ +

Set the +{@code android:contentDescription} attribute for every {@link android.widget.ImageButton}, +{@link android.widget.ImageView}, {@link android.widget.EditText}, {@link android.widget.CheckBox} +in your application's user interface, and on any other input controls that might require additional +information for users who are not able to see it.

+ +

For example, the following {@link android.widget.ImageButton} sets the content description for +the plus button to the {@code add_note} string resource, which could be defined as “Add note" for an +English language interface:

+ +

+<ImageButton
+    android:id=”@+id/add_note_button”
+    android:src=”@drawable/add_note”
+    android:contentDescription=”@string/add_note”/>
+

+ +

By including the description, speech-based accessibility services can announce "Add note" when a +user moves focus to this button or hovers over it.

+ +

Note: For {@link android.widget.EditText} fields, provide an +android:hint +attribute to help users understand what content is expected.

+ +

Enabling Focus Navigation

+ +

Focus navigation allows users with disabilities to step through user interface controls using a +directional controller. Directional controllers can be physical, such as a clickable trackball, +directional pad (D-Pad) or arrow keys, tab key navigation with an attached keyboard or a software +application that provides an on-screen directional control.

+ +

A directional controller is a primary means of navigation for many users. +Verify that all user interface (UI) controls in your application are accessible +without using the touchscreen and that clicking with the center button (or OK button) of a +directional controller has the same effect as touching the controls on the touchscreen. For +information on testing directional controls, see Testing focus +navigation.

+ +

Enabling view focus

+ +

A user interface element is accessible using directional controls when its + +{@code android:focusable} attribute is set to {@code true}. This setting allows users to focus +on the element using the directional controls and then interact with it. The user interface controls +provided by the Android framework are focusable by default and visually indicate focus by changing +the control’s appearance.

+ +

Android provides several APIs that let you control whether a user interface control is focusable +and even request that a control be given focus:

+ +

{@link android.view.View#setFocusable setFocusable()}
{@link android.view.View#isFocusable isFocusable()}
{@link android.view.View#requestFocus requestFocus()}

+ +

When working with a view that is not focusable by default, you can make it focusable from the XML +layout file by setting the + +{@code android:focusable} attribute to {@code true} or by using the {@link +android.view.View#setFocusable setFocusable()} method.

+ +

Controlling focus order

+ +

When users navigate in any direction using directional controls, focus is passed from one +user interface element (View) to another, as determined by the focus ordering. The ordering of the +focus movement is based on an algorithm that finds the nearest neighbor in a given direction. In +rare cases, the default algorithm may not match the order that you intended for your UI. In these +situations, you can provide explicit overrides to the ordering using the following XML attributes in +the layout file:

+ +

{@code android:nextFocusDown}: Defines the next view to receive focus when the user navigates down.; Defines the next view to receive focus when the user navigates left.
{@code android:nextFocusRight}: Defines the next view to receive focus when the user navigates right.
{@code android:nextFocusUp}: Defines the next view to receive focus when the user navigates up.

+ +

The following example XML layout shows two focusable user interface elements where the {@code android:nextFocusDown} and {@code android:nextFocusUp} attributes have been explicitly set. The {@link android.widget.TextView} is +located to the right of the {@link android.widget.EditText}. However, since these properties have +been set, the {@link android.widget.TextView} element can now be reached by pressing the down arrow +when focus is on the {@link android.widget.EditText} element:

+ +

+<LinearLayout android:orientation="horizontal"
+        ... >
+    <EditText android:id="@+id/edit"
+        android:nextFocusDown=”@+id/text”
+        ... />
+    <TextView android:id="@+id/text"
+        android:focusable=”true”
+        android:text="Hello, I am a focusable TextView"
+        android:nextFocusUp=”@id/edit”
+        ... />
+</LinearLayout>
+

+ +

When modifying focus order, be sure that the navigation works as expected in all directions from +each user interface control and when navigating in reverse (to get back to where you came from).

+ +

Note: You can modify the focus order of user interface components +at runtime, using methods such as {@link android.view.View#setNextFocusDownId setNextFocusDownId()} +and {@link android.view.View#setNextFocusRightId setNextFocusRightId()}.

+ + +

Building Accessible Custom Views

+ +

If your application requires a custom +view component, you must do some additional work to ensure that your custom view is accessible. +These are the main tasks for ensuring the accessibility of your view:

+ +

Handle directional controller clicks
Implement Accessibility API methods
Send {@link android.view.accessibility.AccessibilityEvent} objects specific to your custom view
Populate {@link android.view.accessibility.AccessibilityEvent} and {@link + android.view.accessibility.AccessibilityNodeInfo} for your view

+ + +

Handling directional controller clicks

+ +

On most devices, clicking a view using a directional controller sends a {@link +android.view.KeyEvent} with {@link android.view.KeyEvent#KEYCODE_DPAD_CENTER} to the view currently +in focus. All standard Android views already handle {@link +android.view.KeyEvent#KEYCODE_DPAD_CENTER} appropriately. When building a custom {@link +android.view.View} control, make sure this event has the same effect as touching the view on the +touchscreen.

+ +

Your custom control should also treat the {@link android.view.KeyEvent#KEYCODE_ENTER} event the +same as {@link android.view.KeyEvent#KEYCODE_DPAD_CENTER}. This approach makes interaction from a +full keyboard much easier for users.

+ + +

Implementing accessibility API methods

+ +

Accessibility events are messages about users interaction with visual interface components in +your application. These messages are handled by Accessibility Services, +which use the information in these events to produce supplemental feedback and prompts when users +have enabled accessibility services. As of Android 4.0 (API Level 14) and higher, the methods for +generating accessibility events have been expanded to provide more detailed information beyond the +{@link android.view.accessibility.AccessibilityEventSource} interface introduced in Android 1.6 (API +Level 4). The expanded accessibility methods are part of the {@link android.view.View} class as well +as the {@link android.view.View.AccessibilityDelegate} class. The methods are as follows:

+ +

{@link android.view.View#sendAccessibilityEvent sendAccessibilityEvent()}

(API Level 4) This method is called when a user takes action on a view. The event is +classified with a user action type such as {@link +android.view.accessibility.AccessibilityEvent#TYPE_VIEW_CLICKED TYPE_VIEW_CLICKED}. You typically do +not need to implement this method unless you are creating a custom view.

{@link android.view.View#sendAccessibilityEventUnchecked +sendAccessibilityEventUnchecked()}

(API Level 4) This method is used when the calling code needs to directly control the check +for accessibility being enabled on the device ({@link +android.view.accessibility.AccessibilityManager#isEnabled AccessibilityManager.isEnabled()}). If +you do implement this method, you must assume that the calling method has already checked that +accessibility is enabled and the result is {@code true}. You typically do not need to implement this +method for a custom view.

{@link android.view.View#dispatchPopulateAccessibilityEvent +dispatchPopulateAccessibilityEvent()}

(API Level 4) The system calls this method when your custom view generates an +accessibility event. As of API Level 14, the default implementation of this method calls {@link +android.view.View#onPopulateAccessibilityEvent onPopulateAccessibilityEvent()} for this view and +then the {@link android.view.View#dispatchPopulateAccessibilityEvent +dispatchPopulateAccessibilityEvent()} method for each child of this view. In order to support +accessibility services on revisions of Android prior to 4.0 (API Level 14) you +must override this method and populate {@link +android.view.accessibility.AccessibilityEvent#getText} with descriptive text for your custom +view.

{@link android.view.View#onPopulateAccessibilityEvent onPopulateAccessibilityEvent()}

(API Level 14) This method sets the text output of an {@link +android.view.accessibility.AccessibilityEvent} for your view. This method is also called if the +view is a child of a view which generates an accessibility event. + +

Note: Modifying additional attributes beyond the text within +this method potentially overwrites properties set by other methods. So, while you are able modify +attributes of the accessibility event with this method, you should limit these changes +to text content only and use the {@link android.view.View#onInitializeAccessibilityEvent +onInitializeAccessibilityEvent()} method to modify other properties of the event.

+ +

Note: If your implementation of this event calls for completely +overiding the output text without allowing other parts of your layout to modify its content, then +do not call the super implementation of this method in your code.

{@link android.view.View#onInitializeAccessibilityEvent onInitializeAccessibilityEvent()}

(API Level 14) The system calls this method to obtain additional information about the +state of the view, beyond text content. If your custom view provides interactive control beyond a +simple {@link android.widget.TextView} or {@link android.widget.Button}, you should override this +method and set the additional information about your view into the event using this method, such as +password field type, checkbox type or states that provide user interaction or feedback. If you +do override this method, you must call its super implementation and then only modify properties +that have not been set by the super class.

{@link android.view.View#onInitializeAccessibilityNodeInfo +onInitializeAccessibilityNodeInfo()}

(API Level 14) This method provides accessibility services with information about the state of +the view. The default {@link android.view.View} implementation sets a standard set of view +properties, but if your custom view provides interactive control beyond a simple {@link +android.widget.TextView} or {@link android.widget.Button}, you should override this method and set +the additional information about your view into the {@link +android.view.accessibility.AccessibilityNodeInfo} object handled by this method.

{@link android.view.ViewGroup#onRequestSendAccessibilityEvent +onRequestSendAccessibilityEvent()}

(API Level 14) The system calls this method when a child of your view has generated an +{@link android.view.accessibility.AccessibilityEvent}. This step allows the the parent view to amend +the accessibility event with additional information. You should implement this method only if your +custom view can have child views and if the parent view can provide context information to the +accessibility event that would be useful to accessibility services.

+ +

In order to support these accessibility methods for a custom view, you should take one of the +following approaches:

+ +

If your application targets Android 4.0 (API level 14) and higher, override and implement the +accessibility methods listed above directly in your custom view class.
If your custom view is intended to be compatible with Android 1.6 (API Level 4) and above, add +the Android Support Library, revision 5 or +higher, to your project. Then, within your custom view class, call the +{@link android.support.v4.view.ViewCompat#setAccessibilityDelegate +ViewCompat.setAccessibilityDelegate()} method to implement the accessibility methods +above. For an example of this approach, see the Android Support Library (revision 5 or higher) +sample {@code AccessibilityDelegateSupportActivity} in +({@code <sdk>/extras/android/support/v4/samples/Support4Demos/}) +

+ +

In either case, you should implement the following accessibility methods for your custom view +class:

+ +

{@link android.view.View#dispatchPopulateAccessibilityEvent + dispatchPopulateAccessibilityEvent()}
{@link android.view.View#onPopulateAccessibilityEvent + onPopulateAccessibilityEvent()}
{@link android.view.View#onInitializeAccessibilityEvent + onInitializeAccessibilityEvent()}
{@link android.view.View#onInitializeAccessibilityNodeInfo + onInitializeAccessibilityNodeInfo()}

+ +

For more information about implementing these methods, see Populating +Accessibility Events.

+ + +

Sending accessibility events

+ +

Depending on the specifics of your custom view, it may need to send {@link +android.view.accessibility.AccessibilityEvent} objects at a different times or for events not +handled by the default implementation. The {@link android.view.View} class provides a default +implementation for these event types:

+ +

Starting with API Level 4: +
- {@link android.view.accessibility.AccessibilityEvent#TYPE_VIEW_CLICKED}
- {@link android.view.accessibility.AccessibilityEvent#TYPE_VIEW_LONG_CLICKED}
- {@link android.view.accessibility.AccessibilityEvent#TYPE_VIEW_FOCUSED}
+
Starting with API Level 14: +
- {@link android.view.accessibility.AccessibilityEvent#TYPE_VIEW_SCROLLED}
- {@link android.view.accessibility.AccessibilityEvent#TYPE_VIEW_HOVER_ENTER}
- {@link android.view.accessibility.AccessibilityEvent#TYPE_VIEW_HOVER_EXIT}
+

+ +

Note: Hover events are associated with the Explore by +Touch feature, which uses these events as triggers for providing audible prompts for user interface +elements.

+ +

In general, you should send an {@link android.view.accessibility.AccessibilityEvent} whenever the +content of your custom view changes. For example, if you are implementing a custom slider bar that +allows a user to select a numeric value by pressing the left or right arrows, your custom view +should emit an event of type {@link +android.view.accessibility.AccessibilityEvent#TYPE_VIEW_TEXT_CHANGED} whenever the slider +value changes. The following sample code demonstrates the use of the {@link +android.view.accessibility.AccessibilityEventSource#sendAccessibilityEvent +sendAccessibilityEvent()} method to report this event.

+ +

+@Override
+public boolean onKeyUp (int keyCode, KeyEvent event) {
+    if (keyCode == KeyEvent.KEYCODE_DPAD_LEFT) {
+        mCurrentValue--;
+        sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_TEXT_CHANGED);
+        return true;
+    }
+    ...
+}
+

+ + +

Populating accessibility events

+ +

Each {@link android.view.accessibility.AccessibilityEvent} has a set of required properties that +describe the current state of the view. These properties include things such as the view’s class +name, content description and checked state. The specific properties required for each event type +are described in the {@link android.view.accessibility.AccessibilityEvent} reference documentation. +The {@link android.view.View} implementation provides default values for these properties. Many of +these values, including the class name and event timestamp, are provided automatically. If you are +creating a custom view component, you must provide some information about the content and +characteristics of the view. This information may be as simple as a button label, but may also +include additional state information that you want to add to the event.

+ +

The minimum requirement for providing information to accessibility services with a custom +view is to implement {@link android.view.View#dispatchPopulateAccessibilityEvent +dispatchPopulateAccessibilityEvent()}. This method is called by the system to request +information for an {@link android.view.accessibility.AccessibilityEvent} and makes your custom +view compatible with accessibility services on Android 1.6 (API Level 4) and higher. The +following example code demonstrates a basic implementation of this method.

+ +

+@Override
+public void dispatchPopulateAccessibilityEvent(AccessibilityEvent event) {
+    super.dispatchPopulateAccessibilityEvent(event);
+    // Call the super implementation to populate its text to the event, which
+    // calls onPopulateAccessibilityEvent() on API Level 14 and up.
+
+    // In case this is running on a API revision earlier that 14, check
+    // the text content of the event and add an appropriate text
+    // description for this custom view:
+    CharSequence text = getText();
+    if (!TextUtils.isEmpty(text)) {
+        event.getText().add(text);
+    }
+}
+

+ +

On Android 4.0 (API Level 14) and higher, the {@link +android.view.View#onPopulateAccessibilityEvent onPopulateAccessibilityEvent()} and +{@link android.view.View#onInitializeAccessibilityEvent onInitializeAccessibilityEvent()} +methods are the recommended way to populate or modify the information in an {@link +android.view.accessibility.AccessibilityEvent}. Use the +{@link android.view.View#onPopulateAccessibilityEvent onPopulateAccessibilityEvent()} method +specifically for adding or modifying the text content of the event, which is turned into audible +prompts by accessibility services such as TalkBack. Use the +{@link android.view.View#onInitializeAccessibilityEvent onInitializeAccessibilityEvent()} method for +populating additional information about the event, such as the selection state of the view.

+ +

In addition, you should also implement the +{@link android.view.View#onInitializeAccessibilityNodeInfo onInitializeAccessibilityNodeInfo()} +method. {@link android.view.accessibility.AccessibilityNodeInfo} objects populated by this method +are used by accessibility services to investigate the view hierarchy that generated an accessibility +event after receiving that event, to obtain a more detailed context information and provide +appropriate feedback to users.

+ +

The example code below shows how override these three methods by using +{@link android.support.v4.view.ViewCompat#setAccessibilityDelegate +ViewCompat.setAccessibilityDelegate()}. Note that this sample code requires that the Android +Support Library for API Level 4 (revision 5 +or higher) is added to your project.

+ +

+ViewCompat.setAccessibilityDelegate(new AccessibilityDelegateCompat() {
+    @Override
+    public void onPopulateAccessibilityEvent(View host, AccessibilityEvent event) {
+        super.onPopulateAccessibilityEvent(host, event);
+        // We call the super implementation to populate its text for the
+        // event. Then we add our text not present in a super class.
+        // Very often you only need to add the text for the custom view.
+        CharSequence text = getText();
+        if (!TextUtils.isEmpty(text)) {
+            event.getText().add(text);
+        }
+    }
+    @Override
+    public void onInitializeAccessibilityEvent(View host, AccessibilityEvent event) {
+        super.onInitializeAccessibilityEvent(host, event);
+        // We call the super implementation to let super classes
+        // set appropriate event properties. Then we add the new property
+        // (checked) which is not supported by a super class.
+        event.setChecked(isChecked());
+    }
+    @Override
+    public void onInitializeAccessibilityNodeInfo(View host,
+            AccessibilityNodeInfoCompat info) {
+        super.onInitializeAccessibilityNodeInfo(host, info);
+        // We call the super implementation to let super classes set
+        // appropriate info properties. Then we add our properties
+        // (checkable and checked) which are not supported by a super class.
+        info.setCheckable(true);
+        info.setChecked(isChecked());
+        // Quite often you only need to add the text for the custom view.
+        CharSequence text = getText();
+        if (!TextUtils.isEmpty(text)) {
+            info.setText(text);
+        }
+    }
+}
+

+ +

On applications targeting Android 4.0 (API Level 14) and higher, these methods can be implemented +directly in your custom view class. For another example of this approach, see the Android +Support Library (revision 5 or higher) sample +{@code AccessibilityDelegateSupportActivity} in +({@code <sdk>/extras/android/support/v4/samples/Support4Demos/}).

+ +

Note: You may find information on implementing accessibility for +custom views written prior to Android 4.0 that describes the use of the +{@link android.view.View#dispatchPopulateAccessibilityEvent dispatchPopulateAccessibilityEvent()} +method for populating AccessibilityEvents. As of the Android 4.0 release, however, the recommended +approach is to use the +{@link android.view.View#onPopulateAccessibilityEvent onPopulateAccessibilityEvent()} and +{@link android.view.View#onInitializeAccessibilityEvent onInitializeAccessibilityEvent()} +methods.

+ + +

Testing Accessibility

+ +

Testing the accessibility of your application is an important part of ensuring your users have a +great experience. You can test the most important parts of accessibility by testing your application +with audible feedback enabled and testing navigation within your application using directional +controls.

+ +

Testing audible feedback

You can simulate the experience for many users by enabling an accessibility service that speaks +as you move around the screen. The Explore by Touch accessibility service, which is available on +devices with Android 4.0 and later. The TalkBack +accessibility service, by the Eyes-Free +Project comes preinstalled on many Android devices.

+ +

To enable TalkBack on revisions of Android prior to Android 4.0:

Launch the Settings application.
Navigate to the Accessibility category and select it.
Select Accessibility to enable it.
Select TalkBack to enable it.

+ +

Note: If the TalkBack accessibility service is not available, you +can install it for free from Google Play.

+ +

To enable Explore by Touch on Android 4.0 and later:

Launch the Settings application.
Navigate to the Accessibility category and select it.
Select the TalkBack to enable it.
Return to the Accessibility category and select Explore by +Touch to enable it. +
Note: You must turn on TalkBack first, otherwise this +option is not available.
+

+ + + +

As part of your accessibility testing, you can test navigation of your application using focus, +even if your test devices does not have a directional controller. The Android Emulator provides a +simulated directional controller that you can easily use to test navigation. You can also use the +arrow keys and Enter key on your keyboard with the Emulator to simulate use of a D-pad.

diff --git a/docs/html/guide/topics/ui/accessibility/index.jd b/docs/html/guide/topics/ui/accessibility/index.jd new file mode 100644 index 0000000..414d5f3 --- /dev/null +++ b/docs/html/guide/topics/ui/accessibility/index.jd @@ -0,0 +1,55 @@ +page.title=Accessibility +parent.title=User Interface +parent.link=../index.html +@jd:body + +

+ +

Topics

+ +

Key classes

{@link android.view.accessibility.AccessibilityEvent}
{@link android.accessibilityservice.AccessibilityService}

+ +

Topics

Manifest Declarations and Permissions +
1. Accessibility service declaration
2. Accessibility service configuration
+
AccessibilityService Methods
Getting Event Details
Example Code

+ +

Key classes

{@link android.accessibilityservice.AccessibilityService}
{@link android.accessibilityservice.AccessibilityServiceInfo}
{@link android.view.accessibility.AccessibilityEvent}
{@link android.view.accessibility.AccessibilityRecord}
{@link android.view.accessibility.AccessibilityNodeInfo}

+ +

Manifest Declarations and Permissions

+ +

Applications that provide accessibility services must include specific declarations in their + application manifests in order to be treated as an accessibility service by an Android system. + This section explains the required and optional settings for accessibility services.

+ + +

Accessibility service declaration

+ +

In order to be treated as an accessibility service, your application must include the +{@code service} element (rather than the {@code activity} element) within the {@code application} +element in its manifest. In addition, within the {@code service} element, you must also include an +accessibility service intent filter, as shown in the following sample:

+ +

+<application>
+  <service android:name=".MyAccessibilityService"
+      android:label="@string/accessibility_service_label">
+    <intent-filter>
+      <action android:name="android.accessibilityservice.AccessibilityService" />
+    </intent-filter>
+  </service>
+</application>
+

+ +

These declarations are required for all accessibility services deployed on Android 1.6 (API Level + 4) or higher.

+ + +

Accessibility service configuration

+ +

Accessibility services must also provide a configuration which specifies the types of +accessibility events that the service handles and additional information about the service. The +configuration of an accessibility service is contained in the {@link +android.accessibilityservice.AccessibilityServiceInfo} class. Your service can build and set a +configuration using an instance of this class and {@link +android.accessibilityservice.AccessibilityService#setServiceInfo setServiceInfo()} at runtime. +However, not all configuration options are available using this method.

+ +

Beginning with Android 4.0, you can include a {@code <meta-data>} element in your manifest +with a reference to a configuration file, which allows you to set the full range of options for +your accessibility service, as shown in the following example:

+ +

+<service android:name=".MyAccessibilityService">
+  ...
+  <meta-data
+    android:name="android.accessibilityservice"
+    android:resource="@xml/accessibility_service_config" />
+</service>
+

+ +

This meta-data element refers to an XML file that you create in your application’s resource +directory ({@code <project_dir>/res/xml/accessibility_service_config.xml}). The following code +shows example contents for the service configuration file:

+ +

+<accessibility-service xmlns:android="http://schemas.android.com/apk/res/android"
+    android:description="@string/accessibility_service_description"
+    android:packageNames="com.example.android.apis"
+    android:accessibilityEventTypes="typeAllMask"
+    android:accessibilityFlags="flagDefault"
+    android:accessibilityFeedbackType="feedbackSpoken"
+    android:notificationTimeout="100"
+    android:canRetrieveWindowContent="true"
+    android:settingsActivity="com.example.android.accessibility.ServiceSettingsActivity"
+/>
+

+ +

One of the most important functions of the accessibility service configuration parameters is to +allow you to specify what types of accessibility events your service can handle. Being able to +specify this information enables accessibility services to cooperate with each other, and allows you +as a developer the flexibility to handle only specific events types from specific applications. The +event filtering can include the following criteria:

+ +

Package Names - Specify the package names of applications whose accessibility +events you want your service to handle. If this parameter is omitted, your accessibility service is +considered available to service accessibility events for any application. This parameter can be set +in the accessibility service configuration files with the {@code android:packageNames} attribute as +a comma-separated list, or set using the {@link +android.accessibilityservice.AccessibilityServiceInfo#packageNames +AccessibilityServiceInfo.packageNames} member.
Event Types - Specify the types of accessibility events you want your service +to handle. This parameter can be set in the accessibility service configuration files with the +{@code android:accessibilityEventTypes} attribute as a comma-separated list, or set using the +{@link android.accessibilityservice.AccessibilityServiceInfo#eventTypes +AccessibilityServiceInfo.eventTypes} member.

+ +

For more information about the XML attributes which can be used in the accessibility service + configuration file, follow these links to the reference documentation:

+ +

For more information about which configuration settings can be dynamically set at runtime, see +the {@link android.accessibilityservice.AccessibilityServiceInfo} reference documentation.

+ + +

AccessibilityService Methods

+ +

An application that provides accessibility service must extend the {@link +android.accessibilityservice.AccessibilityService} class and override the following methods from +that class. These methods are presented in the order in which they are called by the Android system, +from when the service is started +({@link android.accessibilityservice.AccessibilityService#onServiceConnected onServiceConnected()}), +while it is running ({@link android.accessibilityservice.AccessibilityService#onAccessibilityEvent +onAccessibilityEvent()}, +{@link android.accessibilityservice.AccessibilityService#onInterrupt onInterrupt()}) to when it is +shut down ({@link android.accessibilityservice.AccessibilityService#onUnbind onUnbind()}).

+ +

{@link android.accessibilityservice.AccessibilityService#onServiceConnected +onServiceConnected()} - (optional) This system calls this method when it successfully connects to +your accessibility service. Use this method to do any one-time setup steps for your service, +including connecting to user feedback system services, such as the audio manager or device vibrator. +If you want to set the configuration of your service at runtime or make one-time adjustments, this +is a convenient location from which to call {@link +android.accessibilityservice.AccessibilityService#setServiceInfo setServiceInfo()}.
{@link android.accessibilityservice.AccessibilityService#onAccessibilityEvent +onAccessibilityEvent()} - (required) This method is called back by the system when it detects an +{@link android.view.accessibility.AccessibilityEvent} that matches the event filtering parameters +specified by your accessibility service. For example, when the user clicks a button or focuses on a +user interface control in an application for which your accessibility service is providing feedback. +When this happens, the system calls this method of your service with the associated {@link +android.view.accessibility.AccessibilityEvent}, which you can then interpret and provide feedback to +the user. This method may be called many times over the lifecycle of your service.
{@link android.accessibilityservice.AccessibilityService#onInterrupt onInterrupt()} - +(required) This method is called when the system wants to interrupt the feedback your service is +providing, usually in response to a user taking action, such as moving focus to a different user +interface control than the one for which you are currently providing feedback. This method may be +called many times over the lifecycle of your service.
{@link android.accessibilityservice.AccessibilityService#onUnbind onUnbind()} - (optional) +This method is called when the system is about to shutdown the accessibility service. Use this +method to do any one-time shutdown procedures, including de-allocating user feedback system +services, such as the audio manager or device vibrator.

+ +

These callback methods provide the basic structure for your accessibility service. It is up to +you to decide on how to process data provided by the Android system in the form of {@link +android.view.accessibility.AccessibilityEvent} objects and provide feedback to the user.

+ + +

Getting Event Details

+ +

The Android system provides information to accessibility services about the user interface +interaction through {@link android.view.accessibility.AccessibilityEvent} objects. Prior to Android +4.0, the information available in an accessibility event, while providing a significant amount of +detail about a user interface control selected by the user, typically provided limited contextual +information. In many cases, this missing context information might be critical to understanding the +meaning of the selected control.

+ +

A typical example of an interface where context is of critical importance is a calendar or day +planner. If a user selects a 4:00 PM time slot in a Monday to Friday day list and the accessibility +service announces “4 PM”, but fails to indicate this is a Friday a Monday, the month or day, this is +hardly ideal feedback for the user. In this case, the context of a user interface control is of +critical importance to a user who wants to schedule a meeting.

+ +

Android 4.0 significantly extends the amount of information that an accessibility service can +obtain about an user interface interaction by composing accessibility events based on the view +hierarchy. A view hierarchy is the set of user interface components that contain the component (its +parents) and the user interface elements that may be contained by that component (its children). In +this way, the Android system can provide much richer detail about accessibility events, allowing +accessibility services to provide more useful feedback to users.

+ +

An accessibility service gets information about an user interface event through an {@link +android.view.accessibility.AccessibilityEvent} passed by the system to the service’s +{@link android.accessibilityservice.AccessibilityService#onAccessibilityEvent +onAccessibilityEvent()} callback method. This object provides details about the event, including the +type of object being acted upon, its descriptive text and other details. Starting in Android 4.0 +(and supported in previous releases through the {@link +android.support.v4.view.accessibility.AccessibilityEventCompat} object in the Support Library), you +can obtain additional information about the event using these calls:

+ +

{@link android.view.accessibility.AccessibilityEvent#getRecordCount +AccessibilityEvent.getRecordCount()} and {@link +android.view.accessibility.AccessibilityEvent#getRecord getRecord(int)} - These methods allow you to +retrieve the set of {@link android.view.accessibility.AccessibilityRecord} objects which contributed +to the {@link android.view.accessibility.AccessibilityEvent} passed to you by the system, which can +provide more context for your accessibility service.
{@link android.view.accessibility.AccessibilityEvent#getSource +AccessibilityEvent.getSource()} - This method returns an {@link +android.view.accessibility.AccessibilityNodeInfo} object. This object allows you to request the +parents and children of the component that originated the accessibility event and investigate their +contents and state in order to provide + +
Important: The ability to investigate the full view +hierarchy from an {@link android.view.accessibility.AccessibilityEvent} potentially exposes private +user information to your accessibility service. For this reason, your service must request this +level of access through the accessibility service configuration XML +file, by including the {@code canRetrieveWindowContent} attribute and setting it to {@code true}. If +you do not include this setting in your service configuration xml file, calls to {@link +android.view.accessibility.AccessibilityEvent#getSource getSource()} fail.
+

+ + +

Example Code

+ +

The API Demo project contains two samples which can be used as a starting point for generating +accessibility services +({@code <sdk>/samples/<platform>/ApiDemos/src/com/example/android/apis/accessibility}): +

+ +

ClockBackService + - This service is based on the original implementation of {@link +android.accessibilityservice.AccessibilityService} and can be used as a base for developing basic +accessibility services that are compatible with Android 1.6 (API Level 4) and higher.
TaskBackService + - This service is based on the enhanced accessibility APIs introduced in Android 4.0 (API Level +14). However, you can use the Android Support +Libary to substitute classes introduced in later API levels (e.g., +{@link android.view.accessibility.AccessibilityRecord}, +{@link android.view.accessibility.AccessibilityNodeInfo} +) with equivalent support package classes (e.g., +{@link android.support.v4.view.accessibility.AccessibilityRecordCompat}, +{@link android.support.v4.view.accessibility.AccessibilityNodeInfoCompat} +) to make this example work with API versions back to Android 1.6 (API Level 4).

-- cgit v1.1

Quickview

In this document

Key classes

Related samples

Allow Navigation with a Directional Controller

Controlling focus order

Clicking with a directional controller

Label Your Input Widgets

Follow Android UI Best Practices

Send Accessibility Events from Custom View Components

Test Your Application’s Accessibility

In this document

Key classes

See also

Labeling User Interface Elements

Enabling Focus Navigation

Enabling view focus

Controlling focus order

Building Accessible Custom Views

Handling directional controller clicks

Implementing accessibility API methods

Sending accessibility events

Populating accessibility events

Testing Accessibility

Testing audible feedback

Testing focus navigation

Topics

Key classes

See also

Topics

Key classes

See also

Manifest Declarations and Permissions

Accessibility service declaration

Accessibility service configuration

AccessibilityService Methods

Getting Event Details

Example Code