TalkBack — what it is, control gestures and setup on Android

What is TalkBack?

TalkBack is a screen reader for Android, developed by Google and part of Android Accessibility Suite. It provides voice feedback and gesture control for users with visual impairments. TalkBack works on smartphones, tablets, Smart TVs and wearable devices running Wear OS.

TalkBack first appeared in Android 1.6 (Donut) in 2009. Initially it was a separate project, but with the release of Android 4.0 (Ice Cream Sandwich) it became part of Android Accessibility Suite — a set of services that also includes Switch Access and Select to Speak. Starting with Android 10, TalkBack is pre-installed on all devices with Google Play services, including partner devices — Samsung, Xiaomi, Oppo and others.

TalkBack supports over 30 languages with various voice engines: Google Text-to-Speech, Samsung TTS and third-party ones. For English, Google TTS provides natural pronunciation and correct intonation. The user can adjust speech rate, pitch and select voice gender in TalkBack settings.

How does TalkBack work?

TalkBack works based on the AccessibilityService — a system mechanism in Android that allows apps to receive information about the interface state and interact with it programmatically. When TalkBack is enabled, it intercepts all touch events and transforms them into special screen reader gestures.

Accessibility focus

The key element of TalkBack work is accessibility focus. Unlike the standard input focus, which appears as a text field highlight, accessibility focus is displayed as a yellow frame around the element and is invisible to users without TalkBack. When accessibility focus lands on an element, TalkBack voices its content, type and state.

The user moves accessibility focus using gestures: swipe right — next element, swipe left — previous element. Elements are traversed in the order defined by AccessibilityNodeInfo — the accessibility tree that Android builds for each screen. The developer can influence the order through accessibilityTraversalBefore and accessibilityTraversalAfter properties, which is especially important for complex screens with custom layouts.

AccessibilityNodeInfo and the accessibility tree

Each View on the screen is represented by a node in the accessibility tree — an AccessibilityNodeInfo object. This object contains: the element’s text (contentDescription or view text), element type (button, checkbox, input field), state (enabled/disabled/selected), position on screen and a list of available actions. TalkBack traverses this tree and voices each node in traversal order.

If a View has no text content (e.g., an ImageView without description), it becomes invisible to TalkBack — the user will not know about its existence. To solve this, the developer sets contentDescription — a text description that TalkBack speaks instead of silence. Android also supports stateDescription for elements with changeable state (checked/unchecked) and hintText for input fields with hints.

TalkBack control gestures

TalkBack transforms standard Android gestures into special screen reader gestures. Most operations are performed with one or two fingers, while three-finger gestures are reserved for global actions.

The swipe up then left gesture (L-shaped swipe) opens the global TalkBack menu, where the user can change speech rate, enable screen curtain, launch a tutorial or open settings. TalkBack also supports a context menu for elements: swipe up then right opens a list of available actions for the current element (e.g., “copy”, “paste” for a text field or “delete” for a chat message).

TalkBack in mobile development

Android provides a rich API for accessibility configuration. The basic level is contentDescription, but quality TalkBack support requires working with AccessibilityNodeInfo, AccessibilityDelegate and LiveRegion.

ContentDescription and important attributes

The android:contentDescription attribute sets the text description for TalkBack. It is required for ImageView, ImageButton, FloatingActionButton and any custom View without text content. For standard elements (TextView, Button) contentDescription is optional — TalkBack will read the text automatically.

val avatarView = ImageView(this)
avatarView.contentDescription = "User avatar"
avatarView.importantForAccessibility =
    IMPORTANT_FOR_ACCESSIBILITY_YES

val playButton = ImageButton(this)
playButton.contentDescription = "Play video"

val progressBar = ProgressBar(this)
progressBar.importantForAccessibility =
    IMPORTANT_FOR_ACCESSIBILITY_NO

The importantForAccessibility flag controls element visibility for TalkBack. A value of NO hides the element from the accessibility tree — useful for decorative images, indicators and custom backgrounds. A value of YES forcibly includes the element in traversal even if it has no text. It is important not to overuse NO: hiding semantically important elements makes the app inaccessible for TalkBack users.

AccessibilityDelegate and custom actions

For custom Views that do not use standard click handlers, it is necessary to override AccessibilityDelegate — a class that handles accessibility events. The delegate allows setting custom descriptions, element types and lists of available actions that TalkBack will offer the user through the context menu.

class CustomButtonDelegate : View.AccessibilityDelegate() {
    override fun onInitializeAccessibilityNodeInfo(
        host: View, info: AccessibilityNodeInfoCompat
    ) {
        super.onInitializeAccessibilityNodeInfo(host, info)
        info.text = "Custom button"
        info.className = Button::class.java.name
        info.addAction(
            AccessibilityNodeInfoCompat.AccessibilityActionCompat(
                R.id.custom_action, "Share"
            )
        )
    }

    override fun performAccessibilityAction(
        host: View, action: Int, args: Bundle?
    ): Boolean {
        if (action == R.id.custom_action) {
            shareContent()
            return true
        }
        return super.performAccessibilityAction(host, action, args)
    }
}

In the example, the delegate tells TalkBack that the element is a button (className = Button) and provides a custom “Share” action that will appear in the TalkBack context menu. The performAccessibilityAction method handles the invocation of this action. Without a delegate, TalkBack would treat the custom View as a plain non-interactive area, and the user would not be able to interact with it.

Setting up accessibility for TalkBack

Full TalkBack support includes not only contentDescription but also focus management, LiveRegion for dynamic updates, testing with screen reader enabled and adaptation for different Android versions.

LiveRegion for dynamic content

When screen content changes without explicit user action (e.g., a notification appears for a new message or a like counter updates), TalkBack must receive a notification. For this, the android:accessibilityLiveRegion attribute is used for a View in XML or the setAccessibilityLiveRegion() method in code. A value of polite adds the announcement after the current voicing finishes, while assertive interrupts it immediately.

val statusText = TextView(this)
statusText.accessibilityLiveRegion =
    View.ACCESSIBILITY_LIVE_REGION_POLITE

// When text is updated, TalkBack will automatically
// announce the change
statusText.text = "New message from Anna"

// For critical notifications — assertive
errorBanner.accessibilityLiveRegion =
    View.ACCESSIBILITY_LIVE_REGION_ASSERTIVE

LiveRegion is the Android equivalent of UIAccessibility.post on iOS. Use polite for most updates (new messages, status updates) and assertive only for critical errors (failed payment, connection loss). Excessive use of assertive creates a negative user experience — TalkBack will constantly interrupt current voicing.

Grouping and accessibility providers

For complex screens where multiple Views form a single logical unit, AccessibilityNodeProvider or focusSearch is used to override navigation. For example, a custom calendar with 42 cells (6 weeks × 7 days) should not force the user to scroll through all 42 items to get to the next block. The developer can group cells into logical units: month → week → day.

For Jetpack Compose, the .semantics {} modifier provides a similar API: contentDescription, liveRegion, stateDescription, disabled and customActions. Compose also supports mergeDescendants for merging child semantics into one, simplifying element grouping without manual accessibilityDelegate configuration for each View.

Button(
    onClick = { sendMessage() },
    modifier = Modifier.semantics {
        contentDescription("Send message")
        stateDescription("Ready to send")
    }
) {
    Icon(Icons.Filled.Send, "Send")
}

Testing TalkBack is done using a physical device or emulator with the service enabled. It is recommended to go through key user scenarios with the screen turned off (Screen Curtain) — this simulates a complete lack of visual feedback. Android also provides Accessibility Scanner — a tool for automatic detection of accessibility issues, which highlights elements without contentDescription, too small touch targets and low contrast.