Room によるデータの読み取りと更新

1. 始める前に

前の Codelab では、Room 永続ライブラリ（SQLite データベース上の抽象化レイヤ）を使用してアプリデータを保存する方法を学習しました。この Codelab では、Inventory アプリに機能を追加し、Room を使用して SQLite データベースのデータの読み取り、表示、更新、削除を行う方法について学習します。LazyColumn を使用してデータベースのデータを表示し、データベースを構成するデータが変更されると表示データを自動的に更新します。

前提条件

• Room ライブラリを使用して SQLite データベースの作成と操作ができること。
• エンティティ クラス、DAO クラス、データベース クラスを作成できること。
• データ アクセス オブジェクト（DAO）を使用して Kotlin 関数を SQL クエリにマッピングできること。
• LazyColumn でリストアイテムを表示できること。
• このユニットで前の Codelab（Room を使用してデータを永続化する）を修了していること。

学習内容

• SQLite データベースからエンティティを読み取り、表示する方法。
• Room ライブラリを使用して SQLite データベースのエンティティの更新と削除を行う方法。

作成するアプリの概要

• 在庫アイテムのリストを表示し、Room を使用してアプリ データベースのアイテムを更新、編集、削除できる Inventory アプリ。

必要なもの

• Android Studio がインストールされているパソコン

2. スターター アプリの概要

この Codelab では、前の Codelab（Room を使用してデータを永続化する）で扱った Inventory アプリの解答コードをスターター コードとして使用します。スターター アプリはすでに、Room 永続ライブラリを使用してデータを保存できる状態になっています。ユーザーは [Add Item] 画面を使用してアプリ データベースにデータを追加できます。

注: 現在のバージョンのスターター アプリでは、データベースに保存されているデータは表示されません。

この Codelab ではアプリを拡張し、Room ライブラリを使用して、データの読み取りと表示、データベースのエンティティの更新と削除を行えるようにします。

この Codelab のスターター コードをダウンロードする

まず、スターター コードをダウンロードします。

$ git clone https://github.com/google-developer-training/basic-android-kotlin-compose-training-inventory-app.git
$ cd basic-android-kotlin-compose-training-inventory-app
$ git checkout room

または、リポジトリを ZIP ファイルとしてダウンロードし、Android Studio で開くこともできます。

ZIP をダウンロード

注: スターター コードは、ダウンロードしたリポジトリの room ブランチにあります。

この Codelab のスターター コードを確認する場合は、GitHub で表示します。

3. UI 状態を更新する

このタスクではアプリに LazyColumn を追加して、データベースに格納されているデータを表示します。

コンポーズ可能な関数 HomeScreen のチュートリアル

• ui/home/HomeScreen.kt ファイルを開き、HomeScreen() コンポーザブルを確認します。

@Composable
fun HomeScreen(
    navigateToItemEntry: () -> Unit,
    navigateToItemUpdate: (Int) -> Unit,
    modifier: Modifier = Modifier,
) {
    val scrollBehavior = TopAppBarDefaults.enterAlwaysScrollBehavior()

    Scaffold(
        topBar = {
            // Top app with app title
        },
        floatingActionButton = {
            FloatingActionButton(
                // onClick details
            ) {
                Icon(
                    // Icon details
                )
            }
        },
    ) { innerPadding ->

       // Display List header and List of Items
        HomeBody(
            itemList = listOf(),  // Empty list is being passed in for itemList
            onItemClick = navigateToItemUpdate,
            modifier = modifier.padding(innerPadding)
                              .fillMaxSize()
        )
    }

このコンポーズ可能な関数は、次のアイテムを表示します。

• アプリタイトルが記載されたトップ アプリバー
• 在庫に新しいアイテムを追加するフローティング アクション ボタン（FAB）
• コンポーズ可能な関数 HomeBody()

コンポーズ可能な関数 HomeBody() は、渡されたリストに基づいて在庫アイテムを表示します。スターター コード実装の一環として、空のリスト（listOf()）がコンポーズ可能な関数 HomeBody() に渡されます。在庫リストをこのコンポーザブルに渡すには、リポジトリから在庫データを取得して HomeViewModel に渡す必要があります。

HomeViewModel で UI 状態を出力する

ItemDao にメソッド（getItem() と getAllItems()）を追加してアイテムを取得する際、戻り値の型として Flow を指定します。Flow は通常のデータ ストリームを表すということを思い出してください。Flow を返すと、特定のライフサイクルについて DAO からメソッドを明示的に 1 回呼び出すだけで済みます。Room は、基となるデータの更新を非同期的に処理します。

Flow からデータを取得することを「Flow からの収集」といいます。UI レイヤの Flow から収集する際は、考慮すべき点がいくつかあります。

• 構成変更（デバイスの回転など）のようなライフサイクル イベントが発生すると、アクティビティが再作成されます。これにより、再コンポーズと Flow からの収集が再度行われます。
• ライフサイクル イベント間で既存のデータが失われないように、値を状態としてキャッシュに保存することをおすすめします。
• コンポーザブルのライフサイクルが終了した後など、オブザーバーが残っていない場合は、Flow をキャンセルする必要があります。

ViewModel から Flow を公開するには、StateFlow を使用することをおすすめします。StateFlow を使用すると、UI のライフサイクルに関係なくデータを保存でき、監視できます。Flow を StateFlow に変換するには、stateIn 演算子を使用します。

stateIn 演算子には、次に示す 3 つのパラメータがあります。

• scope - viewModelScope は、StateFlow のライフサイクルを定義します。viewModelScope がキャンセルされると、StateFlow もキャンセルされます。
• started - パイプラインは、UI が表示されている場合にのみアクティブにする必要があります。そのためには SharingStarted.WhileSubscribed() を使用します。最後のサブスクライバーの消失から共有コルーチンの停止までの遅延（ミリ秒単位）を設定するには、TIMEOUT_MILLIS を SharingStarted.WhileSubscribed() メソッドに渡します。
• initialValue - 状態フローの初期値を HomeUiState() に設定します。

Flow を StateFlow に変換したら、collectAsState() メソッドを使用して収集し、そのデータを同じ型の State に変換できます。

このステップでは、StateFlow（UI 状態のオブザーバブル API）として、Room データベース内のアイテムをすべて取得します。Room の在庫データが変更されると、UI が自動的に更新されます。

1. ui/home/HomeViewModel.kt ファイルを開きます。このファイルには TIMEOUT_MILLIS 定数と、コンストラクタ パラメータとしてアイテムのリストが指定された HomeUiState データクラスが含まれています。

// No need to copy over, this code is part of starter code

class HomeViewModel : ViewModel() {

    companion object {
        private const val TIMEOUT_MILLIS = 5_000L
    }
}

data class HomeUiState(val itemList: List<Item> = listOf())

2. HomeViewModel クラス内で、StateFlow<HomeUiState> 型の homeUiState という val を宣言します。 初期化エラーはこの後すぐに解決します。

val homeUiState: StateFlow<HomeUiState>

3. itemsRepository に対して getAllItemsStream() を呼び出し、宣言した homeUiState に割り当てます。

val homeUiState: StateFlow<HomeUiState> =
    itemsRepository.getAllItemsStream()

「Unresolved reference: itemsRepository」というエラーが発生します。この未解決の参照エラーを解決するには、ItemsRepository オブジェクトを HomeViewModel に渡す必要があります。

4. ItemsRepository 型のコンストラクタ パラメータを HomeViewModel クラスに追加します。

import com.example.inventory.data.ItemsRepository

class HomeViewModel(itemsRepository: ItemsRepository): ViewModel() {

5. ui/AppViewModelProvider.kt ファイルの HomeViewModel イニシャライザで、次のように ItemsRepository オブジェクトを渡します。

initializer {
    HomeViewModel(inventoryApplication().container.itemsRepository)
}

6. HomeViewModel.kt ファイルに戻ります。型の不一致エラーが発生します。これを解決するには、次のように変換マップを追加します。

val homeUiState: StateFlow<HomeUiState> =
    itemsRepository.getAllItemsStream().map { HomeUiState(it) }

Android Studio に型の不一致エラーが引き続き表示されます。このエラーは、homeUiState が StateFlow 型であり、getAllItemsStream() が Flow を返すことが原因です。

7. stateIn 演算子を使用して Flow を StateFlow に変換します。StateFlow は、UI 状態のオブザーバブル API であり、UI 自体を更新できます。

import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.flow.stateIn

val homeUiState: StateFlow<HomeUiState> =
    itemsRepository.getAllItemsStream().map { HomeUiState(it) }
        .stateIn(
            scope = viewModelScope,
            started = SharingStarted.WhileSubscribed(TIMEOUT_MILLIS),
            initialValue = HomeUiState()
        )

8. アプリをビルドして、コードにエラーがないことを確認します。表示は変わりません。

4. 在庫データを表示する

このタスクでは、HomeScreen で UI 状態を収集し、更新します。

1. HomeScreen.kt ファイルのコンポーズ可能な関数 HomeScreen に、HomeViewModel 型の新しい関数パラメータを追加し、初期化します。

import androidx.lifecycle.viewmodel.compose.viewModel
import com.example.inventory.ui.AppViewModelProvider

@Composable
fun HomeScreen(
    navigateToItemEntry: () -> Unit,
    navigateToItemUpdate: (Int) -> Unit,
    modifier: Modifier = Modifier,
    viewModel: HomeViewModel = viewModel(factory = AppViewModelProvider.Factory)
)

2. コンポーズ可能な関数 HomeScreen に homeUiState という val を追加して、HomeViewModel から UI 状態を収集します。collectAsState() を使用します。これにより、StateFlow から値を収集し、State を介してその最新の値を表します。

import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue

val homeUiState by viewModel.homeUiState.collectAsState()

3. HomeBody() 関数呼び出しを更新し、homeUiState.itemList を itemList パラメータに渡します。

HomeBody(
    itemList = homeUiState.itemList,
    onItemClick = navigateToItemUpdate,
    modifier = modifier.padding(innerPadding)
)

4. アプリを実行します。アプリ データベースにアイテムを保存した場合、在庫リストが表示されます。リストが空の場合は、在庫アイテムをアプリ データベースに追加します。

5. データベースをテストする

コードをテストする重要性については、これまでの Codelab で説明しました。このタスクでは、DAO クエリをテストする単体テストを追加します。その後、Codelab を進めながらテストを追加します。

データベース実装をテストするには、JUnit テストを作成して Android デバイス上で実行することをおすすめします。このテストではアクティビティの作成が必要ないため、UI テストよりも高速に実行できます。

1. build.gradle.kts (Module :app) ファイルで、Espresso と JUnit に関する次の依存関係に注意してください。

// Testing
androidTestImplementation("androidx.test.espresso:espresso-core:3.5.1")
androidTestImplementation("androidx.test.ext:junit:1.1.5")

2. [Project] ビューに切り替え、[src] > [New] > [Directory] を右クリックして、テスト用にテスト ソースセットを作成します。

3. [New Directory] ポップアップで [androidTest/kotlin] を選択します。

4. ItemDaoTest.kt という Kotlin クラスを作成します。
5. ItemDaoTest クラスに @RunWith(AndroidJUnit4::class) アノテーションを付けます。クラスは以下のサンプルコードのようになります。

package com.example.inventory

import androidx.test.ext.junit.runners.AndroidJUnit4
import org.junit.runner.RunWith

@RunWith(AndroidJUnit4::class)
class ItemDaoTest {
}

6. クラス内に、ItemDao 型と InventoryDatabase 型のプライベート var 変数を追加します。

import com.example.inventory.data.InventoryDatabase
import com.example.inventory.data.ItemDao

private lateinit var itemDao: ItemDao
private lateinit var inventoryDatabase: InventoryDatabase

7. データベースを作成するための関数を追加して @Before アノテーションを付け、どのテストよりも前に実行できるようにします。
8. メソッド内で、itemDao を初期化します。

import android.content.Context
import androidx.room.Room
import androidx.test.core.app.ApplicationProvider
import org.junit.Before

@Before
fun createDb() {
    val context: Context = ApplicationProvider.getApplicationContext()
    // Using an in-memory database because the information stored here disappears when the
    // process is killed.
    inventoryDatabase = Room.inMemoryDatabaseBuilder(context, InventoryDatabase::class.java)
        // Allowing main thread queries, just for testing.
        .allowMainThreadQueries()
        .build()
    itemDao = inventoryDatabase.itemDao()
}

この関数では、インメモリ データベースを使用し、ディスク上には保持しません。そのためには、inMemoryDatabaseBuilder() 関数を使用します。この処理を行うのは、情報を永続的に保持する必要はなく、プロセスが強制終了されたときに削除する必要があるためです。テスト用に、.allowMainThreadQueries() を使用してメインスレッドで DAO クエリを実行しています。

9. データベースを閉じるために別の関数を追加します。@After アノテーションを付けて、データベースを閉じ、それぞれのテストの後に実行します。

import org.junit.After
import java.io.IOException

@After
@Throws(IOException::class)
fun closeDb() {
    inventoryDatabase.close()
}

10. 次のコード例に示すように、使用するデータベース用にクラス ItemDaoTest でアイテムを宣言します。

import com.example.inventory.data.Item

private var item1 = Item(1, "Apples", 10.0, 20)
private var item2 = Item(2, "Bananas", 15.0, 97)

11. データベースにアイテムを 1 つ追加してから 2 つ追加するユーティリティ関数を追加します。これらの関数は後ほどテストで使用します。suspend としてマークし、コルーチン内で実行できるようにします。

private suspend fun addOneItemToDb() {
    itemDao.insert(item1)
}

private suspend fun addTwoItemsToDb() {
    itemDao.insert(item1)
    itemDao.insert(item2)
}

12. データベースにアイテムを 1 つ挿入する（insert()）テストを作成します。テストに daoInsert_insertsItemIntoDB という名前を付け、@Test アノテーションを付けます。

import kotlinx.coroutines.flow.first
import kotlinx.coroutines.runBlocking
import org.junit.Assert.assertEquals
import org.junit.Test

@Test
@Throws(Exception::class)
fun daoInsert_insertsItemIntoDB() = runBlocking {
    addOneItemToDb()
    val allItems = itemDao.getAllItems().first()
    assertEquals(allItems[0], item1)
}

このテストでは、ユーティリティ関数 addOneItemToDb() を使用してデータベースにアイテムを 1 つ追加します。次に、データベースの最初のアイテムを読み取ります。assertEquals() を使用して想定値と実際値を比較します。runBlocking{} を使用して新しいコルーチンでテストを実行します。このためにユーティリティ関数を suspend としてマークします。

13. テストを実行し、合格することを確認します。

14. データベースから getAllItems() の別のテストを作成します。テストに daoGetAllItems_returnsAllItemsFromDB という名前を付けます。

@Test
@Throws(Exception::class)
fun daoGetAllItems_returnsAllItemsFromDB() = runBlocking {
    addTwoItemsToDb()
    val allItems = itemDao.getAllItems().first()
    assertEquals(allItems[0], item1)
    assertEquals(allItems[1], item2)
}

上記のテストでは、コルーチン内でデータベースにアイテムを 2 つ追加します。次に、その 2 つのアイテムを読み取り、想定値と比較します。

6. アイテムの詳細を表示する

このタスクでは、エンティティの詳細を読み取って [Item Details] 画面に表示します。Inventory アプリのデータベースから取得した名前、価格、数量などのアイテム UI 状態を使用し、ItemDetailsScreen コンポーザブルで [Item Details] 画面に表示します。あらかじめ用意されているコンポーズ可能な関数 ItemDetailsScreen には、アイテムの詳細を表示する 3 つの Text コンポーザブルが含まれています。

ui/item/ItemDetailsScreen.kt

この画面はスターター コードの一部であり、アイテムの詳細を表示します。これについては、後の Codelab で説明します。この Codelab では、この画面は扱いません。ItemDetailsViewModel.kt は、この画面に対応する ViewModel です。

1. コンポーズ可能な関数 HomeScreen の HomeBody() 関数呼び出しに注目してください。navigateToItemUpdate が onItemClick パラメータに渡されています。これは、リスト内のアイテムをクリックすると呼び出されます。

// No need to copy over
HomeBody(
    itemList = homeUiState.itemList,
    onItemClick = navigateToItemUpdate,
    modifier = modifier
        .padding(innerPadding)
        .fillMaxSize()
)

2. ui/navigation/InventoryNavGraph.kt を開き、HomeScreen コンポーザブルの navigateToItemUpdate パラメータに注目してください。このパラメータは、アイテムの詳細画面としてナビゲーションのデスティネーションを指定します。

// No need to copy over
HomeScreen(
    navigateToItemEntry = { navController.navigate(ItemEntryDestination.route) },
    navigateToItemUpdate = {
        navController.navigate("${ItemDetailsDestination.route}/${it}")
   }

onItemClick 関数のこの部分は、すでに実装されています。リストアイテムをクリックすると、アプリは [Item Details] 画面に移動します。

3. 在庫リストのアイテムをクリックすると、フィールドが空の状態で [Item Details] 画面が表示されます。

テキスト フィールドにアイテムの詳細を入力するには、ItemDetailsScreen() で UI 状態を収集する必要があります。

4. UI/Item/ItemDetailsScreen.kt で、ItemDetailsViewModel 型の ItemDetailsScreen コンポーザブルに新しいパラメータを追加し、ファクトリ メソッドを使用して初期化します。

import androidx.lifecycle.viewmodel.compose.viewModel
import com.example.inventory.ui.AppViewModelProvider

@Composable
fun ItemDetailsScreen(
    navigateToEditItem: (Int) -> Unit,
    navigateBack: () -> Unit,
    modifier: Modifier = Modifier,
    viewModel: ItemDetailsViewModel = viewModel(factory = AppViewModelProvider.Factory)
)

5. ItemDetailsScreen() コンポーザブル内に uiState という val を作成して、UI 状態を収集します。collectAsState() を使用して uiState StateFlow を収集し、State を介して最新の値を表します。Android Studio に未解決の参照エラーが表示されます。

import androidx.compose.runtime.collectAsState

val uiState = viewModel.uiState.collectAsState()

6. エラーを解決するには、ItemDetailsViewModel クラスに StateFlow<ItemDetailsUiState> 型の uiState という val を作成します。
7. アイテム リポジトリからデータを取得し、拡張関数 toItemDetails() を使用して ItemDetailsUiState にマッピングします。拡張関数 Item.toItemDetails() はスターター コードの一部としてすでに作成されています。

import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.filterNotNull
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.flow.stateIn

val uiState: StateFlow<ItemDetailsUiState> =
         itemsRepository.getItemStream(itemId)
             .filterNotNull()
             .map {
                 ItemDetailsUiState(itemDetails = it.toItemDetails())
             }.stateIn(
                 scope = viewModelScope,
                 started = SharingStarted.WhileSubscribed(TIMEOUT_MILLIS),
                 initialValue = ItemDetailsUiState()
             )

8. ItemsRepository を ItemDetailsViewModel に渡して、Unresolved reference: itemsRepository エラーを解決します。

class ItemDetailsViewModel(
    savedStateHandle: SavedStateHandle,
    private val itemsRepository: ItemsRepository
    ) : ViewModel() {

9. 次のコード スニペットに示すように、ui/AppViewModelProvider.kt で ItemDetailsViewModel のイニシャライザを更新します。

initializer {
    ItemDetailsViewModel(
        this.createSavedStateHandle(),
        inventoryApplication().container.itemsRepository
    )
}

10. ItemDetailsScreen.kt に戻ると、ItemDetailsScreen() コンポーザブルのエラーが解決されています。
11. ItemDetailsScreen() コンポーザブルで、ItemDetailsBody() 関数呼び出しを更新し、uiState.value を itemUiState 引数に渡します。

ItemDetailsBody(
    itemUiState = uiState.value,
    onSellItem = {  },
    onDelete = { },
    modifier = modifier.padding(innerPadding)
)

12. ItemDetailsBody() と ItemInputForm() の実装を確認します。現在選択されている item を ItemDetailsBody() から ItemDetails() に渡します。

// No need to copy over

@Composable
private fun ItemDetailsBody(
    itemUiState: ItemUiState,
    onSellItem: () -> Unit,
    onDelete: () -> Unit,
    modifier: Modifier = Modifier
) {
    Column(
       //...
    ) {
        var deleteConfirmationRequired by rememberSaveable { mutableStateOf(false) }
        ItemDetails(
             item = itemDetailsUiState.itemDetails.toItem(), modifier = Modifier.fillMaxWidth()
         )

      //...
    }

13. アプリを実行します。[Inventory] 画面のリスト要素をクリックすると、[Item Details] 画面が表示されます。
14. 空白画面にはならず、在庫データベースから取得したエンティティの詳細が表示されます。

15. [Sell] ボタンをタップします。何も起こりません。

次のセクションでは、[Sell] ボタンの機能を実装します。

7. アイテムの詳細画面を実装する

ui/item/ItemEditScreen.kt

アイテム編集画面は、スターター コードの一部としてすでに用意されています。

このレイアウトには、新しい在庫アイテムの詳細を編集するテキスト フィールド コンポーザブルが含まれています。

このアプリのコードはまだ完全には機能しません。たとえば、[Item Details] 画面で [Sell] ボタンをタップしても [Quantity in Stock] は増えません。[Delete] ボタンをタップすると確認ダイアログが表示されますが、[Yes] ボタンを選択しても、そのアイテムが実際に削除されるわけではありません。

最後に、FAB ボタン をタップすると空の [Edit Item] 画面が開きます。

このセクションでは、[Sell] ボタン、[Delete] ボタン、FAB ボタンの機能を実装します。

8. アイテム販売機能を実装する

このセクションでは、アプリの機能を拡張して販売機能を実装します。この更新では次のタスクを行います。

• DAO 関数のテストを追加してエンティティを更新します。
• ItemDetailsViewModel に関数を追加して数量を減らし、アプリ データベースのエンティティを更新します。
• 数量が 0 の場合は [Sell] ボタンを無効にします。

1. ItemDaoTest.kt に、パラメータのない daoUpdateItems_updatesItemsInDB() という関数を追加します。@Test アノテーションと @Throws(Exception::class) アノテーションを付けます。

@Test
@Throws(Exception::class)
fun daoUpdateItems_updatesItemsInDB()

2. 関数を定義して、runBlocking ブロックを作成します。内部で addTwoItemsToDb() を呼び出します。

fun daoUpdateItems_updatesItemsInDB() = runBlocking {
    addTwoItemsToDb()
}

3. 2 つのエンティティを異なる値で更新し、itemDao.update を呼び出します。

itemDao.update(Item(1, "Apples", 15.0, 25))
itemDao.update(Item(2, "Bananas", 5.0, 50))

4. itemDao.getAllItems() を使用してエンティティを取得します。更新したエンティティと比較し、アサートします。

val allItems = itemDao.getAllItems().first()
assertEquals(allItems[0], Item(1, "Apples", 15.0, 25))
assertEquals(allItems[1], Item(2, "Bananas", 5.0, 50))

5. 完成した関数が次のようになっていることを確認します。

@Test
@Throws(Exception::class)
fun daoUpdateItems_updatesItemsInDB() = runBlocking {
    addTwoItemsToDb()
    itemDao.update(Item(1, "Apples", 15.0, 25))
    itemDao.update(Item(2, "Bananas", 5.0, 50))

    val allItems = itemDao.getAllItems().first()
    assertEquals(allItems[0], Item(1, "Apples", 15.0, 25))
    assertEquals(allItems[1], Item(2, "Bananas", 5.0, 50))
}

6. テストを実行し、合格することを確認します。

ViewModel に関数を追加する

1. ItemDetailsViewModel.kt の ItemDetailsViewModel クラス内に、パラメータのない reduceQuantityByOne() という関数を追加します。

fun reduceQuantityByOne() {
}

2. この関数内で、viewModelScope.launch{} を使用してコルーチンを開始します。

注: データベース操作は、コルーチン内で実行する必要があります。

import kotlinx.coroutines.launch
import androidx.lifecycle.viewModelScope

viewModelScope.launch {
}

3. launch ブロック内で、currentItem という val を作成し、uiState.value.toItem() に設定します。

val currentItem = uiState.value.toItem()

uiState.value は ItemUiState 型です。拡張関数 toItem() を使用して、Item エンティティ型に変換します。

4. quality が 0 より大きいかどうかを確認する if ステートメントを追加します。
5. itemsRepository に対して updateItem() を呼び出し、更新した currentItem を渡します。copy() を使用して quantity 値を更新し、関数を次のようにします。

fun reduceQuantityByOne() {
    viewModelScope.launch {
        val currentItem = uiState.value.itemDetails.toItem()
        if (currentItem.quantity > 0) {
    itemsRepository.updateItem(currentItem.copy(quantity = currentItem.quantity - 1))
       }
    }
}

6. ItemDetailsScreen.kt に戻ります。
7. ItemDetailsScreen コンポーザブルで、ItemDetailsBody() 関数呼び出しに移動します。
8. onSellItem ラムダで、viewModel.reduceQuantityByOne() を呼び出します。

ItemDetailsBody(
    itemUiState = uiState.value,
    onSellItem = { viewModel.reduceQuantityByOne() },
    onDelete = { },
    modifier = modifier.padding(innerPadding)
)

9. アプリを実行します。
10. [Inventory] 画面でリスト要素をクリックします。[Item Details] 画面が表示されたら、[Sell] をタップすると数量の値が 1 減ります。

11. [Item Details] 画面で、数量が 0 になるまで [Sell] ボタンをタップし続けます。

ヒント: 時間を節約するために、このタスクでは数量の少ないアイテムを使用することをおすすめします。数量の少ないアイテムがない場合は、数量の少ないアイテムを新たに作成しても構いません。

数量が 0 になったら、再度 [Sell] をタップします。数量を更新する前に関数 reduceQuantityByOne() によって数量が 0 より大きいかどうかがチェックされるため、見た目は変わりません。

適切なフィードバックをユーザーに提供するために、販売するアイテムがないときは [Sell] ボタンを無効にすることをおすすめします。

12. ItemDetailsViewModel クラスで、map 変換の it.quantity に基づいて outOfStock 値を設定します。

val uiState: StateFlow<ItemDetailsUiState> =
    itemsRepository.getItemStream(itemId)
        .filterNotNull()
        .map {
            ItemDetailsUiState(outOfStock = it.quantity <= 0, itemDetails = it.toItemDetails())
        }.stateIn(
            //...
        )

13. アプリを実行します。在庫量が 0 になると [Sell] ボタンが無効になります。

これで、アイテム販売機能がアプリに実装されました。

アイテム エンティティを削除する

前のタスクと同様に、削除機能を実装して、アプリの機能をさらに拡張する必要があります。この機能は、販売機能よりはるかに簡単に実装できます。このプロセスでは次のタスクを行います。

• 削除 DAO クエリのテストを追加します。
• データベースからエンティティを削除する関数を ItemDetailsViewModel クラスに追加します。
• ItemDetailsBody コンポーザブルを更新します。

DAO テストを追加する

1. ItemDaoTest.kt に、daoDeleteItems_deletesAllItemsFromDB() というテストを追加します。

@Test
@Throws(Exception::class)
fun daoDeleteItems_deletesAllItemsFromDB()

2. runBlocking {} を使用してコルーチンを開始します。

fun daoDeleteItems_deletesAllItemsFromDB() = runBlocking {
}

3. データベースにアイテムを 2 つ追加し、この 2 つのアイテムに対して itemDao.delete() を呼び出してデータベースから削除します。

addTwoItemsToDb()
itemDao.delete(item1)
itemDao.delete(item2)

4. データベースからエンティティを取得し、リストが空であることを確認します。完成したテストは次のようになります。

import org.junit.Assert.assertTrue

@Test
@Throws(Exception::class)
fun daoDeleteItems_deletesAllItemsFromDB() = runBlocking {
    addTwoItemsToDb()
    itemDao.delete(item1)
    itemDao.delete(item2)
    val allItems = itemDao.getAllItems().first()
    assertTrue(allItems.isEmpty())
}

ItemDetailsViewModel に削除関数を追加する

1. ItemDetailsViewModel に、deleteItem() という新しい関数を追加します。これはパラメータを受け取らず、何も返しません。
2. deleteItem() 関数内に itemsRepository.deleteItem() 関数呼び出しを追加して、uiState.value.toItem() を渡します。

suspend fun deleteItem() {
    itemsRepository.deleteItem(uiState.value.itemDetails.toItem())
}

この関数では、toItem() 拡張関数を使用して、uiState を itemDetails 型から Item エンティティ型に変換します。

3. ui/item/ItemDetailsScreen コンポーザブルに、coroutineScope という val を追加し、rememberCoroutineScope() に設定します。このアプローチでは、呼び出されたコンポジション（ItemDetailsScreen コンポーザブル）にバインドされているコルーチン スコープが返されます。

import androidx.compose.runtime.rememberCoroutineScope

val coroutineScope = rememberCoroutineScope()

4. ItemDetailsBody() 関数までスクロールします。
5. onDelete ラムダ内で coroutineScope を使用してコルーチンを開始します。
6. launch ブロック内で、viewModel に対して deleteItem() メソッドを呼び出します。

import kotlinx.coroutines.launch

ItemDetailsBody(
    itemUiState = uiState.value,
    onSellItem = { viewModel.reduceQuantityByOne() },
    onDelete = {
        coroutineScope.launch {
           viewModel.deleteItem()
    }
    modifier = modifier.padding(innerPadding)
)

7. アイテムを削除したら、在庫画面に戻ります。
8. deleteItem() 関数呼び出しの後で navigateBack() を呼び出します。

onDelete = {
    coroutineScope.launch {
        viewModel.deleteItem()
        navigateBack()
    }

9. 引き続き ItemDetailsScreen.kt ファイル内で、ItemDetailsBody() 関数までスクロールします。

この関数はスターター コードの一部です。このコンポーザブルは、アイテムを削除する前にユーザーの確認を得るためのアラート ダイアログを表示します。[Yes] をタップすると deleteItem() 関数が呼び出されます。

// No need to copy over

@Composable
private fun ItemDetailsBody(
    itemUiState: ItemUiState,
    onSellItem: () -> Unit,
    onDelete: () -> Unit,
    modifier: Modifier = Modifier
) {
    Column(
        /*...*/
    ) {
        //...

        if (deleteConfirmationRequired) {
            DeleteConfirmationDialog(
                onDeleteConfirm = {
                    deleteConfirmationRequired = false
                    onDelete()
                },
                //...
            )
        }
    }
}

[No] をタップするとアラート ダイアログが閉じます。showConfirmationDialog() 関数によって次のアラートが表示されます。

10. アプリを実行します。
11. [Inventory] 画面でリスト要素を選択します。
12. [Item Details] 画面で、[Delete] をタップします。
13. アラート ダイアログで [Yes] をタップすると [Inventory] 画面に戻ります。
14. 削除したエンティティがアプリ データベースに存在しなくなっていることを確認します。

これで削除機能が実装されました。

アイテム エンティティを編集する

前のセクションと同様に、このセクションではアイテム エンティティを編集するという別の機能をアプリに追加します。

アプリ データベースのエンティティを編集する手順を簡単に示すと、次のようになります。

• テスト用アイテム取得 DAO クエリにテストを追加します。
• テキスト フィールドと [Edit Item] 画面にエンティティの詳細を入力します。
• Room を使用してデータベースのエンティティを更新します。

DAO テストを追加する

1. ItemDaoTest.kt に、daoGetItem_returnsItemFromDB() というテストを追加します。

@Test
@Throws(Exception::class)
fun daoGetItem_returnsItemFromDB()

2. 関数を定義します。コルーチン内で、データベースにアイテムを 1 つ追加します。

@Test
@Throws(Exception::class)
fun daoGetItem_returnsItemFromDB() = runBlocking {
    addOneItemToDb()
}

3. itemDao.getItem() 関数を使用してデータベースからエンティティを取得し、item という val に設定します。

val item = itemDao.getItem(1)

4. assertEquals() を使用して実際値と取得値を比較し、アサートします。完成したテストは次のようになります。

@Test
@Throws(Exception::class)
fun daoGetItem_returnsItemFromDB() = runBlocking {
    addOneItemToDb()
    val item = itemDao.getItem(1)
    assertEquals(item.first(), item1)
}

5. テストを実行し、合格することを確認します。

テキスト フィールドに入力する

アプリを実行して [Item Details] 画面に移動し、次に FAB をクリックすると、画面のタイトルが [Edit Item] になったことを確認できます。ただし、テキスト フィールドはすべて空です。このステップでは、[Edit Item] 画面のテキスト フィールドにエンティティの詳細を入力します。

1. ItemDetailsScreen.kt で、ItemDetailsScreen コンポーザブルまでスクロールします。
2. FloatingActionButton() で、onClick 引数を変更して uiState.value.itemDetails.id（選択したエンティティの id）を含めます。この id を使用してエンティティの詳細を取得します。

FloatingActionButton(
    onClick = { navigateToEditItem(uiState.value.itemDetails.id) },
    modifier = /*...*/
)

3. ItemEditViewModel クラスに、init ブロックを追加します。

init {

}

4. init ブロック内で、viewModelScope.launch を使用してコルーチンを開始します。

import kotlinx.coroutines.launch

viewModelScope.launch { }

5. launch ブロック内で、itemsRepository.getItemStream(itemId) を使用してエンティティの詳細を取得します。

import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.flow.filterNotNull
import kotlinx.coroutines.flow.first

init {
    viewModelScope.launch {
        itemUiState = itemsRepository.getItemStream(itemId)
            .filterNotNull()
            .first()
            .toItemUiState(true)
    }
}

この launch ブロックに、null でない値のみを含むフローを返すフィルタを追加します。toItemUiState() を使用して、item エンティティを ItemUiState に変換します。actionEnabled 値を true として渡し、[Save] ボタンを有効にします。

Unresolved reference: itemsRepository エラーを解決するには、ビューモデルに依存関係として ItemsRepository を渡す必要があります。

6. ItemEditViewModel クラスにコンストラクタ パラメータを追加します。

class ItemEditViewModel(
    savedStateHandle: SavedStateHandle,
    private val itemsRepository: ItemsRepository
)

7. AppViewModelProvider.kt ファイルの ItemEditViewModel イニシャライザで、ItemsRepository オブジェクトを引数として追加します。

initializer {
    ItemEditViewModel(
        this.createSavedStateHandle(),
        inventoryApplication().container.itemsRepository
    )
}

8. アプリを実行します。
9. [Item Details] に移動し、FAB をタップします。
10. フィールドにアイテムの詳細が入力されます。
11. 在庫量または他のフィールドを編集し、[Save] をタップします。

何も起こりません。アプリ データベースのエンティティを更新していないためです。これは次のセクションで修正します。

Room を使用してエンティティを更新する

この最後のタスクでは、コードの最後の要素を追加して更新機能を実装します。ViewModel で必要な関数を定義し、ItemEditScreen で使用します。

それではまたコーディングしてみましょう。

1. ItemEditViewModel クラスに、ItemUiState オブジェクトを受け取って何も返さない updateUiState() という関数を追加します。この関数は、ユーザーが入力した新しい値で itemUiState を更新します。

fun updateUiState(itemDetails: ItemDetails) {
    itemUiState =
        ItemUiState(itemDetails = itemDetails, isEntryValid = validateInput(itemDetails))
}

この関数では、渡された itemDetails を itemUiState に割り当て、isEntryValid 値を更新します。itemDetails が true の場合、[Save] ボタンが有効になります。ユーザーが入力した内容が有効である場合にのみ、この値を true に設定します。

2. ItemEditScreen.kt ファイルに移動します。
3. ItemEditScreen コンポーザブルで、ItemEntryBody() 関数呼び出しまで下にスクロールします。
4. onItemValueChange 引数の値を、新しい関数 updateUiState に設定します。

ItemEntryBody(
    itemUiState = viewModel.itemUiState,
    onItemValueChange = viewModel::updateUiState,
    onSaveClick = { },
    modifier = modifier.padding(innerPadding)
)

5. アプリを実行します。
6. [Edit Item] 画面に移動します。
7. 無効になるようにエンティティ値のいずれかを空にします。[Save] ボタンが自動的に無効になります。

8. ItemEditViewModel クラスに戻り、何も受け取らない updateItem() という suspend 関数を追加します。この関数を使用して、更新したエンティティを Room データベースに保存します。

suspend fun updateItem() {
}

9. getUpdatedItemEntry() 関数内で、if 条件を追加し、validateInput() 関数を使用してユーザー入力を検証します。
10. itemsRepository に対して updateItem() 関数を呼び出し、itemUiState.itemDetails.toItem() を渡します。Room データベースに追加するには、エンティティを Item 型にする必要があります。完成した関数は次のようになります。

suspend fun updateItem() {
    if (validateInput(itemUiState.itemDetails)) {
        itemsRepository.updateItem(itemUiState.itemDetails.toItem())
    }
}

11. ItemEditScreen コンポーザブルに戻ります。updateItem() 関数を呼び出すためにコルーチン スコープが必要です。coroutineScope という val を作成し、rememberCoroutineScope() に設定します。

import androidx.compose.runtime.rememberCoroutineScope

val coroutineScope = rememberCoroutineScope()

12. ItemEntryBody() 関数呼び出しで、onSaveClick 関数の引数を更新し、coroutineScope 内のコルーチンを開始します。
13. launch ブロック内で、viewModel に対して updateItem() を呼び出し、戻ります。

import kotlinx.coroutines.launch

onSaveClick = {
    coroutineScope.launch {
        viewModel.updateItem()
        navigateBack()
    }
},

完成した ItemEntryBody() 関数呼び出しは次のようになります。

ItemEntryBody(
    itemUiState = viewModel.itemUiState,
    onItemValueChange = viewModel::updateUiState,
    onSaveClick = {
        coroutineScope.launch {
            viewModel.updateItem()
            navigateBack()
        }
    },
    modifier = modifier.padding(innerPadding)
)

14. アプリを実行し、在庫アイテムを編集してみましょう。Inventory アプリのデータベース内のアイテムを編集できるようになりました。

Room を使用してデータベースを管理する初めてのアプリを作成しました。

9. 解答コード

この Codelab の解答コードは、以下に示す GitHub リポジトリとブランチにあります。

解答コードの URL:

https://github.com/google-developer-training/basic-android-kotlin-compose-training-inventory-app

10. 関連リンク

Android デベロッパー ドキュメント

• Database Inspector を使用してデータベースをデバッグする
• Room を使用してローカル データベースにデータを保存する
• データベースをテストしてデバッグする | Android デベロッパー

Kotlin リファレンス

• Extensions