DEV Community: Olivia Sung

Hello World for Fire TV with Kotlin & Jetpack Compose

Olivia Sung — Fri, 17 Jan 2025 17:42:19 +0000

With the release of Jetpack Compose for TV that came out during summer of 2024, Compose for TV introduces TV material components that are designed for the living room, with clear focus indicators and remote-friendly input behavior. Now there is a specific dependency for TV androidx.tv:tv-material instead of using the mobile one such as androidx.compose.material3:material3.

In this tutorial, I will be following closely on a ‘📺 🔥 Hello World Fire TV App’ sample recently published on GitHub. I will be highlight some cool features that are used in this sample so that you don’t have to read through the code base! Once again for this tutorial, we will be using Google Jetpack Compose to design and implement tv navigation drawer.

Prerequisite

You can use an existing Fire TV or an Android TV virtual device.

Light/Dark Mode

Switching from light and dark mode depending on the device’s system theme is an industry standard nowadays.
We can use the isSystemInDarkTheme to check if the device system is in light or dark mode to help build responsive UIs that follow the system setting.

In Theme.kt, you can find below code snippet:

@Composable
fun HelloWorldTVTheme(
    isInDarkTheme: Boolean = isSystemInDarkTheme(),
    content: @Composable () -> Unit,
) {
    val colorScheme = if (isInDarkTheme) {
        darkColorScheme(
            primary = Purple80,
            secondary = PurpleGrey80,
            tertiary = Pink80
        )
    } else {
        lightColorScheme(
            primary = Purple40,
            secondary = PurpleGrey40,
            tertiary = Pink40
        )
    }
    MaterialTheme(
        colorScheme = colorScheme,
        typography = Typography,
        content = content
    )
}

Navigation Drawer

Navigation drawers are essential components in any TV app as they allow users to access different destinations and features. In our sample, we are using [ModalNavigationDrawer](https://developer.android.com/reference/kotlin/androidx/tv/material3/package-summary#ModalNavigationDrawer(kotlin.Function2,androidx.compose.ui.Modifier,androidx.tv.material3.DrawerState,androidx.compose.ui.graphics.Brush,kotlin.Function0)) as they are good for infrequent, but more focused, switching to different destinations. In HomeDrawer.kt, we are defining navigation drawer although we have not set any specific destinations.

ModalNavigationDrawer(
        drawerState = drawerState, drawerContent = { drawer ->
            Column(
                Modifier
                    .background(MaterialTheme.colorScheme.surface)
                    .fillMaxHeight()
                    .padding(12.dp)
                    .selectableGroup(),
                horizontalAlignment = Alignment.Start,
                verticalArrangement = Arrangement.spacedBy(
                    8.dp, alignment = Alignment.CenterVertically
                ),
            ) {
                Spacer(modifier = Modifier.height(8.dp))

                menuItems.forEachIndexed { _, item ->
                    NavigationRow(item = item,
                        isSelected = selectedId == menuItems.indexOf(item),
                        onMenuSelected = {
                            drawerState.setValue(DrawerValue.Closed)
                            onMenuSelected?.invoke(item)
                        })
                }
                Spacer(modifier = Modifier.weight(1f))
            }
        }, scrimBrush = Brush.horizontalGradient(
            listOf(
                MaterialTheme.colorScheme.surface, Color.Transparent
            )
        )
    )

Scrollable grid of cards

As this sample on GitHub is showcasing a catalog, we need a grid of cards where each card can represent a media of some sort. If it’s a media streaming app, you can imagine what these cards will be filled with, TV shows, movies, etc you name it! We are using [LazyVerticalGrid](https://developer.android.com/develop/ui/compose/lists#lazy-grids) which will provide support for displaying items in a grid. As we want something scrollable with a remote, vertical grid will display items in vertically scrollable container so users can scroll up and down!
For this sample, we want 5 columns so we will declare GridCells.Fixed(5).

LazyVerticalGrid(
                columns = GridCells.Fixed(5),
                contentPadding = PaddingValues(
                    start = 24.dp,
                    top = 24.dp,
                    end = 24.dp,
                    bottom = 48.dp
                ),
            )

In the end, when you run the sample app, you will have a scrollable TV app with grid of cards!

Conclusion

Today we went over some quick pointers on the Hello World Fire TV sample on GitHub which includes features such as different light/dark mode, navigation drawer and scrollable vertical grid to look similar to an streaming app on TV.

Stay connected

Stay up to date with Amazon Appstore developer updates on the following platforms:
📣 Follow @AmazonAppDev on Twitter
📺 Subscribe to our Youtube channel
📧 Sign up for the Developer Newsletter

Porting Your Android App from Google Play Billing to Amazon (While Enjoying Pizza)

Olivia Sung — Thu, 25 Jul 2024 17:20:39 +0000

If you have an existing Android App that uses the Google Play Billing Library for in-app purchases (IAP) and subscriptions, you can use the Appstore Billing Compatibility (ABC) SDK to port it to the Amazon Appstore. Porting your app to the Amazon Appstore offers you a great opportunity to connect with engaged customers around the world — to date, there have been more than 200 million Fire TV devices sold globally.

Similar to the Google Play Billing Library versions 4.0 and 5.0, the Amazon Appstore Billing Compatibility SDK supports consumable, entitlement, and subscription IAPs. In this article, we'll walk through the step-by-step instructions to integrate the Appstore Billing Compatibility SDK into your app. I will use our Hello Pizza ordering app for the purposes of this article (because ordering and eating pizza is one of my favorite things to do when I'm not building apps).

Let’s dive in and get started. I’ve already built a Hello Pizza app that uses the Google Play Billing Library. Before porting the app to the Amazon Appstore, let’s go through a checklist of the items we need.

Checklist — what you’ll need to get started to port your Android app to the Amazon Appstore

Getting started is simple. Below are the three things you’ll need to port your app to the Amazon Appstore:

An Android app that uses versions 4.0 or 5.0 of the Google Play Billing Library.
An Amazon Developer Console Account (If you don’t have one, you can get it here.)

The Amazon Appstore Billing Compatibility SDK (you can download the latest version here — extract the zip file and copy the jar file).

Step 1: Integrate the Amazon Appstore SDK 📥

The Amazon Appstore Billing Compatibility SDK is available through Maven Central. Make sure your project's top-level build.gradle has the Maven Central repository defined (now added by default by Android Studio), or add it otherwise:

allprojects {
 repositories {
    mavenCentral()
}

Then add the dependency of the Amazon Appstore Billing Compatibility SDK in your app build.gradle

dependencies {
   implementation 'com.amazon.device:appstore-billing-compatibility:4.2.0'
}

Now, sync your project to resolve the dependency.

Step 2: Configure Your App 🔧

It’s time to configure your app!

A. To get started, log in to the Amazon Developer Console and navigate to your app's page.

B. Generate a public key for your app and download the AppstoreAuthenticationKey.pem file. You can find more information here.

C. Next, copy the PEM file to your app's src/main/assets folder.

D. Update your AndroidManifest.xml file to include the BillingResponseReceiver. Remember, if your app targets Android 12 or higher, you must explicitly set android:exported to true in the MainActivity and ResponseReceiver.

<activity
    android:name=".MainActivity"
    android:exported="true"
    android:theme="@style/Theme.HelloPizza">
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />

        <category android:name="android.intent.category.LAUNCHER" />
    </intent-filter>
</activity>

<receiver
    android:name="com.amazon.device.iap.billingclient.api.BillingResponseReceiver"
    android:exported="true"
    android:permission="com.amazon.inapp.purchasing.Permission.NOTIFY">
    <intent-filter>
        <action android:name="com.amazon.inapp.purchasing.NOTIFY" />
    </intent-filter>
</receiver>

E. Update your app's import statements to use the Appstore Billing Compatibility SDK classes. Replace com.android.billingclient.api with the com.amazon.device.iap.billingclient.api).

F. Add your app IAP items to the Amazon Appstore Developer Console following the instructions here. This will allow you to do important things like charge for your pizza, and also the noble things like offer your pizza at a discount.

Step 3: Initialize the BillingClient 🚀

Now that you’ve configured your app, it’s time to initialize a BillingClient instance in your app. This is similar to how you would initialize a billing instance with Google Play Billing. The syntax to initalize the billing clients is the same with the two SDKs.

In Google Play Billing:

private val billingClient = BillingClient.newBuilder(application)
    .setListener(this)
    .enablePendingPurchases()
    .build()

For the ABC SDK:

private val billingClient = BillingClient.newBuilder(application)
    .setListener(this)
    .enablePendingPurchases()
    .build()

Step 4: Connect to the Amazon Appstore 🔗

Unlike Google Play Billing, the Amazon Appstore doesn't require you to maintain a connection. All you have to do is call startConnection() on your BillingClient instance:

In Google Play Billing:

class GoogleIAPDataSource : BillingClientStateListener {
...
    init {
        billingClient.startConnection(this)
    }
...
    override fun onBillingSetupFinished(billingResult: BillingResult) {
        when (billingResult.responseCode) {
            BillingClient.BillingResponseCode.OK -> {
                reconnectMilliseconds = RECONNECT_TIMER_START_MS
                defaultScope.launch {
                    querySkuDetailsAsync()
                    refreshPurchasesAsync()
                }
            }

            else -> {
                onBillingServiceDisconnected()
            }
        }
    }    

    override fun onBillingServiceDisconnected() {
        reconnectMilliseconds = (reconnectMilliseconds * 2).coerceAtMost(RECONNECT_TIMER_MAX_MS)
        billingClient.startConnection(this)
    }
}

In ABC SDK:

override fun onBillingSetupFinished(billingResult: BillingResult) {
    when (billingResult.responseCode) {
        BillingClient.BillingResponseCode.OK -> {
            reconnectMilliseconds = RECONNECT_TIMER_START_MS
            defaultScope.launch {
                querySkuDetailsAsync()
                refreshPurchasesAsync()
            }
        }

        else -> {
            onBillingServiceDisconnected()
        }
    }
}


override fun onBillingServiceDisconnected() {
    reconnectMilliseconds = (reconnectMilliseconds * 2).coerceAtMost(RECONNECT_TIMER_MAX_MS)
    billingClient.startConnection(this)
}

Step 5: Query Product Details 🔍

To retrieve the details for your product, you can use either the queryProductDetailsAsync() or querySkuDetailsAsync() method. The syntax is the same between ABC and Google Play Billing.

val inAppSkuDetailsParams = SkuDetailsParams.newBuilder()
    .setType(BillingClient.SkuType.INAPP)
    .setSkusList(knownInAppSKUs)
    .build()
billingClient.querySkuDetailsAsync(inAppSkuDetailsParams) { result, details ->
    onSkuDetailsResponse(result, details)
}

Step 6: Launch the Purchase Flow 🚀

To start a purchase, simply call the launchBillingFlow() method with a BillingFlowParams object containing the product details. The syntax is the same between ABC and Google Play Billing.

val billingFlowParams = BillingFlowParams.newBuilder()
    .setSkuDetails(skuDetails)
    .build()
val billingResult = billingClient.launchBillingFlow(activity!!, billingFlowParams)

Note: The Appstore Billing Compatibility SDK allows only one product per purchase.

Step 7: Process Purchases 💰

After a successful purchase, process it in your PurchasesUpdatedListener's onPurchasesUpdated() method.

 override fun onPurchasesUpdated(billingResult: BillingResult, purchases: List<Purchase>?) {
    when (billingResult.responseCode) {
        BillingClient.BillingResponseCode.OK -> purchases?.let { processPurchaseList(it, null) }
        else -> {}
    }
    defaultScope.launch {
        _billingFlowInProcess.emit(false)
}

For consumables, call consumeAsync() to acknowledge delivery and mark the item as consumed.

billingClient.consumeAsync(consumeParams) { billingResult, _ ->
    purchaseConsumptionInProcess.remove(purchase)
    if (billingResult.responseCode == BillingClient.BillingResponseCode.OK) {
        defaultScope.launch {
            _purchaseConsumedFlow.emit(purchase.skus)
        }
        purchase.skus.forEach { sku ->
            setSkuState(sku, SkuState.UNPURCHASED)
        }
    }
}

For entitlements, use acknowledgePurchase() to acknowledge delivery.

Step 8: Fetch Purchases 🛒

To retrieve a user's purchases, call queryPurchasesAsync().

billingClient.queryPurchasesAsync(BillingClient.SkuType.INAPP) { billingResult, purchases ->
    if (billingResult.responseCode == BillingClient.BillingResponseCode.OK) {
        processPurchaseList(purchases, knownInAppSKUs)
    }
}

billingClient.queryPurchasesAsync(BillingClient.SkuType.SUBS) { billingResult, purchases ->
    if (billingResult.responseCode == BillingClient.BillingResponseCode.OK) {
        processPurchaseList(purchases, listOf(knownSubscriptionSKUs))
    }
}

Step 9: Test Your App 🧪

To test your app's integration with the Appstore Billing Compatibility SDK, you can use the Live App Testing to test your app in a live production environment with a select group of users. To set up Live App Testing for your app follow the steps here.

Discount	Subscription	Entitlement

Important notes

It’s easy to forget to place the file AppstoreAuthenticationKey.pem in the correct directory You should double check you performed all the steps in the Configure Your App 🔧 section above.
Check that the SKUs used in your app are the same that you defined in the Amazon Appstore Console (See the official guide)

Conclusion 🎉

If you’ve followed the steps above carefully, your app should be compatible with In-app purchasing on the Amazon Appstore. Here’s more resources to help ensure that you are getting the most bang for your buck from your development efforts on the Amazon Appstore. I hope you enjoyed this article. As for me, writing this demo has made me hungry. I’m now going to power off for the evening and get some pizza.

Stay updated

For the latest Amazon Appstore developer news, product releases, tutorials, and more:
📣 Follow @AmazonAppDev and our team on Twitter
📺 Subscribe to our YouTube channel
📧 Sign up for the Developer Newsletter

Related resources

Build your first app for the Amazon Appstore with three simple (and very cute) pointers

Olivia Sung — Mon, 06 May 2024 23:02:42 +0000

By building an app for Fire tablets, you can connect with customers around the world, and grow your revenue . This article explains how you can build your first app for that can run seamlessly across the entire Fire tablet family of devices. The tutorial below draws on a ‘Hello World’ sample that I recently published on GitHub. I have picked out code snippets from the sample to save you time if you don’t want to read through the entire code base!

Because Fire Tablets are so popular, Amazon has made them available in a wide variety of form factors. This makes device orientation an important factor for Fire tablet app developers to fully utilize the available screen space. For this tutorial, we will use Google Jetpack Compose to design and implement layouts that adjust themselves to render content differently across a variety of sizes.

The example below features a single code base that can be used on Android and the Amazon Appstore. A bonus: the example also features one of my two awesome pugs Katsu (wearing a red harness in the picture below!)

Prerequisite

To get the most out of this tutorial, check to see if you have a Fire TV tablet, and two photos of your pet. If you don’t have a tablet, you can use the Android tablet emulator. 🐱🐶 Needless to say, if you don’t have a pet, any photo will do.

Without further ado, let’s get started with the three simple pointers needed to build your Amazon Appstore app.

Check for Google Play Service

In MainActivity.kt file, there is a check if the app is using Google Play Service. This is one of the two checks to verify whether the app supports Google Play Service and/or Amazon Appstore.

By using GoogleApiAvailability class, we create a new private function called isGooglePlayServicesAvailable to verify if Google Play Services are available.

private fun isGooglePlayServicesAvailable(): Boolean {
    val googleApiAvailability: GoogleApiAvailability = GoogleApiAvailability.getInstance()
    val status: Int = googleApiAvailability.isGooglePlayServicesAvailable(this @MainActivity)
    return status == ConnectionResult.SUCCESS
}

Check for Amazon Appstore

We also implemented a check to verify if the app is installed from Amazon Appstore.
If the installer package name is equal to com.amazon.veneziathen it is indeed installed from Amazon Appstore! Just like we did with Google Play Service, let’s create a private function called isInstalledFrom AmazonAppstore.

private fun isInstalledFromAmazonAppstore(): Boolean {
    val installerPackageName = getInstallerPackageName()
    return installerPackageName == getString(R.string.amazon_appstore_identifier)
}

Display your pet photos

Now for the fun part! You might be wondering where what the purpose of your optional pet photos were. Now is the time 🐶
To sprinkle some fuzziness into this app, we will be using two different photos.

Use one of your photo to display if the Google Play Service is available
Use provided Appstore logo to display if the app is installed from Amazon Appstore
Use your second photo to display if it doesn’t fall into either of the above cases

Drop your photos into app/src/main/res/drawable folder. Refer to this doc for supported file types. Add the code snippet below back in the MainActivity.kt file.

@Composable
fun IdentifierImage(
    isGooglePlayServicesAvailable: Boolean,
    installedFromAmazonAppstore: Boolean,
    modifier: Modifier
) {


    if (isGooglePlayServicesAvailable) {
        Image(
            painter = painterResource(id = R.drawable.younger_katsu_in_chair),
            contentDescription = stringResource(id = R.string.android_content_description),
            modifier = modifier
        )
    } else {
        if (installedFromAmazonAppstore) {
            Image(
                painter = painterResource(id = R.drawable.appstore_logo),
                contentDescription = stringResource(id = R.string.fos_content_description),
                modifier = modifier
            )
        } else {
            Image(
                painter = painterResource(id = R.drawable.older_katsu_in_chair),
                contentDescription = stringResource(id = R.string.other_content_description),
                modifier = modifier
            )
        }
    }
}

Determine device orientation

The fun doesn’t end there. Remember how I mentioned about the importance of tablet orientation earlier? This section talks through also code snippet to add a text that will have a different string depending on the window width (landscape vs portrait.)

In order to determine the device orientation, we will be utilizing calculateWindowSizeClass, if it returns WindowWidthSizeClass of Expanded, we know that the device is in landscape mode and can adjust the position of the image and text accordingly.

val isExpandedScreen =
    calculateWindowSizeClass(this).widthSizeClass == WindowWidthSizeClass.Expanded

With isExpandedScreen , we can place the text accordingly!
If WindowWidthSizeClass is not expanded, meaning it would represent majority of tablets in portrait , we will place the image at the top and text at the bottom. If it’s expanded, we will place the image on the left with text on the right!

HelloWorldFireTabletTheme {
    Surface(
        modifier = Modifier.fillMaxSize(), color = MaterialTheme.colorScheme.background
    ) {
        Box(
            modifier = Modifier.fillMaxSize()
        ) {
            IdentifierImage(
                isGooglePlayServicesAvailable(),
                isInstalledFromAmazonAppstore(),
                Modifier.align(
                    if (isExpandedScreen) {
                        Alignment.CenterStart
                    } else {
                        Alignment.TopStart
                    })
            )
            Text(
                style = MaterialTheme.typography.headlineLarge,
                text = textToShow,
                modifier = Modifier
                .align(
                    if (isExpandedScreen) {
                        Alignment.CenterEnd
                    } else {
                        Alignment.BottomCenter
                    }
                )
                .padding(30. dp)
            )
        }
    }

Test it out!

Build and run your app either on emulator or on your own Fire tablet. Make sure to have your device setting so that it auto-rotates! Below is an example of toggling on the Auto-rotate from the drop down menu.

Now try rotating the tablet to see the sample in action!

Conclusion

Today, we went over how to check whether Google Play Service is available and/or if the app was installed from the Amazon Appstore. We also displayed photos to indicate the status for the above in the app. In addition, we also added text to determine the device orientation for the tablet.

Stay tuned for the second tutorial for building a Fire TV app with my second pug, TOMO! 😈 In the interim, you can check out these tutorials for building next-level Fire TV tablets, and growing your business on the Amazon Appstore.

Stay connected

Stay up to date with Amazon Appstore developer updates on the following platforms:

📣 Follow @AmazonAppDev on Twitter
📺 Subscribe to our Youtube channel
📧 Sign up for the Developer Newsletter

Recap of Publishing on the Amazon Appstore Interview

Olivia Sung — Tue, 02 Apr 2024 23:47:42 +0000

Hey everyone! 👋 It’s Olivia from the Amazon Appstore Developer Advocate team.

Back in January, I was interviewed by Chris Melissinos, Principal Evangelist for AWS for Games. Chris has an awesome playlist on the AWS for Games YouTube channel called ‘Partner Profiles’ where he interviews folks from around the gaming industry. I was the first one from another Amazon team to be interviewed, which was a huge honor.

If you’re new to developing on the Amazon Appstore, this is a perfect starter for you. It’s in-depth, but the video has chapters so you can jump to whatever topic you’re interested in.

I recommend checking out the Developer benefits and opportunities especially, which is aimed at Android developers who already have apps published in Google Play Store. Porting your app is a great way to gain a new audience and potential revenue source. We also cover requirements, available SDKs, much more.

Also check out the Revenue opportunities, where we discuss the Small Business Accelerator Program, a way for smaller developers to access additional benefits worth up to 20% additional revenue! This includes 10% increased royalty payments and AWS credits equivalent to 10% of your app revenue! And check out my blog about 4 ways to use AWS for your mobile app, to learn how to use those AWS credits.

So what are you waiting for? Get started with the Amazon Appstore!✌️

📺 YouTube link for interview

4 ways to use AWS for your mobile app

Olivia Sung — Tue, 09 Jan 2024 22:34:34 +0000

If you’ve launched websites or backend services before, you’ve likely used AWS or another hosting provider for your infrastructure. In this article, we’ll discuss four developer use cases for AWS tools specific to building and improving mobile applications in addition to speeding up overall development time.

1. Create new mobile app prototypes in minutes

Are you planning to launch a new mobile app and want to spin up a prototype in minutes? AWS Amplify is a JavaScript library accompanied by a set of tools and services to help you build and deploy serverless applications in the cloud with AWS. It’s a full-stack application platform that utilizes code from both the client and server sides and can be used for several common applications requirements:

Create a unified backend: Create a unified backend for your apps to support iOS, Android, Flutter, web, and React Native. Once Amplify is configured, your project will possess both real-time and offline functionality.
Build rich user interfaces: Use Amplify Studio to build rich user interfaces with React Components connected to your cloud backend. Convert designs from Figma into reusable code components, saving the need to write thousands of lines of code.
Fully managed hosting: Amplify Hosting offers a fully managed hosting services with built-in CI/CD pipelines. In addition, Amplify allows direct deployment to CloudFront, an AWS Content Delivery Network (CDN), allowing you to leverage it’s points of presence (PoP) to quickly reach your customers. Learn how you can let Amplify worry about your app backend infrastructure so that you can focus on application coding. Check out the docs to get started.

2. Streamline device testing with AWS Device Farm

AWS Device Farm operates as an application testing service that facilitates testing your mobile apps across a broad range of Android and iOS devices. This helps save time and resources during quality assurance checks by allowing you to:

Run concurrent tests across devices
Test multiple OS versions for each device *Upload your own test suite or utilize pre-built tests
Review the logs and reports available for each device after testing Enhance your device testing with AWS Device Farm and receive your first 1,000 device minutes free with AWS Free Tier. The interactive device list includes view filters and additional information.

3. Engage customers effectively with Amazon Pinpoint

Seamlessly deliver communications across channels, segments, and campaigns at scale with with AWS Pinpoint.

Communication channels

Pinpoint offers a multichannel messaging platform to engage with your customers through email, voice, push notification, and SMS. You can create multi-step campaigns for defined user journeys in the drag-and-drop editor.

Analytics

Understanding how customers use your app is crucial to improving customer engagement. Pinpoint collects usage metrics and attributes to identify trends in customer interactions with your app. Streamline your communications today. Check out the docs to get started.

4. Optimize game servers with Amazon GameLift

Amazon GameLift offers a streamlined approach to deploying, operating, and scaling dedicated game servers for session-based multiplayer games. This allows for:

Simplified server management: GameLift takes away the complexities of server infrastructure management, allowing developers to focus on game development.
Cost-effective scaling: The service dynamically scales capacity and optimizes resource utilization.
Enhanced security: GameLift provides robust protection against DDoS attacks for a secure gaming experience.
Efficient player matchmaking: Amazon GameLift FlexMatch enables developers to implement real-time player matchmaking with ease. By allowing the creation of custom rule sets to define multiplayer functionality, it ensures compatible players are matched seamlessly.

Cross-platform

Today, games are becoming increasingly cross-platform to provide users seamless experiences. Typically these platforms include mobile, PC, and console so that users can hop from one platform to another to continue playing. If you have considered making your mobile game work across platforms, AWS has new guidance for building scalable cross-platform backends on AWS.

Read the latest blog post on the updates in addition to the sample code on GitHub. The article covers how to use the framework to simplify getting started with AWS and backend game development with support for popular game engines such as Unreal, Unity, and Godot 4.

Conclusion

Building mobile apps and games requires strategic planning to ensure that backend services run smoothly and deliver an exceptional gameplay experience as new users join. The AWS services mentioned above will help save time and effort spent on infrastructure, allowing you to focus on enhancing your apps and games.

Just getting started with the Amazon Appstore? You are eligible for additional benefits including 80/20 revenue share and AWS promotional credits! Learn more about our Small Business Accelerator Program.

Related resources

Stay connected
Stay up to date with Amazon Appstore developer updates on the following platforms:

📣 Follow @AmazonAppDev on Twitter
📺 Subscribe to our Youtube channel
📧 Sign up for the Developer Newsletter