Developer Console

How to use Amazon Q Developer to boost productivity for Fire app development

Amazon Appstore Developer May 22, 2025

AI has been at the forefront of developer conversations for a while. But how can it actually help you create an app, no matter your skill level? Meet Amazon Q Developer.

Q is one of the most exciting Amazon developer tools we now have available. It’s an Amazon AI coding assistant that can be integrated into most popular IDEs—including Android Studio—and even used directly on the CLI. It's designed to use context-aware suggestions to help you efficiently write, test, and understand code. It can assist you with:

Generating code
Writing tests
Reviewing and refactoring
Integrating APIs
... and more.

Since Q is trained on both Amazon and open-source code, it’s especially handy for teams building apps for Fire tablets and Fire TV. Whether you're a React Native developer who is new to Fire TV or a veteran Fire developer looking to increase productivity, Q can help you reduce friction so you can focus on building.

So let’s get into what Q can do and how best to use it.

Getting started with Q in Android Studio

Q can help dramatically increase your Android Studio productivity level. To get started, download and install the latest version of Android Studio. For this guide, we’ll use Meerkat Feature Drop (2024.3.2).

Install the plugin

Open Android Studio and navigate to File ➤ Settings (or Android Studio ➤ Settings on a Mac). Find the Plugins settings and click Marketplace at the top. Search for "Amazon Q." Click Install.

After installing the plugin, you may need to restart Android Studio. Now, the Amazon Q tool menu will be available in the bottom-right corner of the application.

Click on it, then select Get Started.

The plugin will display the option for you to connect via your AWS Builder ID. Click Connect.

Your browser will open, and you'll be asked to authenticate by signing in with your AWS Builder ID or to create a new profile if you don't have one. After authenticating, you'll have full access to Q within Android Studio.

Now, the Amazon Q tool menu will display the following:

Enable chat panel in Android Studio

One of the key features of the Amazon Q plugin for Android Studio is the chat panel. To enable it in Android Studio, you’ll need to change your boot runtime to JetBrains Runtime JBR with JCEF.

1. Navigate to Help ➤ Find Action….

2. Search for "Choose Boot Java Runtime for the IDE."

3. You'll notice that the current boot runtime is the "JetBrains Runtime" default. From the list of available runtimes, select one that is titled "JetBrains Runtime JBR with JCEF."

4. Click OK. Android Studio will install the boot runtime and then ask you to restart the IDE.

5. Click Restart now.

Now, when you click Open Chat Panel, this is what you will see:

Amazon Q Android Studio should now be fully functional!

Real world examples

Q comes equipped with a broad set of capabilities designed to help you code smarter and faster and keep you moving forward efficiently. So let’s get into some real, practical scenarios of how Amazon Q Fire app development works:

Scenario #1: Integrating APIs

If you're fairly new to working with Amazon's SDKs for Fire OS app development, you can use Q to help you quickly get started, scaffolding functions, giving you a solid foundation to build on.

Let's say you're building a Fire tablet app, and you want to implement in-app purchasing to facilitate subscriptions for premium content. You'll need to work with the Appstore SDK IAP. With Q, you can start with the /dev command to describe what you need.

Q will list a set of steps to generate the code you need.

Then, it will list out all the files it reviewed, along with proposed new files, changes, and deletions.

After listing out all of the proposed changes, it will ask if you're ready to accept the changes or if you need to request any adjustments.

Tell it to go ahead and Q will quickly create all the proposed files, providing the code that you can use to get started with the SDK IAP.

It can even generate layouts to help you navigate the UI/UX concerns as you explore and learn IAP.

Don’t forget this is just an example scenario. If you’re building a Fire TV app or you want to integrate Login with Amazon instead of IAP, Q can help with those scenarios too.

Scenario #2: Troubleshooting

Amazon Q doesn’t just write code to get you started, it can also help further along the journey when you get lost or stuck. Because Q is trained on open-source codebases as well as code related to Amazon properties and apps, it can help immensely with Fire-specific SDKs and APIs.

If you’re seeing an error or you don’t know what to do, ask questions, just like you would a friend or teacher who’s helping you write your app.

In this scenario, let's say you're using AWS Amplify to handle the backend concerns for your Fire TV app development.

You have the configurations set up for your backend data resource with Amplify but you also need to generate the GraphQL client code for your Java application. The Amplify (Gen2) CLI has a command for this, but you don't know what it is.

Ask Q. It can detect context based on your open files and project structure, then recommend the command to use for generating the client code.

Scenario #3: Comparing libraries

Maybe you’re unsure which library you want to integrate into your app.

For example, you're building a Fire tablet app, but you're unclear about the differences in how Fire OS supports the Android Leanback library versus Jetpack Compose. Q can provide detailed explanations about the differences:

It can go on to provide best practices, guidance, and code samples:

Scenario #4: Scaffold components and UI layout files

If your development process gets hung up on UI concerns, such as writing the XML for layouts and fragments, you can save time by asking Q to do the heavy lifting for you.

For example, imagine needing to introduce a new activity screen in your app. You know how you want the app to behave and what to display, but translating that into the correct files and code can be a slog. For this too, you can lean on Q with the /dev command.

Based on your request, Q will outline the steps to help you generate the code you need.

The tasks performed by Q include creating all the Activity classes, fragments, and XML layouts you need.

Using Amazon Q to scaffold the code for these components and layouts will help you avoid repetitive setup work, providing you with a strong starting point to refine designs to fit your needs.

Scenario #5: Generate and debug unit tests

Q can also generate unit test code when you use /dev requests. In the example below, it generates five tests for the PurchasingListener implementation.

It can even help with legacy code that needs unit tests, like in this example using the Fire TV Integration SDK Sample App.

Q detects the presence of some testing dependencies, but no test folders or files.

Based on the gaps identified, Q can create a comprehensive set of tests for all of the major parts of the project.

Q will even create a summary file (in markdown), detailing the project's current test coverage.

# Test Coverage Summary

This document provides an overview of the test coverage for the Fire TV Integration SDK Sample App.

## Unit Tests

### SDK Package Tests
- **FireTvIntegrationSDKUtilsTest**
  - Tests the `hashProfileId` function to ensure it correctly hashes profile IDs
  - Tests the `isFTVIntegrationSDKSupportedOnDevice` function for both supported and unsupported devices

- **FireTvPlaybackReporterTest**
  - Tests reporting of different playback states (PLAYING, PAUSED, EXIT, INTERSTITIAL)
  - Tests that no events are reported when the feature is not supported

- **FireTvWatchlistReporterTest**
  - Tests adding items to the watchlist
  - Tests removing items from the watchlist
  - Tests setting the entire watchlist
  - Tests that no actions are performed when the feature is not supported

- **MyAmznDataIntegrationServiceTest**
  - Tests retrieving and reporting recent playback events
  - Tests retrieving and reporting watchlist entries
  - Tests handling of non-watchlist types

### Util Package Tests
- **ExoPlayerUtilsTest**
  - Tests reporting of current player state for different scenarios (playing normal content, playing ads, paused, ended)
  - Tests reporting when the player exits playback

### Account Package Tests
- **AccountRepositoryTest**
  - Tests setting and getting login state
  - Tests setting and getting active profile
  - Tests the LiveData functionality for active profile

### Client Package Tests
- **MyCustomerDataApiClientTest**
  - Tests retrieving customer watch activity
  - Tests retrieving customer purchased content
  - Tests retrieving customer rented content
  - Tests retrieving customer recorded content
  - Tests retrieving customer subscriptions
  - Tests retrieving customer watchlist

### Model Tests
- **VideoModelTest**
  - Tests Video data class properties and equality
  - Tests WatchlistItem data class properties and equality

- **CustomerDataApiReturnTypesTest**
  - Tests conversion of CustomerPurchasedContent to AmazonContentEntitlement
  - Tests conversion of CustomerRentedContent to AmazonContentEntitlement
  - Tests conversion of CustomerRecordedContent to AmazonContentEntitlement
  - Tests conversion of CustomerListEntry to AmazonCustomerListEntry
  - Tests conversion of CustomerSubscriptionEntitlement to AmazonSubscriptionEntitlement
  - Tests conversion of CustomerTitleWatched to AmazonPlaybackEvent
  - Tests enum conversions for MyPlaybackState and MyEntitlementType

## Instrumentation Tests

- **MainActivityTest**
  - Tests that MainActivity shows SignInFragment when not logged in
  - Tests that MainActivity shows VideoBrowserFragment when logged in
  - Tests the FragmentReplacementListener functionality

## Infrastructure Changes

- Added necessary test directories (`test` and `androidTest`)
- Updated `build.gradle` with additional testing dependencies:
  - Mockito for mocking dependencies
  - PowerMock for mocking static methods
  - AndroidX Test libraries for instrumentation tests
  - Architecture Components testing for LiveData testing
- Modified `AccountRepository` to make it testable by adding a method to set the instance for testing

## Future Improvements

- Add more instrumentation tests for fragments and UI components
- Add integration tests for the interaction between components
- Implement code coverage reporting to identify areas that still need testing
- Add UI tests using Espresso for testing user interactions

As tests run and possibly fail, ask for help debugging and improving code, or ask Q to help you write more tests, such as functional and integration tests.

Just remember to keep your prompts clear and specific, to ensure that Q understands your context and your goals.

Using clear prompts like this will allow Q to create a comprehensive set of tests to cover component-to-component interactions.

Scenario #6: Refactor code into another programming language

What if you've been tasked with refactoring a legacy Java application into modern Kotlin? Q can enhance your productivity and efficiency here as well.

Consider this sample repository, written in Java to show how to integrate the LWA SDK in an Android app. You can ask Q to help you refactor the code, porting it to Kotlin.

Q will review the project to understand how best to refactor the codebase and then apply those conversions.

Q can replace Java files with Kotlin equivalents, as in this example.

Scenario #7: Identify and fix potential vulnerabilities

Q can also help you find and fix potential security vulnerabilities in your code. Use the /review command from the chat panel or click Full Project Scan from the Amazon Q tool menu in the bottom right of the application.

Q will run a full security review of the codebase, powered in part by the Amazon Q Detector Library—a collection of curated code analysis detectors designed to spot common security issues.

Q will scan the codebase, detect potential issues, and then categorize them based on criticality. For each issue it finds, it will provide a detailed explanation, pointing to the offending block of code and offering a fix.

Amazon Q on the command line

The Amazon Q Developer CLI can extend your productivity beyond the IDE. Use it just as you would within the IDE—to generate code, help with SDKs, write tests—but with the convenience and speed of working inside the terminal.

$ q

To learn more about MCP safety, see https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/command-line-mcp-security.html

Welcome to 

 █████╗ ███╗   ███╗ █████╗ ███████╗ ██████╗ ███╗   ██╗     ██████╗ 
██╔══██╗████╗ ████║██╔══██╗╚══███╔╝██╔═══██╗████╗  ██║    ██╔═══██╗
███████║██╔████╔██║███████║  ███╔╝ ██║   ██║██╔██╗ ██║    ██║   ██║
██╔══██║██║╚██╔╝██║██╔══██║ ███╔╝  ██║   ██║██║╚██╗██║    ██║▄▄ ██║
██║  ██║██║ ╚═╝ ██║██║  ██║███████╗╚██████╔╝██║ ╚████║    ╚██████╔╝

╭───────────────────────── Did you know? ─────────────────────────╮
│                                                                 │
│         You can use /editor to edit your prompt with a          │
│                       vim-like experience                       │
│                                                                 │
╰─────────────────────────────────────────────────────────────────╯


/help all commands  •  ctrl + j new lines  •  ctrl + k fuzzy search
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
> I need to work with the Leanback Library for an Amazon FireTV App that I'm building. Where should I start?

To start working with the Leanback Library for your Amazon FireTV App, I'll guide you through the essential steps:

The Leanback Library is part of the Android TV support libraries specifically designed for creating TV-optimized interfaces, which is perfect for your FireTV app.

Here's how to get started:

1. Set up your development environment:
   • Make sure you have Android Studio installed
   • Install the necessary SDK components for TV development

2. Create a new Android TV project:
   • In Android Studio, create a new project with the "Android TV Activity" template
   • This automatically includes the Leanback dependencies

3. Add Leanback Library dependencies to your existing project:
   • Open your app's build.gradle file and add:

gradle
dependencies {
    // Leanback library
    implementation 'androidx.leanback:leanback:1.0.0'
    
    // Optional but recommended for Leanback apps
    implementation 'androidx.leanback:leanback-preference:1.0.0'
    implementation 'androidx.leanback:leanback-paging:1.0.0'
}

4. Configure your AndroidManifest.xml:
   • Ensure your app is marked as a TV app
   • Add required Leanback theme

xml
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.yourapp">
    
    <uses-feature
        android:name="android.hardware.touchscreen"
        android:required="false" />
        
    <uses-feature
        android:name="android.software.leanback"
        android:required="true" />
        
    <application
        android:banner="@drawable/app_banner"
        android:theme="@style/Theme.Leanback">
        
        <!-- Activities -->
        <activity
            android:name=".MainActivity"
            android:theme="@style/Theme.Leanback">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LEANBACK_LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>

5. Implement key Leanback components:
   • BrowseFragment: Main navigation interface
   • DetailsFragment: For showing detailed content
   • PlaybackFragment: For media playback
   • SearchFragment: For search functionality

6. Follow Fire TV specific guidelines:
   • Optimize for D-pad navigation
   • Implement proper focus handling
   • Design for 10-foot UI experience

Would you like me to provide a simple code example for implementing a basic BrowseFragment to get you started with the UI structure?

Wrap-up: Smarter development for Fire apps

Amazon Q Developer is built to reduce development friction and help you move from idea to implementation more efficiently.

If you're developing apps for Fire tablets or Fire TV, Q can be a great way to get started, improve code quality, automate repetitive tasks, and streamline your overall workflow. Try it out—both in the Android Studio IDE, or straight from the command line—and see how it fits into your development process.