Build a Fire TV app in under an hour with AWS Amplify

~/project$ $ npm create amplify@latest
Need to install the following packages:
create-amplify@1.2.0
Ok to proceed? (y) y


> npx
> create-amplify

✔ Where should we create your project? .
Installing devDependencies:
- @aws-amplify/backend
- @aws-amplify/backend-cli
- aws-cdk-lib@2.189.1
...
Welcome to AWS Amplify!
- Get started by running npx ampx sandbox.
- Run npx ampx help for a list of available commands.

$ npx ampx sandbox --profile amplify-app-developer
The region us-east-1 has not been bootstrapped. Sign in to the AWS console as a Root user or Admin to complete the bootstrap process, then restart the sandbox.
If this is not the region you are expecting to bootstrap, check for any AWS environment variables that may be set in your shell or use --profile <profile-name> to specify a profile with the correct region.

$ npx ampx sandbox --profile amplify-app-developer

  Amplify Sandbox
  
  Identifier: 	firedev
  Stack: 	amplify-project-firedev-sandbox-c212f661f8
  Region: 	us-east-1
  
  To specify a different sandbox identifier, use --identifier

WARNING: Schema is using an @auth directive with deprecated provider 'iam'. Replace 'iam' provider with 'identityPool' provider.

✔ Backend synthesized in 1.47 seconds
✔ Type checks completed in 3.38 seconds
✔ Built and published assets
✔ Deployment completed in 210.98 seconds
AppSync API endpoint = https://hw734z3v7bhknhxjpvxf4xrnvu.appsync-api.us-east-1.amazonaws.com/graphql
[Sandbox] Watching for file changes...

plugins {
    alias(libs.plugins.android.application)
    alias(libs.plugins.kotlin.android)
}

android {
    namespace = "com.example.amplifyfiretv"
    compileSdk = 35

    defaultConfig {
        applicationId = "com.example.amplifyfiretv"
        minSdk = 29
        targetSdk = 35
        versionCode = 1
        versionName = "1.0"

        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
    }

    buildTypes {
        release {
            isMinifyEnabled = false
            proguardFiles(
                getDefaultProguardFile("proguard-android-optimize.txt"),
                "proguard-rules.pro"
            )
        }
    }
    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_11
        targetCompatibility = JavaVersion.VERSION_11
    }
    kotlinOptions {
        jvmTarget = "11"
    }

    lint {
        abortOnError = false
        checkReleaseBuilds = false
    }
}

dependencies {
    implementation(libs.androidx.core.ktx)
    implementation(libs.androidx.appcompat)
    implementation("androidx.leanback:leanback:1.0.0")
    implementation("com.github.bumptech.glide:glide:4.12.0")
    implementation(libs.androidx.lifecycle.runtime.ktx)
    
    // Testing dependencies
    testImplementation("junit:junit:4.13.2")
    androidTestImplementation("androidx.test.ext:junit:1.1.5")
    androidTestImplementation("androidx.test.espresso:espresso-core:3.5.1")

package com.example.amplifyfiretv

import android.os.Bundle
import android.view.ViewGroup
import android.widget.TextView
import androidx.fragment.app.FragmentActivity
import androidx.leanback.app.BrowseSupportFragment
import androidx.leanback.widget.*

class MainActivity : FragmentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        if (savedInstanceState == null) {
            supportFragmentManager.beginTransaction()
                .replace(R.id.main_browse_fragment, MainFragment())
                .commit()
        }
    }
}

class MainFragment : BrowseSupportFragment() {
    override fun onActivityCreated(savedInstanceState: Bundle?) {
        super.onActivityCreated(savedInstanceState)
        setupUIElements()
        loadContent()
    }

    private fun setupUIElements() {
        title = "Amplify Fire TV"
        headersState = HEADERS_DISABLED
    }

    private fun loadContent() {
        val textView = TextView(requireContext()).apply {
            layoutParams = ViewGroup.LayoutParams(
                ViewGroup.LayoutParams.WRAP_CONTENT,
                ViewGroup.LayoutParams.WRAP_CONTENT
            )
            text = "Hello Android"
            textSize = 24f
        }

        val container = requireActivity().findViewById<ViewGroup>(R.id.main_browse_fragment)
        container.addView(textView)
    }
}

package com.example.amplifyfiretv.data

import android.content.Context
import android.util.Log
import com.google.gson.Gson

data class CardData(
  val title: String,
  val subtitle: String,
  val imageUrl: String,
  val videoUrl: String
)

data class CardDataResponse(
  val cards: List<CardData>
)

object CardDataProvider {
  private const val TAG = "CardDataProvider"
  private var cards: List<CardData> = emptyList()

  fun initialize(context: Context) {
    try {
      val jsonString = context
                         .assets
                         .open("cards.json")
                         .bufferedReader()
                         .use { it.readText() }
      val response = Gson()
                     .fromJson(jsonString, CardDataResponse::class.java)
      cards = response.cards
    } catch (e: Exception) {
      cards = emptyList()
    }
  }

  fun getCards(): List<CardData> {
    return cards
  }
} 

implementation("com.amplifyframework:aws-api:2.24.0")
implementation("com.amplifyframework:aws-datastore:2.24.0")
implementation("com.amplifyframework:aws-storage-s3:2.24.0")
implementation("com.amplifyframework:aws-auth-cognito:2.24.0")

package com.example.amplifyfiretv

import android.app.Application
import android.util.Log
import com.amplifyframework.AmplifyException
import com.amplifyframework.api.aws.AWSApiPlugin
import com.amplifyframework.auth.cognito.AWSCognitoAuthPlugin
import com.amplifyframework.core.Amplify
import com.amplifyframework.datastore.AWSDataStorePlugin
import com.amplifyframework.storage.s3.AWSS3StoragePlugin
import com.example.amplifyfiretv.data.CardDataProvider

class AmplifyApp : Application() {
    companion object {
        private const val TAG = "AmplifyApp"
    }

    override fun onCreate() {
        super.onCreate()
        
        CardDataProvider.initialize(applicationContext)
        
        try {
            Amplify.addPlugin(AWSApiPlugin())
            Amplify.configure(applicationContext)
        } catch (error: AmplifyException) {
            Log.e(TAG, "Error initializing Amplify", error)
        } catch (error: Exception) {
            Log.e(TAG, "Unexpected error during initialization", error)
        }
    }
} 

    <application
        android:name=".AmplifyApp"

import { defineStorage } from '@aws-amplify/backend';

export const storage = defineStorage({
  name: 'my-bucket',
  access: (allow) => ({
    'data/*': [
      allow.guest.to(['get']),
      allow.authenticated.to(['get'])
    ]
  })
});

import { defineAuth } from '@aws-amplify/backend';

export const auth = defineAuth({
  loginWith: {
    email: true,
  },
});

import { defineBackend } from '@aws-amplify/backend';
import { auth } from './auth/resource';
import { storage } from './storage/resource';

defineBackend({
  auth,
  storage,
});

$ npx ampx sandbox \
    --profile amplify-app-developer \
    --outputs-out-dir app/src/main/res/raw/

  Amplify Sandbox
  
  Identifier: 	firedev
  Stack: 	      amplify-project-firedev-sandbox-c212f661f8
  Region: 	      us-east-1
  
  To specify a different sandbox identifier, use --identifier

WARNING: Schema is using an @auth directive with deprecated provider 'iam'. Replace 'iam' provider with 'identityPool' provider.

✔ Backend synthesized in 1.47 seconds
✔ Type checks completed in 3.38 seconds
✔ Built and published assets
✔ Deployment completed in 210.98 seconds
AppSync API endpoint = https://hw734z3v7bhknhxjpvxf4xrnvu.appsync-api.us-east-1.amazonaws.com/graphql
[Sandbox] Watching for file changes…
File written: app/src/main/res/raw/amplify_outputs.json

 "storage": {
    "aws_region": "us-east-1",
    "bucket_name": "amplify-project-firedev-sandb-mybucket-ovpsejk2htya",
    ...

s3://amplify-project-firedev-sandb-mybucket-ovpsejk2htya/data/cards.json

// Set up local file for downloading
val localFile = File(cacheDir, FILE_NAME)

// Get bucket name from AmplifyOutputs
val outputs = AmplifyOutputs.fromResource(R.raw.amplify_outputs)
val jsonString = context
      .resources
      .openRawResource(R.raw.amplify_outputs)
      .bufferedReader()
      .use { it.readText() }
val jsonObject = Gson().fromJson(jsonString, JsonObject::class.java)
val storageObject = jsonObject.getAsJsonObject("storage")
val bucketName = storageObject.get("bucket_name").asString
                
// Set up S3 path - using data/ prefix to match permissions
val s3Path = StoragePath.fromString("$DATA_SUBFOLDER/$FILE_NAME")
val options = StorageDownloadFileOptions.builder().build()
Amplify.Storage.downloadFile(
  s3Path,
  localFile,
  options,
  { result ->
      try {
        val jsonString = localFile.readText()
        val response = Gson()
          .fromJson(jsonString, CardDataResponse::class.java)
        cards = response.cards
        onCardsLoaded?.invoke()
      } catch (e: Exception) {
        e.printStackTrace()
        throw e
      }
  },
  { error ->
      error.printStackTrace()
      throw error
  }
)

CardDataProvider.setOnCardsLoadedListener {
  updateContent()
}

override fun onCreate() {
  super.onCreate()
        
  try {
    Amplify.addPlugin(AWSS3StoragePlugin())
    Amplify.addPlugin(AWSCognitoAuthPlugin())
    val outputs = AmplifyOutputs.fromResource(R.raw.amplify_outputs)
    Amplify.configure(outputs, applicationContext)
            
    applicationScope.launch {
      try {
        CardDataProvider.initialize(applicationContext)
      } catch (e: Exception) {
        e.printStackTrace()
      }
    }
  ...

"auth": {
    "user_pool_id": "us-east-1_8Riey238F",
    "aws_region": "us-east-1",
    …

$ aws cognito-idp admin-set-user-password \
    --profile amplify-app-developer \
    --user-pool-id us-east-1_8Riey238F \
    --username jen@example.com \
    --password "My password has 0 numbers." \
    --permanent

private fun checkAuthSession() {
  Amplify.Auth.fetchAuthSession(
    { session ->
      val cognitoSession = session as AWSCognitoAuthSession
      if (cognitoSession.isSignedIn) {
        handleSignedInState()
      } else {
        Handler(Looper.getMainLooper()).post {
          updateAuthUI(false)
        }
      }
    },
    { error ->
      Handler(Looper.getMainLooper()).post {
        updateAuthUI(false)
      }
    }
  )
}

<activity
  android:name=".SignInActivity"
  android:exported="false"
  android:theme="@style/Theme.AppCompat.NoActionBar" />

import { type ClientSchema, a, defineData } from '@aws-amplify/backend';

const schema = a.schema({
  Favorite: a
    .model({
      userId: a.string().required(),
      videoId: a.string().required()
    })
    .authorization(allow => [
      allow.authenticated()
    ]),
});

export type Schema = ClientSchema<typeof schema>;

export const data = defineData({
  schema,
  authorizationModes: {
    defaultAuthorizationMode: 'userPool'
  }
});

import { defineBackend } from '@aws-amplify/backend';
import { auth } from './auth/resource';
import { storage } from './storage/resource';
import { data } from './data/resource';

defineBackend({
  auth,
  storage,
  data,
});

...
import com.amplifyframework.api.aws.AWSApiPlugin
...

class AmplifyApp : Application() {
    private val TAG = "AmplifyApp"
    private val applicationScope = CoroutineScope(SupervisorJob() + Dispatchers.Main)

    override fun onCreate() {
        super.onCreate()
        try {
            Amplify.addPlugin(AWSS3StoragePlugin())
            Amplify.addPlugin(AWSCognitoAuthPlugin())
            Amplify.addPlugin(AWSApiPlugin())
...

…
"data": {
    "url": "https://kvvm75giyvdk5kjdttewbdfvry.appsync-api.us-east-1.amazonaws.com/graphql",
    "aws_region": "us-east-1",
    "default_authorization_type": "AMAZON_COGNITO_USER_POOLS",
    "authorization_types": [
      "AWS_IAM"
    ],
    "model_introspection": {
      "version": 1,
      "models": {
        "Favorite": {
          "name": "Favorite",
          "fields": {
            "id": {
              "name": "id",
              "isArray": false,
              "type": "ID",
              "isRequired": true,
              "attributes": []
            },
            "userId": {
              "name": "userId",
              "isArray": false,
              "type": "String",
              "isRequired": true,
              "attributes": []
            },
            "videoId": {
              "name": "videoId",
              "isArray": false,
              "type": "String",
              "isRequired": true,
              "attributes": []
            },
            …

~project/$ npx ampx \
           --profile amplify-app-developer generate graphql-client-code \
           --format modelgen \
           --model-target java \
           --out app/src/main/java/

~/project/app/src/main/java/com$ tree amplifyframework

amplifyframework/
└── datastore
    └── generated
        └── model
            ├── AmplifyModelProvider.java
            ├── Favorite.java
            └── FavoritePath.java

private fun checkFavoriteStatus(
  cardView: ImageCardView,
  cardData: CardData) {

  val userId = AuthStateManager.getInstance().getCurrentUserId()
  val query = ModelQuery.list(Favorite::class.java,
                              Favorite
                                .VIDEO_ID.eq(cardData.videoId)
                                .and(Favorite.USER_ID.eq(userId))
              )

  Amplify.API.query(
    query,
    { response ->
      if (response.hasData()) {
        val isFavorite = response.data.items.count() > 0
        cardView.post {
          updateFavoriteIcon(cardView, isFavorite)
        }
      }
    },
    { error -> 
      Log.e(TAG, "Error checking favorite status: ${error.message}", error)
    }
  )
}

val favorite = Favorite.builder()
                 .userId(userId)
                 .videoId(videoData.videoId)
                 .build()

val createFavorite = ModelMutation.create(favorite)

Amplify.API.mutate(createFavorite,
  { response -> 
      checkFavoriteStatus()
  },
  { error -> 
      Log.e(TAG, "Error creating favorite: ${error.message}", error)
  }
)

val query = ModelQuery.list(Favorite::class.java,
                            Favorite
                              .VIDEO_ID.eq(videoData.videoId)
                              .and(Favorite.USER_ID.eq(userId))
            )
            
Amplify.API.query(
  query,
  { response ->
    if (response.hasData() && response.data.items.any()) {
      val favorite = response.data.items.first()
      val deleteMutation = ModelMutation.delete(favorite)
                        
      Amplify.API.mutate(
        deleteMutation,
        { 
          isFavorited = false
          updateFavoriteIcon()
        },
        { error -> 
            Log.e(TAG, "Error deleting favorite: ${error.message}", error)
        }
      )
    }
  },
  { error -> 
      Log.e(TAG, 
            "Error querying favorite for deletion: ${error.message}",
            Error
           )
  }
)