AWS Amplifyを活用して短時間でFire TV対応アプリを作成

~/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)
    
    // 依存関係をテストします
    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, "Amplifyを初期化する際のエラー", error)
        } catch (error: Exception) {
            Log.e(TAG, "初期化中の予期しないエラー", 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

// ダウンロード用のローカルファイルを設定します
val localFile = File(cacheDir, FILE_NAME)

// 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
                
// S3パスを設定 - パーミッションに合わせてdata/プレフィックスを使用します
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 "パスワードに数字が含まれていません。" \
    --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.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.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.message}", error)
        }
      )
    }
  },
  { error -> 
      Log.e(TAG, 
            "お気に入りの削除についてクエリする際のエラー: ${error.message}",
            Error
           )
  }
)