Androidアプリ開発 Compose x Room を使って Database を操作する

implementation("androidx.room:room-runtime:${rootProject.extra["room_version"]}") // 追加
ksp("androidx.room:room-compiler:${rootProject.extra["room_version"]}") // 追加
implementation("androidx.room:room-ktx:${rootProject.extra["room_version"]}") // 追加
implementation("androidx.lifecycle:lifecycle-viewmodel-compose:2.7.0") // ViewModelのために追加

buildscript {
    extra.apply {
        set("room_version", "2.6.1")
    }
}

plugins {
    ...
    id("com.google.devtools.ksp") version "1.9.0-1.0.13"
}

    compileOptions {
//        sourceCompatibility = JavaVersion.VERSION_1_8
//        targetCompatibility = JavaVersion.VERSION_1_8
        sourceCompatibility = JavaVersion.VERSION_17
        targetCompatibility = JavaVersion.VERSION_17
    }
    kotlinOptions {
//        jvmTarget = "1.8"
        jvmTarget = "17"
    }

package com.apppppp.testroom.data

import androidx.room.Entity
import androidx.room.PrimaryKey

@Entity(tableName = "users")
data class Users(
    @PrimaryKey(autoGenerate = true)
    val id: Int = 0,
    val name: String,
    val age: Int
)

CREATE TABLE users (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT NOT NULL,
    age INTEGER NOT NULL
);

package com.apppppp.testroom.data

import androidx.room.Dao
import androidx.room.Delete
import androidx.room.Insert
import androidx.room.OnConflictStrategy
import androidx.room.Query
import androidx.room.Update
import kotlinx.coroutines.flow.Flow

@Dao
interface UsersDao {
    @Insert(onConflict = OnConflictStrategy.IGNORE)
    suspend fun insert(item: Users)

    @Update
    suspend fun update(item: Users)

    @Delete
    suspend fun delete(item: Users)

    @Query("SELECT * from users WHERE id = :id")
    fun getItem(id: Int): Flow<Users>

    @Query("SELECT * from users ORDER BY name ASC")
    fun getAllItems(): Flow<List<Users>>
}

package com.apppppp.testroom.data

import android.content.Context
import androidx.room.Database
import androidx.room.Room
import androidx.room.RoomDatabase

/**
 * Database class with a singleton Instance object.
 */
@Database(entities = [Users::class], version = 1, exportSchema = false)
abstract class MyDatabase : RoomDatabase() {
    abstract fun usersDao(): UsersDao

    companion object {
        @Volatile
        private var INSTANCE: MyDatabase? = null

        fun getDatabase(context: Context): MyDatabase {
            return INSTANCE ?: synchronized(this) {
                Room.databaseBuilder(context, MyDatabase::class.java, "my_database").build().also { INSTANCE = it }
            }
        }
    }
}

package com.apppppp.testroom.data

import kotlinx.coroutines.flow.Flow

interface UsersRepository {

    fun getAllUsers(): Flow<List<Users>>

    fun getUserStream(id: Int): Flow<Users>

    suspend fun insertUser(user: Users)

    suspend fun updateUser(user: Users)

    suspend fun deleteUser(user: Users)
}

package com.apppppp.testroom.data

import kotlinx.coroutines.flow.Flow

class OfflineUsersRepository(private val userDao: UsersDao) : UsersRepository {
    override fun getAllUsers(): Flow<List<Users>> = userDao.getAllItems()

    override fun getUserStream(id: Int): Flow<Users> = userDao.getItem(id)

    override suspend fun insertUser(user: Users) = userDao.insert(user)

    override suspend fun updateUser(user: Users) = userDao.update(user)

    override suspend fun deleteUser(user: Users) = userDao.delete(user)
}

package com.apppppp.testroom.data

import android.content.Context

interface AppContainer {
    val usersRepository: UsersRepository
}

class AppDataContainer(private val context: Context) : AppContainer {
    override val usersRepository: UsersRepository by lazy {
        OfflineUsersRepository(MyDatabase.getDatabase(context).usersDao())
    }
}

package com.apppppp.testroom

import android.app.Application
import com.apppppp.testroom.data.AppContainer
import com.apppppp.testroom.data.AppDataContainer

class MyApplication: Application() {
    
    /**
     * AppContainer instance used by the rest of classes to obtain dependencies
     */
    lateinit var container: AppContainer
    
    override fun onCreate() {
        super.onCreate()
        container = AppDataContainer(this)
    }
}

    <application
        android:name=".MyApplication"
        ...

package com.apppppp.testroom.ui

import android.app.Application
import androidx.lifecycle.ViewModelProvider
import androidx.lifecycle.viewmodel.CreationExtras
import androidx.lifecycle.viewmodel.initializer
import androidx.lifecycle.viewmodel.viewModelFactory
import com.apppppp.testroom.MyApplication
import com.apppppp.testroom.ui.home.HomeViewModel

object AppViewModelProvider {

    val Factory = viewModelFactory {
        // Initializer for HomeViewModel
        initializer {
            HomeViewModel(inventoryApplication().container.usersRepository)
        }
    }
}

/**
 * Extension function to queries for [Application] object and returns an instance of
 * [MyApplication].
 */
fun CreationExtras.inventoryApplication(): MyApplication =
    (this[ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY] as MyApplication)

package com.apppppp.testroom.ui.home

import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Add
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.FloatingActionButton
import androidx.compose.material3.Icon
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import com.apppppp.testroom.ui.AppViewModelProvider
import androidx.lifecycle.viewmodel.compose.viewModel
import com.apppppp.testroom.data.Users

@Composable
fun HomeScreen(
    modifier: Modifier = Modifier,
    viewModel: HomeViewModel = viewModel(factory = AppViewModelProvider.Factory)
) {
    val homeUiState by viewModel.homeUiState.collectAsState()

    Scaffold(
        topBar = {
            Text(
                text = "ROOMテスト",
                style = MaterialTheme.typography.titleLarge,
                modifier = Modifier.padding(16.dp)
            )
        },
        floatingActionButton = {
            FloatingActionButton(
                onClick = {viewModel.addUser()},
                shape = MaterialTheme.shapes.medium,
            ) {
                Icon(
                    imageVector = Icons.Default.Add,
                    contentDescription = "追加"
                )
            }
        },
    ) { innerPadding ->
        LazyColumn(content = {
            items(items = homeUiState.userList, key = { it.id }) { user ->
                HomeListItem(
                    user = user,
                    modifier = Modifier
                        .clickable {
                            viewModel.deleteUser(user)
                        }
                )
            }
        },
            modifier = Modifier
                .padding(innerPadding)
        )
    }
}

@Composable
fun HomeListItem(user: Users, modifier: Modifier = Modifier) {
    Text(
        text = "${user.id} : ${user.name} (${user.age})",
        modifier = modifier.padding(16.dp)
    )
}

package com.apppppp.testroom.ui.home

import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.apppppp.testroom.data.Users
import com.apppppp.testroom.data.UsersRepository
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.flow.stateIn
import kotlinx.coroutines.launch

class HomeViewModel(private val usersRepository: UsersRepository): ViewModel() {
    /**
     * Holds home ui state. The list of items are retrieved from [UsersRepository] and mapped to
     * [HomeUiState]
     */

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

    companion object {
        private const val TIMEOUT_MILLIS = 5_000L
    }

    fun addUser() {
        viewModelScope.launch {
            val newUser = Users(name = "New User", age = 30)
            usersRepository.insertUser(newUser)
        }
    }

    fun deleteUser(user: Users) {
        viewModelScope.launch {
            usersRepository.deleteUser(user)
        }
    }
}

/**
 * Ui State for HomeScreen
 */
data class HomeUiState(val userList: List<Users> = listOf())