Measure KPIs for Fire TV apps on Fire OS

Performance testing is the process of app testing in areas such as compatibility, reliability, speed, response time, stability, and resource usage on Amazon Fire TV devices running Fire OS. You can use this testing to identify and address your app's performance bottlenecks. Performance testing involves gathering and evaluating key performance indicator (KPI) metrics. To gather KPI metrics, you run a specific set of steps on an Amazon device and then find or calculate the metrics using device resources, such as logs.

Make sure to run performance tests before submitting your app to Amazon Appstore. By regularly tracking these KPIs, you can verify that your app delivers a smooth, responsive experience.

Understanding latency and memory:

• Latency measures how quickly your app launches and becomes usable. Users expect near-instant app startup and minimal delay before interacting with content.
• Memory measures how efficiently your app uses device RAM. Excessive memory consumption leads to system kills, poor multitasking performance, and degraded user experience.

Prerequisites

Before you measure app KPIs on Fire OS:

1. Install the following software packages on your development computer:
   • Amazon Corretto
   • Android Studio (make sure to install platform tools during setup)
   • Appium
2. Complete the following setup:
   • Set up a path for JAVA_HOME and ANDROID_HOME folders.
   • Enable developer mode on the device and enable USB Debugging. For instructions, see Enable Debugging on Amazon Fire TV.
   • Capture the serial number of the attached device using:

       adb devices -l
     

3. Read the following sections:
   • App KPI metrics and guidelines
   • Launch scenarios
   • Fully drawn marker

App KPI metrics and guidelines

The following table lists KPI metrics to measure for Fire TV apps on Fire OS, and the recommended guideline for each. These metrics measure launch performance and memory efficiency.

Launch scenarios

Performance testing measures two types of app launch scenarios to evaluate TTFF and TTFD:

• Cold start – When a user launches an app after they force stop the app process or reboot the device. The system must load all resources and dependencies into memory.
• Warm start – When a user moves an app from background (inactive state) to foreground (active state) with some resources and dependencies already in memory.

Fully drawn marker

A fully drawn marker signals when your app becomes interactive for users. The marker:

• Indicates when your app completes loading its essential components.
• Marks when users can start interacting with your app.
• Helps measure TTFD performance.

To implement, call reportFullyDrawn() from your Activity at these key points:

• Cold start – After loading initial data and rendering the main screen (sign-in page or home page).
• Warm start – When your app becomes responsive after foregrounding.

The following example code shows how to add a fully drawn marker.

• Java
• Kotlin

public class MainActivity extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        getWindow().getDecorView().post(() -> {
            reportFullyDrawn();
        });
    }
}

class MainActivity : Activity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        window.decorView.post { reportFullyDrawn() }
    }
}

Measure KPIs with ADB and Atrace

Use Android Debug Bridge (ADB) and Atrace to measure each KPI on a Fire TV device running Fire OS.

Test strategy

During testing, you launch the app and force stop it several times using the app launcher intent or the Monkey tool. Between each iteration, capture Atrace logs, perform navigation actions, capture timer values, and capture memory usage before force stopping.

Amazon recommends running the following minimum number of iterations.

Devices to test

For test coverage across Fire OS versions, test on the following reference devices.

Cold start KPIs

Cold start KPIs measure app performance when launching the app after force stopping the app process or rebooting the device.

TTFF - cold start

1. Force stop the app:

    adb -s <DSN> shell am force-stop <package_name>
   

2. Start Atrace:

    adb shell atrace -o /sdcard/atrace.capture -t 15 -b 32000 -a <package_name> gfx input am view wm
   

3. Launch the app:

    adb -s <DSN> shell monkey --pct-syskeys 0 -p <package_name> -c android.intent.category.LEANBACK_LAUNCHER 1
   

4. Wait 30 seconds.
5. Pull the Atrace logs:

    adb -s <DSN> pull /sdcard/atrace.capture ./atrace_cold_<iteration>.txt
   

6. Calculate time difference:
   • Start marker: AMS.startActivityAsUser
   • End marker: eglSwapBuffersWithDamageKHR
7. Force stop the app.
8. Repeat steps 1–7 for 50 iterations.

TTFD - cold start

Follow the same steps as TTFF - cold start, but use these markers:

• Start marker: AMS.startActivityAsUser
• End marker: Activity.reportFullyDrawn (matching app PID)

Repeat for 10 iterations.

Warm start KPIs

Warm start KPIs measure app performance when bringing the app from background to foreground, with some resources already in memory.

TTFF - warm start

1. Launch the app and press Home to send it to background.
2. Start Atrace.
3. Launch the app (bringing it to foreground) using the Monkey tool.
4. Wait 30 seconds.
5. Pull the Atrace logs.
6. Calculate time difference:
   • Start marker: AMS.startActivityAsUser
   • End marker: eglSwapBuffersWithDamageKHR
7. Press Home button to send the app to background.
8. Repeat steps 2–7 for 50 iterations.

TTFD - warm start

Follow the same steps as TTFF - warm start, but use Activity.reportFullyDrawn as the end marker.

Repeat for 10 iterations.

Foreground memory KPIs

Foreground memory KPIs capture your app's memory consumption while it's actively running and playing content.

1. Download, install, and sign in to the app (if applicable).
2. Force stop the app.
3. Launch the app using the Monkey tool.
4. Play video content for 10 minutes.
5. Wait 120 seconds.
6. Capture foreground memory:

    adb -s <DSN> shell dumpsys meminfo <package_name>
   

7. Force stop the app.
8. Repeat steps 2–7 for 5 iterations.

The PSS Total from dumpsys meminfo is the primary metric.

Background memory KPIs

Background memory KPIs capture your app's memory consumption after it has been moved to the background. When RAM is low, the system is more likely to kill apps with high background memory usage.

1. Download, install, and sign in to the app (if applicable).
2. Launch the app and play video content for 10 minutes.
3. Press Home button to send the app to background.
4. Wait 60 seconds.
5. Capture background memory:

    adb -s <DSN> shell cat /proc/<PID>/statm
   

6. Repeat steps 2–5 for 5 iterations.

Summary of guidelines

The following table summarizes the recommended guidelines and measurement iterations for each KPI.

KPI health assessment

Use the following indicators to evaluate whether your app's KPI results meet the recommended guidelines.

Tools

The following tools can help you measure and monitor app KPIs on Fire TV devices:

• Android Debug Bridge (ADB) – Command-line tool for communicating with Fire TV devices.
• Atrace/Systrace – System tracing utility for capturing performance markers.
• Monkey tool – App launcher for automated testing.
• Appium – Test automation framework.
• Maestro – Script-based UI automation for memory/playback scenarios.
• Android Studio Profiler – Real-time CPU, memory, and network profiling.
• App Health Insights Dashboard – Developer Console dashboard for tracking live app metrics.

Related topics

• App Performance Scripts for Fire TV
• To learn more about ADB commands, see Android Debug Bridge (adb) in the Android developer documentation.
• For more tests on Fire TV devices, see Test criteria group 2a: App behavior on Fire TV device.

Last updated: Jul 23, 2026