Developing for Amazon Fire TV Devices Running Fire OS 16

Fire OS 16 is based on API level 36. The following sections explain some of important changes that you should consider when you build apps for Fire OS 16. The migration to standard Android components in the following sections help reduce the risk of compatibility issues and provide ease of maintenance for your app.

• Devices that run Fire OS 16 and previous Fire OS versions
• Android updates
  • ART internal API restrictions
  • Edge-to-edge display enforcement
  • TLS 1.0/1.1 removal
  • 16 KB page size support
  • Local network permission required
  • Dolby/DTS audio passthrough invalidation
  • BOOT_COMPLETED behavior change
  • Foreground service type required
  • Predictive back gesture enforcement
  • targetSdkVersion constraints
  • Exact alarm restrictions
  • RenderScript removal
  • JobScheduler quota enforcement
  • Discontinued accessibility announcements
  • Media projection consent required
• Update your Amazon SDKs
• Target your app for Fire OS 16 devices
• Test your app
• What to set for minSdkVersion and targetSdkVersion
• How minSdkVersion affects supported devices and backwards compatibility
• Support
• Related topics

Devices that run Fire OS 16 and previous Fire OS versions

Fire OS 16 incorporates updates from Android 15 (API 35) and Android 16 (API 36). Some older Fire TV devices remain on earlier versions of Fire OS.

For a detailed list of Fire TV devices and versions, see Fire OS Versions.

Android updates

The following is a list of important features and behavioral changes for you to know when upleveling to Android 16:

• Android 16 features and APIs
• Android 15 features and APIs

ART internal API restrictions

Android 16 restricts access to internal Android Runtime (ART) and Dalvik classes (sun.misc.Unsafe, dalvik.system.*, libcore.io.*). It also restricts reflection into hidden framework APIs.

Solution

If your app uses these internal APIs, do the following:

• Replace sun.misc.Unsafe with java.lang.invoke.VarHandle or AtomicReferenceFieldUpdater.
• Replace dalvik.system.* with public ClassLoader APIs.
• Check your dependencies. Many third-party ad SDKs and analytics libraries use these internal APIs. Update to the latest versions of your third-party SDKs.

Edge-to-edge display enforcement

Android 15 (API 35) enforces edge-to-edge rendering for apps targeting SDK 35+.

On Android 16 (API 36), the windowOptOutEdgeToEdgeEnforcement theme attribute that allowed apps to opt out is completely ignored. Apps that previously used this workaround will have broken layouts.

Solution

If your app uses windowOptOutEdgeToEdgeEnforcement, do the following:

• Use WindowInsetsCompat APIs to handle insets properly.
• Remove any windowOptOutEdgeToEdgeEnforcement as it no longer works on API 36.
• Test your app's layout to ensure no content is obscured.

For details, see Edge to edge opt-out going away.

TLS 1.0/1.1 removal

Starting with Android 15 (API 35), TLS 1.0 and TLS 1.1 protocol versions are disallowed.

Solution

If your app uses TLS 1.0/1.1, do the following:

• Ensure your backend servers support TLS 1.2 or higher.
• Remove any explicit TLS 1.0/1.1 configuration from your SSLContext or OkHttp client setup.
• Update your network_security_config.xml if it specifies minimum TLS versions.

16 KB page size support

Android 16 introduces support for 16 KB memory page sizes. If your app includes native (NDK) libraries, you must compile those libraries with 16 KB page alignment.

Solution

If your app includes native libraries, do the following:

• Rebuild native libraries with -Wl,-z,max-page-size=16384.
• Verify alignment using objdump -p libYourLib.so | grep LOAD.

Apps with improperly aligned native libraries might crash or fail to load on devices running 16 KB page-size kernels.

On Android 16, apps with 4 KB aligned native libraries that lack the android:pageSizeCompat manifest declaration trigger a user-facing compatibility warning dialog on every launch and run in degraded compatibility mode. To suppress the warning and avoid compatibility mode, either recompile your native libraries with 16 KB alignment or add the following to your manifest:

<application
    android:pageSizeCompat="true"
    ... >

Local network permission required

Android 16 requires the NEARBY_WIFI_DEVICES permission for apps using local network discovery (mDNS, SSDP, NsdManager, multicast).

Solution

Use the following permission:

<uses-permission android:name="android.permission.NEARBY_WIFI_DEVICES" />

Without this permission, device discovery and casting features (Chromecast, smart speakers, multi-room audio) will stop working.

Dolby/DTS audio passthrough invalidation

Starting with Android 15 (API 35), the system may invalidate AudioTrack instances using passthrough or offload audio encodings (Dolby AC3, E-AC3, DTS, TrueHD) when resource limits are reached.

Solution

If your app uses the above audio encodings, do the following:

• Register an AudioTrack.OnRoutingChangedListener to detect when audio output is invalidated.
• Handle the invalidation gracefully by recreating the AudioTrack or falling back to decoded audio output.
• Test HDMI passthrough scenarios (Dolby/DTS surround sound) thoroughly.

BOOT_COMPLETED behavior change

Starting with Android 15 (API 35), apps in the "stopped" state no longer receive BOOT_COMPLETED broadcasts. An app enters the stopped state when it is freshly installed (never launched) or when the user force-stops it.

Additionally, Android 15 blocks apps with BOOT_COMPLETED receivers from starting restricted foreground service types (media playback, data sync, camera) during boot.

Solution

Review your BOOT_COMPLETED receivers and remove any that start restricted foreground service types. Use WorkManager instead.

For details, see Changes to package stopped state.

Foreground service type required

Starting with Android 14 (API 34), all foreground services must declare a foregroundServiceType in the manifest. On Fire OS 16, apps that declare FOREGROUND_SERVICE permission without a service type crash with MissingForegroundServiceTypeException.

Solution

Use the following service type:

<service
    android:name=".PlaybackService"
    android:foregroundServiceType="mediaPlayback"
    android:exported="false" />

Valid types include the following: mediaPlayback, dataSync, location, camera, microphone, phoneCall, connectedDevice, mediaProjection, health, remoteMessaging, systemExempted, shortService, and specialUse.

Predictive back gesture enforcement

Starting with Android 16, the predictive back gesture is enforced for all apps. The deprecated onBackPressed() method and KeyEvent.KEYCODE_BACK interception no longer control back navigation behavior.

Solution

1. Set android:enableOnBackInvokedCallback="true" in your AndroidManifest.xml <application> tag.

   <!-- AndroidManifest.xml -->
   <application
      android:enableOnBackInvokedCallback="true"
       ... >
   

2. Replace all onBackPressed() overrides with OnBackInvokedCallback or the Jetpack OnBackPressedCallback API.

   • Java
   • Kotlin

   getOnBackInvokedDispatcher().registerOnBackInvokedCallback(
       OnBackInvokedDispatcher.PRIORITY_DEFAULT,
       () -> {
           // Handle back navigation
       }
   );
   

   onBackInvokedDispatcher.registerOnBackInvokedCallback(
       OnBackInvokedDispatcher.PRIORITY_DEFAULT
   ) {
       // Handle back navigation
   }
   

targetSdkVersion constraints

Starting with Android 14 (API 34), users can't install apps that have a targetSdkVersion lower than 23. The requirement to meet this minimum target API level improves security and privacy for users. On Fire OS 16:

• Apps with targetSdkVersion earlier than 24 might be blocked from installation entirely.
• Apps with targetSdkVersion between 24 and 27 show a one-time compatibility warning to the user.

For more details, see Ensure compatibility with Android 16.

Exact alarm restrictions

Starting with Android 14 (API 34), SCHEDULE_EXACT_ALARM is no longer pre-granted. Apps must check canScheduleExactAlarms() at runtime before scheduling exact alarms.

Solution

Use the following code example as a starting point:

• Java
• Kotlin

AlarmManager alarmManager = getSystemService(AlarmManager.class);
if (alarmManager.canScheduleExactAlarms()) {
    // Schedule exact alarm
} else {
    // Fall back to inexact alarm or request permission
}

val alarmManager = getSystemService(AlarmManager::class.java)
if (alarmManager.canScheduleExactAlarms()) {
    // Schedule exact alarm
} else {
    // Fall back to inexact alarm or request permission
}

RenderScript removal

The RenderScript runtime has been removed starting with Android 15 (API 35). Apps that bundle RenderScript libraries (librenderscript-toolkit.so, libRSSupport.so, librsjni.so) crash on Fire OS 16.

Solution

Migrate image processing code using Vulkan compute or the RenderScript Intrinsics Replacement Toolkit. For details, see Migrate from RenderScript.

JobScheduler quota enforcement

Android 16 introduces stricter runtime quotas for JobScheduler. Jobs that run too long or too frequently might be throttled or stopped. Code decompilation analysis shows 91% of Fire TV apps (108 of 119) use JobScheduler and are subject to these quotas. This is a behavioral change. Apps will not crash, but background tasks might become less reliable over time.

For more details, see JobScheduler quota optimizations.

Discontinued accessibility announcements

Android 16 no longer supports announceForAccessibility() and TYPE_ANNOUNCEMENT accessibility events.

Solution

If your app uses these discontinued APIs, do the following:

• Replace announceForAccessibility() with setAccessibilityPaneTitle() or android:accessibilityLiveRegion (for live regions).
• Replace TYPE_ANNOUNCEMENT events with TYPE_WINDOW_STATE_CHANGED using pane titles.

Media projection consent required

Starting with Android 15 (API 35), apps using MediaProjection APIs must obtain per-session user consent. Previously granted permissions no longer persist across sessions.

Solution

If your app uses MediaProjection APIs, do the following:

• Request MediaProjection permission each time screen capture or recording is initiated.
• Handle the case where the user denies consent gracefully.

Update your Amazon SDKs

If your app integrates any Amazon SDKs, ensure you are using the latest versions compatible with Fire OS 16.

For the full list of SDKs, see Amazon SDKs and Samples.

Target your app for Fire OS 16 devices

Users might run your app on a Fire OS 5, Fire OS 6, Fire OS 7, Fire OS 8, Fire OS 14, or Fire OS 16 device. To maximize your app’s compatibility with the Fire OS version on the device, Amazon recommends that you target the device based on the SDK level.

In your code, you can check whether Build.VERSION.SDK_INT is greater than or equal to 36 (Android 16 API level) to target Fire OS 16 devices.

For more details, see Support different platform versions.

Test your app

In order to test your app on Fire OS 16 devices, you can use Live Device Interaction (LDI) of Appstore Quality Central. With LDI, you can remotely access a Fire OS 16 device in the Appstore device farm and run tests on the device. To learn more about LDI, see Live Device Interaction.

Additionally, if you want to distribute your app for closed beta testing, you can use Live App Testing (LAT) and accordingly target the Fire OS 16 device. To get started with LAT, see Get Started with Live App Testing.

What to set for minSdkVersion and targetSdkVersion

Set targetSdkVersion to the highest API level that you're targeting. For Fire OS 16 devices, Amazon requires that you set targetSdkVersion to 36. To guarantee app compatibility for your apps on Fire OS 16 devices, you must uplevel your apps on older Fire TV devices running Fire OS 5, Fire OS 6, Fire OS 7, Fire OS 8, and Fire OS 14 to targetSdkVersion 36.

You can still support older devices by setting minSdkVersion to the API level you want.

The following table shows the API level based on the Fire OS version.

For more details, see Device Filtering and Compatibility.

How minSdkVersion affects supported devices and backwards compatibility

In your app manifest (or build.gradle file), minSdkVersion sets the minimum SDK level that your app needs in order to function properly. Devices that don't support that API level prevent users from installing the app on that device — this is how device filtering and compatibility works with the Appstore.

Fire OS 5 devices are based on API level 22 (Lollipop 5.1). Fire OS 16 devices are based on API level 36 (Android 16). When you set minSdkVersion to 22, you've decided that your app requires the device to have at least API level 22 for it to function properly.

When you set minSdkVersion to 22, your app also installs on any devices that have a higher API level (such as 34), because Android levels are backwards-compatible. API level 34 usually includes all the APIs for levels 1 through 34. Each release adds an API level to the previous levels.

However, suppose you want to take advantage of APIs in Android 16 (API level 36). If you set minSdkVersion to 22, your app installs on Fire OS 5 devices that don't have level 34 APIs. Therefore, you must code in a defensive way to check the device API level and fall back to alternatives if the device doesn't support that API level. Your code might look like the following code example.

if (Build.VERSION.SDK_INT >= 36) {
    // Fire OS 16 / Android 16 specific code
} else {
    //Fallback for older devices
}

In the previous example, the code checks whether the device's API level is greater than or equal to 36, and if so, runs the code. If not, the code falls back on the else logic.

By default, if targetSdkVersion is not specified, Android uses the same value as minSdkVersion. Specifically, targetSdkVersion lets you set the latest API level that you have tested your app against. Based on this value, Android will ensure proper behavior on devices at this level.

Although not recommended, if you must prevent older apps from appearing on Fire OS 16 devices, you can set maxSdkVersion to Fire OS 14 (34).

For more details, see the following resources:

• <uses-sdk>
• Support different platform versions
• Picking your compileSdkVersion, minSdkVersion, and targetSdkVersion

Support

If you notice any issues with your app on Fire OS 16, note the issue in the Amazon Fire TV and Fire TV Stick forums.

Related topics

• Fire OS versions
• Identifying Fire TV Devices
• Device Filtering and Compatibility
• Integrate Your App

Last updated: May 20, 2026