Skip to main content
Titan OS offers accessibility features designed to help you create inclusive applications for Smart TVs. This guide will walk you through implementing them across Titan OS devices.

Core Accessibility features

Titan OS provides the following features for enhancing accessibility:

Text-to-Speech (TTS)

Converts on-screen text into spoken audio, enabling navigation for visually impaired users. In the Titan OS ecosystem, the implementation strategy how customized you want the system to communicate with visual impaired users:
  • Automatic WAI-ARIA native screen reader: Automatically reads standard WAI-ARIA attributes (e.g., aria-label, role). The native screen reader is disabled by default for apps and must be explicitly enabled by calling the Titan SDK accessibility.enableNativeReader() function once the SDK is loaded.
  • Custom Voice Announcements: Reads custom text passed as a parameter to the Titan SDK startSpeaking(text: string) function. Use this approach to trigger voice guidance on demand when you want to provide a highly customized accessibility experience (e.g., giving richer context about focused elements).

Text Magnification (TM)

Text Magnification (TM) allows users to increase font size and contrast for better readability. When a user enables magnification in the OS system settings, the SDK exposes this preference to your application. You are responsible for detecting this property and programmatically adjusting your UI’s text scaling to match the requested size.

Audio Description (AD)

Audio Description enables the playback of a dedicated secondary audio track included in the manifest that describes visual elements, actions, and scenes for visually impaired users. This feature applies strictly to video content playback and is distinct from Text-to-Speech (TTS). The system does not manage track selection automatically within your player; it simply signals whether Audio Description is enabled at the system level. Therefore, the application is responsible for configuring the player to ensure the appropriate audio track is selected when the setting is enabled. Using the system’s exposed property is optional. Alternatively, applications can implement their own in-app settings to manage this feature independently.

Getting Started

This section provides practical steps and code snippets to begin integrating accessibility features into your TitanOS application.

Basic TTS and TM Setup using the Titan SDK

Before using TTS or TM, it’s essential to check if the feature is supported by the device and if the user has enabled it in the TV’s operating system settings. Checking Support & User Settings:

Automatic WAI-ARIA native screen reader

The native screen reader relies on standard WAI-ARIA attributes (aria-label, role, aria-live, etc.) and semantic HTML to automatically announce focused elements as the user navigates through your app. Because this feature is disabled by default for applications, you must explicitly activate it once the Titan SDK is initialized. Enabling the Native Reader:
Note: The snippet above is a basic example, and your exact implementation may vary depending on your application’s architecture or framework lifecycle. However, make sure to call enableNativeReader() once both your application and the Titan SDK are fully loaded. Note: This initialization check assumes that Voice Guidance (TTS) is already enabled in the TV settings when the app launches. To react dynamically if the user toggles Voice Guidance while using your app, you must call enableNativeReader() inside the onTTSSettingsChange listener whenever the setting is turned on, as described in Responding to User Preferences. You do not need to call disableNativeReader() when the user disables Voice Guidance at the OS level, as the system automatically deactivates it across the board; however, you must explicitly call enableNativeReader() again if the user re-enables it during the same session. Disabling the Native Reader (Optional): You only need to call disableNativeReader() if you plan to alternate between the automatic native screen reader and Custom Voice Announcements (startSpeaking()), covered in the next section. If both are active at the same time, the system will speak twice for the same interaction, first via the native reader and then via your startSpeaking() call. While this may fit specific use cases, we recommend using one approach at a time, or temporarily disabling the native reader and re-enabling it afterward to maintain full control over voice output.
As always, how and when you toggle between these two approaches depends on your application’s architecture and specific navigation logic.

Custom Voice Announcements

The Titan SDK’s startSpeaking() function provides direct control over the TV’s speech output. It does not automatically read content from your DOM elements or ARIA attributes. As the developer, you are responsible for extracting the specific text you wish to be spoken and passing it as a string (or an array of strings) to this function. For example, you might extract text from a focused element’s textContent, innerText, or its aria-label attribute. Initiating Speech:
Your GitHub examples provide more complete implementations: Optionally, you can call the stop speaking function right after moving between elements and avoid duplicated speaking actions: Stopping Speech:

Responding to User Preferences

Users can enable or disable accessibility features from the TitanOS home screen settings. Your application should listen for these changes and adapt its behavior accordingly. Monitoring Accessibility Settings:
Note: The events returns the function to unsubscribe (clean) the function after using it. Call the function returned when you are no longer using it to avoid accumulating the listeners.

Audio Description Implementation

Responding to the change event:
For more details on what Audio Definition is, please refer to: Audio Description (AD)

Testing Your Accessible App

Thorough testing is vital to ensure your app is truly accessible.
  • Manual Testing with Remote Control:
    • Navigate your entire application using only the TV remote’s D-Pad (directional buttons) and the OK/Enter button.
    • Ensure every interactive element (buttons, links, inputs) is reachable and highlightable.
    • Verify that when the Accessibility Reader is enabled, all relevant elements are announced correctly as focus moves.
    • Test dynamic content updates (e.g., loading messages, form errors) to ensure they are spoken.
  • Live Testing on TV:
    • Test directly on Titan OS devices with Accessibility settings (TTS, Text Magnification and Audio Description) enabled/disabled via the OS home screen. This provides the most accurate user experience.

Implementation by brands (Brand Check)

This is now tottally optional! In earlier versions of Titan OS accessibility features, the implementation strategy depended on the TV manufacturer. Today, both approaches (Automatic WAI-ARIA native screen reader and Custom Voice Announcements) are delivered through a unified Titan SDK interface. You no longer need brand-specific logic to achieve consistent accessibility behavior. However, if your application still needs to apply custom logic or fallback behavior for specific manufacturers (or legacy firmware), you can detect the device brand at runtime using deviceInfo.getDeviceInfo(), as shown below: Note: For new integrations, relying on isTTSSupported() and getTTSSettings() (the same for Text Magnification and Audio Description) is sufficient across all supported Titan OS TVs. Use brand detection only if your architecture explicitly requires different behaviors per manufacturer. To see which devices have support to the accessibility featyres, refer to the Devices Specifications. Implementation:

Real-World Examples & Resources

To see these features in action and understand more about the integration, explore these examples on GitHub: We are committed to receiving feedback and continuously improving our documentation and examples.

Next steps

Migration to Titan SDK

Learn how to migrate from the DeviceInfo API to the new TitanSDK

About the new TitanSDK

Introduction to the new TitanSDK