Display and Layout (Fire TV)
Fire TV devices render your app's UI on a 1080p or 720p UI canvas, at a screen density that depends on the device. To render well on a TV, your layouts must account for screen resolution, density, and density-independent pixels (dp).
This document provides technical information for building your UI layouts on Amazon Fire TV devices. See Design and User Experience Guidelines for general guidelines on TV design.
Screen size and resolution
Many Android devices, such as Fire tablets, have a fixed physical size and a single resolution. This isn't the case with Amazon Fire TV devices, to which you can connect a 720p or 1080p screen of any size.
To keep your layouts the same size at any resolution, specify dimensions in dp instead of pixels.
The following table shows the size, screen density, and display resolution in dp of each UI canvas on Fire TV devices.
| UI canvas | Canvas size (pixels) | Density identifier | Display resolution (dp) | Screen size identifier |
|---|---|---|---|---|
| 1080p | 1920 x 1080 | xhdpi (320) |
960 x 540 | large |
| 720p | 1280 x 720 | tvdpi (213) |
~960 x 540 | large |
The device sets the UI canvas, which is the surface your app's UI renders to. The UI canvas can differ from the output resolution of the connected TV. Because Android scales dp units to match each canvas density, the display resolution is about 960 x 540 dp on every canvas. If you build your layouts in dp, they render the same on every Fire TV device and need no per-device changes.
Orientation
The orientation of the Amazon Fire TV device never changes, and requests for the rotation or orientation on the device return these results:
| Method | Result |
|---|---|
Display.getRotation() |
0 (ROTATION_0) |
Display.getOrientation() (deprecated) |
0 (ORIENTATION_UNDEFINED) |
Resource configurations
If you design your app to run on devices other than Amazon Fire TV, such as tablets, you can create different layouts and drawables for each device type, and store them in subdirectories of res/ named for various device configurations. For more information on using these resource configurations, see the Android Screen compatibility overview.
The following table describes the resource configurations available on Amazon Fire TV devices.
| Configuration | Value |
|---|---|
| Smallest width | sw540dp |
| Available width | w960dp |
| Available height | h540dp |
| Screen size | large |
| Screen aspect | long |
| Screen orientation | land (TV apps are always landscape) |
| UI mode | television |
| Night mode | notnight |
| Screen pixel density | xhdpi (1080p UI canvas) or tvdpi (720p UI canvas) |
| Touchscreen type | notouch |
| Keyboard availability | keyssoft |
| Primary text input method | nokeys |
| Navigation key availability | navexposed |
| Primary non-touch navigation method | dpad |
| Platform version | v17 |
Layout best practices
Follow these practices so that your app renders correctly on every UI canvas:
- Size your UI in dp, not px. Don't hardcode 1920 x 1080 or other pixel values in your layouts or code.
- Get the screen size from the window. Use
WindowMetrics(API level 30 and higher),Resources.getDisplayMetrics(), orConfiguration. Don't useDisplay.Mode, which reports the resolution of the TV panel, not the UI canvas. - Don't gate layouts or assets on a density threshold. For example, a check such as
densityDpi >= 320fails on atvdpicanvas. Use resource qualifiers or dp-based sizes instead. - Request and decode images at their displayed size. Calculate the pixel size from the current density (dp ×
DisplayMetrics.density), and include any zoom applied on focus. Don't request images at a fixed 1080p pixel size.
The following example reads the UI canvas size from the window and converts a dp size to pixels for an image request:
import kotlin.math.roundToInt
// Read the UI canvas size from the window, not from Display.Mode.
val metrics = resources.displayMetrics
val canvasWidthPx = metrics.widthPixels // 1920 on xhdpi, 1280 on tvdpi
val canvasHeightPx = metrics.heightPixels // 1080 on xhdpi, 720 on tvdpi
// Convert a dp size to pixels for the current density.
fun dpToPx(dp: Float): Int = (dp * resources.displayMetrics.density).roundToInt()
// Size a 200 dp wide poster that zooms to 1.1x on focus.
val posterWidthPx = dpToPx(200f * 1.1f) // 440 on xhdpi, about 293 on tvdpi
Related topics
Last updated: Oct 30, 2026
