No results found

Try a different or more specific query
Developer Console
Amazon Developer Blogs

Amazon Developer Blogs

Showing posts tagged with Tips and Tricks

July 10, 2014

David Isbitski

With the launch of the Fire, Amazon’s first Android-based phone, you can now create experiences where customers interact in an entirely new way with your apps. With Dynamic Perspective, apps can have peek, tilt and zoom capabilities all based on customer head movements. You can also use the Firefly button to identify virtually anything and enable actions your customers can take based on what they identify. By enhancing or optimizing your apps for Fire, you have the opportunity to enable experiences that combine realistic visuals and bring new depth to what customers can do on a phone. And while you think about the new experiences you can offer your user, you can get the current version of you app running on Fire with little or no modification. Here are 10 tips to help you get your apps running on Fire phone today!

Tip 1 – Register for a Free Amazon Developer Account

Fire uses the Amazon Appstore exclusively, and we’ve streamlined the process to make it easy to submit your app. Registration is free, fast, has no annual subscription cost, and supports both free and paid apps. Once your Fire phone app is submitted you also have the option to distribute the apps across Kindle Fire, Fire TV and Android devices simply by selecting those device targets in the developer console. The boxes indicating your intent to publish on other devices will be pre-checked in the console. Most Fire apps will also work on Kindle Fire tablets and Android devices, so just keep those checked if you are not sure. To get started:

  1. Sign in or register for a free developer Amazon Apps & Games Developer Portal account. If you do not already have one, you will be prompted to create an account
  2. Submit your payment and tax information if you intend to sell a paid app or offer in app items for purchase.

Tip 2 – Download the Fire SDKs

Fire phone development APIs fall into two categories: Dynamic Perspective SDK and Firefly SDK. Both SDKs are available through the standard Android SDK Manager as a single add-on and support a variety of programming languages.

To download the add-on simply open the Android SDK Manager from a command line or from within Android Studio and do the following:

  1. Add the following user-defined site, in the Manage Add-on Sites dialog:
  2. Expand Android 4.2.2 (API 17) and click SDK Platform and Amazon Fire Phone SDK Addon.

Macintosh HD:Users:dave:Desktop:Screen Shot 2014-07-01 at 9.34.32 PM.png

  1. Accept license agreement and install the packages.
  2. Set your project up in Eclipse and specify Amazon Fire Phone SDK in the Compile With drop-down.

The SDK includes everything you need to get started including multiple sample projects and Android Studio gradle support.

You also have the option to download the Fire Phone SDK directly without installing the add-on here.

Tip 3 – Test Your APK compatibility with the Amazon Testing Service

Fire is based on the latest version of Fire OS 3.5, which is based on Android API level 17. Android app compatibility is supported on Fire OS, so if an app runs on Android it can run on Fire with little or no effort. Simply drag and drop your Android APK and receive feedback on your app's compatibility within 90 seconds. You will also have access to additional Fire phone test results that enable you to see how your app looks and performs on Fire phone. The test results are presented in 6 hours and include carousel, peek and tilt actions.

Checking APK compatibility and submitting can be done in just a few steps:

  1. Drag and drop your APK to the app-testing control here.
  2. If your app passes testing, you can submit it to the Amazon Appstore right away. If testing reveals any issues, you will see a list of issues to address. 

Tip 4 – Become Familiar with the Fire Phone Design Guidelines

Fire represents a huge leap forward in mobile user experiences. As a developer, you’ll want to design the best customer experience possible for this new platform. To help you achieve that, we’ve outlined the core design principles that will allow you to take advantage of Fire’s unique Dynamic Perspective features in our guide here.

The good news is that if you are an Android developer your app will work on Fire with little or no work, and as you will see, just a few modifications to your app’s user experience will let it better take advantage of all that the Fire SDK has to offer.

For additional best practices for designing Fire phone user experiences check out our blog post here.

Tip 5 - Add the Fire Phone Android Theme to Your App

The quickest optimization you can make is to set the application Theme in your Android app’s AndroidManifest.xml file. This updated Amazon theme will set app fonts, color pallet and skinned controls to match Fire phone’s design guidelines.

Simply set the android:theme argument to the application section of the Android Manifest to Theme.DeviceDefault, as introduced in Android 4.0, and your application will pick up the skinned controls that match Fire phone.

Tip 6 – Utilize the Fire Foundation Controls

The Fire Foundation Controls are included in the Dynamic Perspective SDK and give your app 2D controls designed and built for use with the device. These controls currently include SidePanel, HeaderNavigationBar, TabBar, ToolBar and MediaController. All of these controls can be implemented in three steps just as you would with any Android control.

Step 1: Prepare the Android Manifest
The Android manifest needs to be modified to include a <uses-library> tag to load the Foundation Controls library (in addition to setting the theme as mentioned in Tip 3).


Step 2. Place the control in your XML Layout file

In this example Android layout file we are referencing the new header navigation bar and utilizing two additional files. Strings.xml will contain the names of our menu items and header_menu.xml file defines the menu items for the HeaderNavigationBar's actions menu.

XML layout for HeaderNavigationBar inside of a RelativeLayout view:

Strings.xml containing menu item names:

Header_menu.xml containing action menu items:

Step 3. Implementing the Control

All of the APIs for Fire phone will be installed into your <Android_SDK>/sdk/add-ons/addon-amazon_fire_phone_sdk_addon-amazon-17 folder including the SDK samples. To access the controls you will need to reference them from your own app. For example, to implement the HeaderNavigationBar make sure you reference the amazon.widget.* package and implement the control. The following code shows how to inflate the XML layout into a view, obtain a reference to the HeaderNavigationBar, use the reference to set a click listener on the actions menu, and implement up navigation.

In the case of the HeaderNavigationBar we will also disable the Android title bar before inflating the layout. We can also programmatically change menu items by setting properties directly on the HeaderNavigationBar like so:

For more details on implementing Foundation Controls in your Android app check out our Implementing Foundation Controls for Fire phone guide here.

Tip 7 - Implement a Side Panel Layout

One easily identifiable layout characteristic of Amazon Fire apps is the Side Panel layout included as part of the Fire Foundation Controls. Implementing the Side Panel layout will go a long way to giving your app that Fire phone look and feel.

With this control, no matter what the current view in your app, a user can always access your menu or a context aware page just by executing a quick swipe or gesture.

For example, doing a quick right-flick of the phone (or swiping in from the left) can expose a navigation pane. You can also put a context-sensitive pane a flick away in the other direction. In the picture above, the middle content panel is a Music Store. The left panel is a navigation panel, and the right panel is context sensitive, and when the user is looking at music in the content panel, the right panel will show recommendations.

SidePanel Layout works very similar to the HeaderNavigationBar described above. You will need to reference the EAC library in your Android Manifest like above, reference the same amazon.widget library in your java code and then define the left, right and content panels in your XML layout file.

A full Side Panel sample project is included with the Fire SDK under the /Samples/SidePanels folder and you can get more details about implementing a Side Panel layout here

If you don't have a Fire phone you can also use the simulator included in the SDK to test your SidePanel implementations.

Tip 8 – Adding Depth and Perspective to Your Android App Interface

In addition to the 2D Foundation Controls, Dynamic Perspective includes a rich set of APIs and Controls to help developers incorporate peek, tilt and zoom capabilities within their apps while adding a sense of realistic depth and perspective. These controls work behind the scenes with Fire’s advanced camera and sensors to automatically adjust their appearance based on how your application is being viewed. These new UI Controls are part of the Euclid package included in the Fire phone SDK.

For the most part, Euclid controls are very similar to their Android and Foundation Controls counterparts. Euclid controls retain the name of the original base control, but with a "Z" prepended to the name. For example, a Button control becomes a ZButton control.


Figure 1- Example of Euclid Controls. From left to right: ZCheckbox, ZButton, ZSwitch and ZRadioButton

Euclid simplifies the process of adding 3D effects to your Android apps. Because most Euclid layout and widget classes are derived from either standard Android or Amazon Foundation Control classes, you are probably already familiar with the most common methods and attributes of Euclid controls and should be able to convert your app to use the new Dynamic Perspective UI with few code updates.

The following aspects of a control remain unchanged when you swap a stock Android control for its Euclid equivalent, such as changing a Button to a ZButton:

  • Click handler methods: User interaction is handled via your existing onClick() method or View.OnClickListener object.
  • Screen position methods: Layout in the X and Y planes follow the same rules as 2D widgets.
  • Layout methods: Euclid controls follow Android rules for scaling, sizing, and padding, and auto-resize based on layout parameters.
  • Support methods: Euclid controls often inherit Android widget support for testing, accessibility, and localization.

The biggest difference between Euclid and 2D widgets is how their visual assets are produced and rendered. These differences provide new behaviors but also set some limits on what you can change. Euclid widgets are artist-created textured mesh files, including collections of vertices, edges and faces that define the shape of 3D objects.

Although you can set the color of a 3D widget, you cannot add a border, set a custom background, or make changes in View.OnDraw(). However, 3D controls do provide the same access to behaviors such as animations and head tracking without additional code.

The following summary highlights the changes between 2D and 3D controls:

  • Layout parameters: 3D object layout parameters include depth in addition to height and width. While 2D Android layouts are a nested hierarchy of flat rectangles, 3D layouts are a nested hierarchy of rectangular boxes.
  • Delegate classes: All 3D methods are passed to delegate classes to handle 3D operations, such as layout and animation. You do not need to extend the delegate classes unless you want to modify the stock control animations or layout.
  • Missing or overridden class methods: Some 2D Android base class methods have been removed from the 3D controls because these methods are either not relevant to a 3D environment or have been replaced with true 3D paradigms. For example, stock Android controls support rotation using a faux 3D mode, whereas Euclid replaces these methods with a simplified 3D orientation method.
  • Draw method: Because they are not rendered dynamically, 3D controls do not directly use the Draw method. Instead, you must build a tree of transformations and execute a drawing command using ZSceneNode and ZRenderable. This retained approach better matches the model of the underlying 3D graphics library. Note that this change is transparent if you are using the stock 3D controls in the toolkit.
  • Unsupported base class attributes: Some 2D base class attributes are not supported in 3D, such as the Android faux shadow parameter. See the API reference documentation for information about specific control attributes.
  • 3D-specific methods and attributes: 3D controls have 3D-specific methods and attributes, such as the ability to supply layout attributes using orientation_Zin a linear layout or depthGravity.

For more information on implementing Euclid controls be sure to check out our Dynamic Perspective UI Migration Guide here. For suggestions on when to use the standard Android widgets, 2D controls and the new Euclid controls check out our comparison matrix here.

Tip 9 – Firefly SDK: Apps that Discover the World around You

With the Firefly SDK, developers can build apps that recognize real world objects - QR and bar codes, artwork, songs, movies and more - and let customers interact with them. Firefly combines Amazon's deep catalog of physical and digital content with multiple image, text and audio recognition technologies to quickly identify over 100 million movies, TV episodes, songs and products. It can also recognize URLs, email addresses and phone numbers. Customers simply press the Firefly button to discover helpful information and take action in seconds. You can use the Firefly SDK to supplement item identification or build actionable options for customers after an item is recognized. For example, iHeartRadio used the Firefly SDK’s built-in music recognizer and music database to identify a song playing. Then they built their own Firefly action to create a station based on the song Firefly recognized.

Integration with Firefly requires the creation of a plug in. You can get complete details on implementing a Firefly plugin on our developer portal here.

Tip 10 – New Developer Incentives for Fire Phone Apps

The immersive apps you create for Fire phone are also eligible for new developer promotions. We have updated Appstore Developer Select and Amazon Mobile Ads API with more incentives. 

  • Appstore Developer Select: Optimize your apps for Fire phone and get enhanced merchandising and 500,000 Amazon Coins incentives for your customers. Get the details here.
  • Amazon Mobile Ads API: Developers earn $6 for every thousand interstitial ads displayed across any supported device in August and September (up to one million impressions per app per month) when they distribute their apps on Fire phones and send the first ad request from a qualified app. Get the details here.

Now is the time to submit your apps and games! Apps that are submitted and approved by July 18 will be in the Amazon Appstore when Fire ships on July 25.

Be sure to check out these additional Fire phone developer resources:

-Dave (@TheDaveDev)


April 10, 2014

Jesse Freeman

Add Remote and Game Controller Support to Your Amazon Fire TV Game in ­10 Steps

One of the most exciting prospects of publishing your game on Amazon Fire TV is that you can run Android games directly on the TV. If you are already building games for Android, you can use the same codebase you currently have, and make that game playable on Amazon Fire TV.

One thing to consider is how to add support for user input from the newly announced Amazon Fire TV remote and Amazon Fire game controller. Luckily, basic controller support is already built into Android.  You can leverage the Android input device APIs and the game controller API from the Amazon Fire TV SDK to get your game ready to publish in no time. Here are the top ten things you should do in order to get your game ready for Amazon Fire TV customers.

1. Think Remote First

An Amazon Fire TV remote is included with every Amazon Fire TV. That means at the very least, your app should support simple four-way navigation and selection input from the remote itself. Let’s take a look at the button layout:

 As you can see above, the remote has a standard set of navigational buttons and a single selection button in the center. That is your player’s primary means of input.  The remote also has some additional proprietary buttons including home, back and menu buttons which respond exactly how you would expect them to on any Android device. I highly suggest referring to the Guidelines for Controller Behavior for our recommendations around supporting the Amazon Fire TV remote in your game.

Also consider that the Amazon Fire TV remote is the most common input device users of Fire TV use. By designing games that will take advantage of the remote, you increase your chances of appealing to a broader audience. While you can publish games that only use the Amazon Fire game controller to the store, keep in mind that not everyone has a game controller -- those games that leverage the remote input will have a broader audience appeal.

2. Navigating the UI with a Remote

Now that we have gone through basic remote input, let’s look at how to implement the user flow in your game’s navigation. When it comes to basic UI, I simply focus on supporting 6 core inputs you receive from the Amazon Fire TV remote:


Amazon Remote Button

Amazon Game Controller Button

Other Game Controller Button


Main Action

D-Pad Center



Select the item in focus, confirm menu options or prompts, or perform the main game action.






Cancel the current operation, or return to the previous screen.


Intercept this action to provide confirmation dialogs ("Are you sure you want to quit?")







Left Stick


Left Stick

Move the input focus in the appropriate direction.


On game controllers, the left stick should have the same behavior as the D-Pad.

It is critical that you design your UI with the remote in mind. This means putting the starting focus at the correct location in the UI. This is often the most likely object your users will interact with first. Let’s look at a simple weapons store screen in Super Resident Raver and see how the UI flow works with basic directional input events:


Here you can see the game places the player’s focus in the store area, at number one. From there, the player can move DOWN to buy something via the Buy button, or continue moving down to the Continue button to move to the next screen. When the player is inside the actual store area, they can move from item to item using the LEFT or RIGHT navigation buttons. If they move up from the top of the item area or down from the Continue button, the focus moves to the Quit Button and the entire UI makes a full circle.

Not only should it be clear where the player can navigate to, but the game should also make sure that UI flow never lets the player get stuck or makes the user keep back tracking to find the operations they want, or missed when moving around too quickly.

3. Capturing Remote Key Events

Android has built-in support for D-Pad key events. These function similarly on the Amazon Fire TV as they did in the past when Android phones had rocker D-Pads. Let’s walk through a quick example of how to actually implement this in your own game. Just like you would support this in any Android project, simply override the onKeyDown() method in your View and use a switch statement to test the key code value that gets passed in.

Here we have some basic logic that captures the main input events from the Amazon Fire TV remote.

public boolean onKeyDown(int keyCode, KeyEvent event){
    boolean handled = false;
    switch (keyCode){
        case KeyEvent.KEYCODE_DPAD_CENTER: case KeyEvent.KEYCODE_BUTTON_A:
                // ... handle selections
                handled = true;
        case KeyEvent.KEYCODE_DPAD_UP:
                // ... handle up action
                handled = true;
        case KeyEvent.KEYCODE_DPAD_RIGHT:
                // ... handle right action
                handled = true;
        case KeyEvent.KEYCODE_DPAD_DOWN:
                // ... handle down action
                handled = true;
        case KeyEvent.KEYCODE_DPAD_LEFT:
                // ... handle left action
                handled = true;
     return handled || super.onKeyDown(keyCode, event);

Now we have the building blocks for moving through our game’s UI, and we can also use this code for simple movement in a game. In addition, you can build upon this foundation by adding support for the Amazon Fire game controller.

4. Adding Controller Support

Amazon Fire TV supports up to seven Bluetooth gamepads at the same time. Here is the key layout for the optional Amazon Fire TV game controller.

Since controller support is built into Android, if you have previously worked with adding controllers to your Android game, working with Fire TV controllers will be very familiar. Leverage the default onKeyDown() method for the controller buttons just like we used for the remote, and use onGenericMotionEvent() for capturing the joystick’s movement events. This is a key concept to understand since it means if you build your game to support navigation or in-game control via the built-in KeyEvent handler, you won’t have much additional work to do in order to capture the analog movement events from the controller that are not part of the remote.

Let’s look at the two  methods in Android for handling the Amazon Fire game controller events. The first is exactly the same as what we use for the Amazon Fire TV remote support:

public boolean onKeyDown(int keyCode, KeyEvent event){
    boolean handled = false;
    switch (keyCode){
        case KeyEvent.KEYCODE_BUTTON_X:
                // ... handle x button 
                handled = true;
     return handled || super.onKeyDown(keyCode, event);

When it comes to dealing with movement input from the joystick, the second override we can make to capture those events are part of the View’s onGenericMotionEvent() method like this:

public boolean onGenericMotionEvent(MotionEvent event){
    // get changes in value from left joystick
    float deltaX = event.getAxisValue(MotionEvent.AXIS_X);
    float deltaY = event.getAxisValue(MotionEvent.AXIS_Y);
    return true || super.onGenericMotionEvent(event);

You can see the full list of controller input events here. As you may have noticed from the reference table, especially with the D-Pad controls, there are primary and secondary events. While the most granular way of getting analog movement input from a game controller is the MotionEvent, the secondary event is a useful fallback that allows you to support the Amazon Fire TV remote and Amazon game controller at the same time. Another example of this is the A button which has a secondary event of KEYCODE_DPAD_CENTER.

If your game only supports the D-Pad, take advantage of the onKeyDown() method and listen for the secondary event types while ignoring overriding onGenericMotionEvent(). Likewise you can simply listen to KEYCODE_DPAD_CENTER events ignore KEYCODE_BUTTON_A events for the controller’s A button. This ensures that your game works with the included Amazon Fire TV remote and also the optional Amazon Fire game controller. The only caveat is that if you listen to both primary and secondary events you may get multiple events saying the same thing so be prepared to handle that in your code.

5. Using the GameController API

Using the built-in event handlers is helpful for Android-based games that use of Views, some games may use a custom engine or need more direct access to the current input event on a frame by frame basis. The GameController API, part of the Amazon Fire TV’s SDK offers the following things:

  • Methods to associate game controllers with the player numbers as defined by the Amazon Fire TV.
  • Methods to query controller state at any time.
  • Input event constants specific to gamepads.
  • Behavior to enable you to process gamepad input events on a per-frame basis (that is, within a game loop).

To use the GameController API simply import the correct classes from the SDK:


From there you will have to initialize the GameController in your onCreate() method:

protected void onCreate(Bundle savedInstanceState) {
    //Initialize GameController with the context to attach to the game controller service

If you don’t initialize the GameController before accessing any of its APIs, it throws a NotInitializedException exception. Once you know it is properly initialized, you can begin using it. Here are some important APIs to get more granular data over each controller’s input state:

  • Getting GameController Objects by Player - simply use GameController.getControllerByPlayer() and supply the player number for access to that particular controller. There is a constant you can use to iterate through all the controllers called GameController.MAX_Players, which is capped at 4 by default.
  • Test for Key Down - Once your have the reference to the player’s controller you can call getKeyValue() on it and pass in a constant such as GameController.BUTTON_TRIGGER_LEFT to see if that key is pressed. It will return a true or false value.
  • Get Axis Value - Likewise you can also access the analogue stick by calling getAxisValue() on the reference to the player’s controller and supply a constant such as GameController.AXIS_STICK_LEFT_X to return a float value you can use to determine the direction it is being pushed in.
  • Testing Changes In Value - Finally you can test if a change has occurred since the last frame by calling getAxisValue() and supplying a constant such as GameController.AXIS_STICK_LEFT_Y. This will return a Boolean to help you decide if you need to apply a new change in the game.

While the above code is simply here to illustrate how this works, I suggest going through the GameController API documentation to see more sample code that you can use in your own game. Also, make sure you check out the GameController Event Constants as well.

6. Supporting Multiple Controllers

Now that we have covered the basics of the GameController API, let’s talk about multi-player games on the Amazon Fire TV. While you can connect up to seven Bluetooth game controllers to the Amazon Fire TV, only four of those controllers are assigned to player numbers in the GameController API. Getting the player’s number from the API is an easy way to manage your game’s players. You can use this by calling GameController.getPlayerNumber() and supply an Android Device ID to get the player number for that device. Likewise, there is a helper method to get you the Android Device ID if you call GameController.getDeviceID() and pass in a player number. You can iterate through all the devices by using the GameController.MAX_PLAYERS constant.

If your game supports more than four players, you can manage controllers and player numbers manually. For most games though, four is a great experience for local multi-player and you will find that the Amazon Fire TV is more than capable of keeping up with the action. While you can also do remote multi-player via standard networking APIs, keep in mind that you will have to manage that system separately from the game running on the Amazon Fire TV.

7. Handling Interruptions In Your Game

Your game should be prepared to handle interruptions. At the very least, make sure you support Android’s native onPause() and onResume() methods in your View. This is critical when the following events or situations happen:

·         Remote or Controller Drops - if you lose the connection to the main input of the device, possibly due to a battery or connection issue, you want to make sure your game is able to pause itself immediately. You should also build in some simple way to test that the controller is still active. This is critical in multi-player games; if one player drops you need to immediately pause the game.

·         User Presses the Home Button - if the user presses the home button on the controller, no event is raised, but onPause() is called. Your game exits back to the home screen.

·         User Performs a Search - once the user tries to perform a search, the event cannot be intercepted and onPause() will be called in your View.

·         User Presses the GameCircle Button - this immediately takes the user to the GameCircle dashboard while in your game.

It’s also important to capture ‘back’ events and handle exiting the game from a ‘back’ button properly. If you are on the home screen of your game and you receive a back button event, your game should prompt the user if they actually want to quit.

8. Building Controller Friendly UI

Each interactive UI element should have the following states:

  •           Enabled
  •           Disabled
  •           Highlighted
  •           Selected

These states are critical to helping your player understand where they currently are in the UI and also what action they can do. Sometimes you may need to have multiple states such as Disabled Selected in the case of the Resident Raver store scenario where it’s possible to select an item that can’t be purchased just to see what the price is.

On the same topic, it’s also important to take the Highlight state of the other UI elements into consideration. Here is a screenshot with the main UIs Selected states visible.  The selected state moves as the player moves around from main UI element to main UI element.

Finally, no matter what you end up designing, make sure there is consistency in each button state so that the player can intuitively understand where they are on the screen and what they need to do next.

9. Handling Joystick Dead Zone

Like all controllers, the joystick needs to be properly calibrated. Many things can happen that may mess-up the alignment of the joystick. At the very least, you need to account for adding a joystick dead zone to ignore joystick movements that are not large enough to cause an actual require a movement event to be recognized. Here is an example of how you can calculate this by using the GameController API.

gameController = GameController.getControllerByPlayer(1)
float x = gameController.getAxisValue(GameController.AXIS_STICK_LEFT_X);
float y = gameController.getAxisValue(GameController.AXIS_STICK_LEFT_Y);
float value = (float) Math.sqrt(x * x + y * y);

Here the formula returns a value between 0 and 1. You can choose how aggressively you want to ignore controller drift. A good place to start is somewhere above 0.25f - 0.35f. Test that the value is greater than your allowed dead zone value before applying the movement. In addition to this, I also suggest allowing the user to recalibrate their joystick in the options menu. Nothing is more frustrating than an unresponsive or “sticky” joystick control in a game.

10. Clearly Display What the Controls Are

Before any of my games start, I always show a screen with the game’s controls. While most people skip right over this, there will be a few who stop to read it in order to figure out what they will need to do in the actual game.

This also means making sure you remove any reference to touch controls, especially if you ported the game over from mobile. Also make sure you remove on screen pause buttons and sound buttons. Sound in your game should be managed via the TV’s remote. The only exception is if you have two separate user configurable volumes for the sounds effects and music which I would still keep in as long as it can be modified via the remote or controller directly.

Wrapping Up

There is a lot to consider as you begin to add support for the Amazon Fire TV remote and Amazon Fire game controllers to your game. It helps to take a step back and map out how this should all work. Having poor controls in your game will not go over well with your players, so nailing tight, responsive, and intuitive controls is critical to launching a successful game on the Amazon Fire TV. Also,look to other similar TV based gaming experiences for inspiration on how your UI and game controls should work.

For More Information

Amazon Fire TV Remote Input: Learn how to handle input from the Amazon Fire TV remote.

Amazon Fire Game Controller Input: Learn how to handle input from game controllers (both the Amazon Fire game controller and other game controllers).

GameController API: The Fire TV SDK includes a utility API for games to help you manage game controller input. This API includes the ability to associate player numbers with controllers and to manage input events on a frame-based basis.

Identifying Controllers: Users may pair up to seven Bluetooth controllers to the device at a time. Learn how to identify different controllers paired with the system and interpret input from those controllers.

Controller Behavior Guidelines: For consistency with the Fire TV user interface and across different apps we suggest you implement the guidelines in this document for controller behavior.

Controller Image Assets: If your app or game provides instructions or help screens for how to use a controller, you may freely use the controller images and button hints on this page in your app.


- Jesse Freeman (@jessefreeman)