学习

Lab Week 7 Summary · Jimmy Huang's Blog

AndroidRoom

toml

[versions]
roomRuntime = "2.7.2"
ksp = "2.0.21-1.0.26"

[libraries]
room-runtime = {group = "androidx.room",name = "room-runtime",version.ref = "roomRuntime" }
room-ktx = {group = "androidx.room",name = "room-ktx",version.ref = "roomRuntime" }
room-compiler = {group = "androidx.room",name = "room-compiler",version.ref = "roomRuntime" }
compose-icons-extended = {group = "androidx.compose.material",name = "material-icons-extended" }

[plugins]
ksp = {id = "com.google.devtools.ksp",version.ref = "ksp" }

plain text

com.example.androidroom
├─ Subject.kt
├─ SubjectDAO.kt
├─ SubjectDatabase.kt
├─ SubjectRepository.kt
├─ SubjectViewModel.kt
├─ MainActivity.kt
└─ DialogSubjectScreen.kt   // Task 3 用

kotlin

plugins {
    alias(libs.plugins.android.application) apply false
    alias(libs.plugins.kotlin.android) apply false
    alias(libs.plugins.kotlin.compose) apply false
    alias(libs.plugins.ksp) apply false
}

kotlin

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

dependencies {
    // 保留模板原有依赖，不要删
    implementation(libs.room.runtime)
    implementation(libs.room.ktx)
    ksp(libs.room.compiler)

    // Part 3 的 Edit / Delete 图标会用到
    implementation(libs.compose.icons.extended)
}

kotlin

package com.example.androidroom

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

@Entity(tableName = "Subject")
data class Subject(
    @PrimaryKey(autoGenerate = true)
    val uid: Int = 0,
    val name: String
)

kotlin

package com.example.androidroom

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

@Dao
interface SubjectDAO {
    @Query("SELECT * FROM Subject")
    fun getAllSubjects(): Flow<List<Subject>>

    @Insert
    suspend fun insertSubject(subject: Subject)

    @Update
    suspend fun updateSubject(subject: Subject)

    @Delete
    suspend fun deleteSubject(subject: Subject)
}

kotlin

package com.example.androidroom

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

@Database(
    entities = [Subject::class],
    version = 1,
    exportSchema = false
)
abstract class SubjectDatabase : RoomDatabase() {

    abstract fun subjectDAO(): SubjectDAO

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

        fun getDatabase(context: Context): SubjectDatabase {
            return INSTANCE ?: synchronized(this) {
                val instance = Room.databaseBuilder(
                    context.applicationContext,
                    SubjectDatabase::class.java,
                    "subject_database"
                )
                    .fallbackToDestructiveMigration(true)
                    .build()

                INSTANCE = instance
                instance
            }
        }
    }
}

kotlin

package com.example.androidroom

import android.app.Application
import kotlinx.coroutines.flow.Flow

class SubjectRepository(application: Application) {

    private val subjectDao: SubjectDAO =
        SubjectDatabase.getDatabase(application).subjectDAO()

    val allSubjects: Flow<List<Subject>> = subjectDao.getAllSubjects()

    suspend fun insert(subject: Subject) {
        subjectDao.insertSubject(subject)
    }

    suspend fun update(subject: Subject) {
        subjectDao.updateSubject(subject)
    }

    suspend fun delete(subject: Subject) {
        subjectDao.deleteSubject(subject)
    }
}

kotlin

package com.example.androidroom

import android.app.Application
import androidx.lifecycle.AndroidViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.launch

class SubjectViewModel(application: Application) : AndroidViewModel(application) {

    private val repository = SubjectRepository(application)

    val allSubjects: Flow<List<Subject>> = repository.allSubjects

    fun insertSubject(subject: Subject) = viewModelScope.launch(Dispatchers.IO) {
        repository.insert(subject)
    }

    fun updateSubject(subject: Subject) = viewModelScope.launch(Dispatchers.IO) {
        repository.update(subject)
    }

    fun deleteSubject(subject: Subject) = viewModelScope.launch(Dispatchers.IO) {
        repository.delete(subject)
    }
}

kotlin

package com.example.androidroom

import android.os.Bundle
import android.widget.Toast
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.activity.viewModels
import androidx.compose.foundation.background
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.weight
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.material3.Button
import androidx.compose.material3.HorizontalDivider
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.material3.TextField
import androidx.compose.runtime.Composable
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp

class MainActivity : ComponentActivity() {

    private val viewModel: SubjectViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()

        setContent {
            MaterialTheme {
                SubjectScreen(subjectViewModel = viewModel)
            }
        }
    }
}

@Composable
fun SubjectScreen(subjectViewModel: SubjectViewModel) {
    val subjects by subjectViewModel.allSubjects.collectAsState(initial = emptyList())

    var name by remember { mutableStateOf("") }
    var selectedSubject by remember { mutableStateOf<Subject?>(null) }

    val context = LocalContext.current

    Column(modifier = Modifier.padding(16.dp)) {
        Spacer(modifier = Modifier.height(30.dp))

        Text(
            text = "Database Operations",
            modifier = Modifier.fillMaxWidth(),
            fontSize = 25.sp
        )

        Spacer(modifier = Modifier.height(10.dp))

        TextField(
            value = name,
            onValueChange = { name = it },
            label = { Text("Subject Name") },
            modifier = Modifier.fillMaxWidth()
        )

        Spacer(modifier = Modifier.height(10.dp))

        Row(
            modifier = Modifier.fillMaxWidth(),
            horizontalArrangement = Arrangement.spacedBy(8.dp)
        ) {
            Button(
                onClick = {
                    if (name.isBlank()) {
                        Toast.makeText(
                            context,
                            "Please enter a subject",
                            Toast.LENGTH_SHORT
                        ).show()
                    } else {
                        subjectViewModel.insertSubject(Subject(name = name))
                        name = ""
                        selectedSubject = null
                    }
                },
                modifier = Modifier.weight(1f)
            ) {
                Text("Add")
            }

            Button(
                onClick = {
                    if (selectedSubject == null) {
                        Toast.makeText(
                            context,
                            "Please select a subject to update",
                            Toast.LENGTH_SHORT
                        ).show()
                    } else if (name.isBlank()) {
                        Toast.makeText(
                            context,
                            "Please enter a subject",
                            Toast.LENGTH_SHORT
                        ).show()
                    } else {
                        val updated = selectedSubject!!.copy(name = name)
                        subjectViewModel.updateSubject(updated)
                        name = ""
                        selectedSubject = null
                    }
                },
                modifier = Modifier.weight(1f)
            ) {
                Text("Update")
            }

            Button(
                onClick = {
                    if (selectedSubject == null) {
                        Toast.makeText(
                            context,
                            "Please select a subject to delete",
                            Toast.LENGTH_SHORT
                        ).show()
                    } else {
                        subjectViewModel.deleteSubject(selectedSubject!!)
                        name = ""
                        selectedSubject = null
                    }
                },
                modifier = Modifier.weight(1f)
            ) {
                Text("Delete")
            }
        }

        Spacer(modifier = Modifier.height(16.dp))

        LazyColumn {
            items(items = subjects, key = { it.uid }) { subject ->
                Row(
                    modifier = Modifier
                        .fillMaxWidth()
                        .background(
                            if (selectedSubject?.uid == subject.uid) {
                                Color.LightGray
                            } else {
                                Color.Transparent
                            }
                        )
                        .clickable {
                            name = subject.name
                            selectedSubject = subject
                        }
                        .padding(8.dp),
                    verticalAlignment = Alignment.CenterVertically
                ) {
                    Text(
                        text = subject.name,
                        modifier = Modifier.weight(1f)
                    )
                }
                HorizontalDivider(thickness = 2.dp)
            }
        }
    }
}

kotlin

package com.example.androidroom

import android.widget.Toast
import androidx.compose.foundation.background
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.weight
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Delete
import androidx.compose.material.icons.filled.Edit
import androidx.compose.material3.AlertDialog
import androidx.compose.material3.Button
import androidx.compose.material3.HorizontalDivider
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.unit.dp

@Composable
fun SubjectDialogScreen(subjectViewModel: SubjectViewModel) {
    val subjects by subjectViewModel.allSubjects.collectAsState(initial = emptyList())

    var selectedSubject by remember { mutableStateOf<Subject?>(null) }
    var showDialog by remember { mutableStateOf(false) }
    var isEditMode by remember { mutableStateOf(false) }
    var dialogText by remember { mutableStateOf("") }

    val context = LocalContext.current

    Column(modifier = Modifier.padding(16.dp)) {
        Spacer(modifier = Modifier.height(24.dp))

        Button(
            onClick = {
                isEditMode = false
                dialogText = ""
                showDialog = true
            },
            modifier = Modifier.fillMaxWidth()
        ) {
            Text("Add Subject")
        }

        Spacer(modifier = Modifier.height(16.dp))

        LazyColumn {
            items(items = subjects, key = { it.uid }) { subject ->
                Row(
                    modifier = Modifier
                        .fillMaxWidth()
                        .background(
                            if (selectedSubject?.uid == subject.uid) {
                                Color.LightGray
                            } else {
                                Color.Transparent
                            }
                        )
                        .clickable { selectedSubject = subject }
                        .padding(vertical = 8.dp),
                    verticalAlignment = Alignment.CenterVertically
                ) {
                    Text(
                        text = subject.name,
                        modifier = Modifier.weight(1f)
                    )

                    IconButton(
                        onClick = {
                            selectedSubject = subject
                            isEditMode = true
                            dialogText = subject.name
                            showDialog = true
                        }
                    ) {
                        Icon(
                            imageVector = Icons.Default.Edit,
                            contentDescription = "Edit Subject"
                        )
                    }

                    IconButton(
                        onClick = {
                            selectedSubject = subject
                            subjectViewModel.deleteSubject(subject)
                            selectedSubject = null

                            Toast.makeText(
                                context,
                                "Subject deleted",
                                Toast.LENGTH_SHORT
                            ).show()
                        }
                    ) {
                        Icon(
                            imageVector = Icons.Default.Delete,
                            contentDescription = "Delete Subject"
                        )
                    }
                }

                HorizontalDivider()
            }
        }
    }

    if (showDialog) {
        SubjectInputDialog(
            title = if (isEditMode) "Edit Subject" else "Add Subject",
            initialValue = dialogText,
            onDismiss = {
                showDialog = false
                dialogText = ""
            },
            onSave = { newName ->
                if (newName.isBlank()) {
                    Toast.makeText(
                        context,
                        "Please enter a subject",
                        Toast.LENGTH_SHORT
                    ).show()
                } else {
                    if (isEditMode) {
                        val current = selectedSubject
                        if (current != null) {
                            subjectViewModel.updateSubject(current.copy(name = newName))
                        }
                    } else {
                        subjectViewModel.insertSubject(Subject(name = newName))
                    }

                    selectedSubject = null
                    showDialog = false
                    dialogText = ""
                }
            }
        )
    }
}

@Composable
private fun SubjectInputDialog(
    title: String,
    initialValue: String,
    onDismiss: () -> Unit,
    onSave: (String) -> Unit
) {
    var text by remember(initialValue) { mutableStateOf(initialValue) }

    AlertDialog(
        onDismissRequest = onDismiss,
        title = {
            Text(text = title)
        },
        text = {
            OutlinedTextField(
                value = text,
                onValueChange = { text = it },
                label = { Text("Subject Name") },
                singleLine = true,
                modifier = Modifier.fillMaxWidth()
            )
        },
        confirmButton = {
            TextButton(onClick = { onSave(text) }) {
                Text("Save")
            }
        },
        dismissButton = {
            TextButton(onClick = onDismiss) {
                Text("Cancel")
            }
        }
    )
}

Lab Week 7 Summary

Overview

Goal

Task 0: 创建项目并完成 Room / KSP 环境配置

Lab Week 7 Summary

Overview

Goal

Task 0: 创建项目并完成 Room / KSP 环境配置

Step 0.1：创建 Android Studio 项目

Step 0.2：修改 gradle/libs.versions.toml

Step 0.3：修改项目级 build.gradle.kts

Step 0.4：修改模块级 app/build.gradle.kts

Step 0.5：同步 Gradle 并检查依赖是否正常

Task 1: 创建 Room 数据层

Step 1.1：确定文件结构

Step 1.2：创建 Entity —— Subject.kt

Step 1.3：创建 DAO —— SubjectDAO.kt

Step 1.4：创建 Database —— SubjectDatabase.kt

Step 1.5：创建 Repository —— SubjectRepository.kt

Step 1.6：创建 ViewModel —— SubjectViewModel.kt

Task 2: 实现基础版 Compose UI，并完成 CRUD 验证

Step 2.1：把 MainActivity.kt 改成基础版 Room UI

Step 2.2：运行 app 并测试 Add / Update / Delete

Step 2.3：用 Database Inspector 验证数据确实写进 Room（推荐）

Task 3: 完成 Part 3 的进阶版 UI（AlertDialog + 列表图标操作）

Step 3.1：新建 DialogSubjectScreen.kt

Step 3.2：把 MainActivity.kt 切换到 Dialog 版本

Step 3.3：运行并验证 Dialog 版本

Summary

本周必须理解的知识点

1. Entity / DAO / Database / Repository / ViewModel 各自负责什么

2. 为什么数据库操作不能直接跑在主线程

3. suspend function 和 Flow 的区别

4. 为什么更新时要用 copy()

关键概念对比

suspend function vs Flow

ViewModel vs AndroidViewModel

DAO vs Repository

老师可能会问什么

为什么 Room 里读全部数据要用 Flow？

为什么这里还要加 Repository？

为什么新增时不用传 uid？

为什么 Update 要先选中某一条记录？

为什么 Part 3 能换 UI 但数据库层不用改？

提交前自查

Step 0.2：修改 `gradle/libs.versions.toml`

Step 0.3：修改项目级 `build.gradle.kts`

Step 0.4：修改模块级 `app/build.gradle.kts`

Step 1.2：创建 Entity —— `Subject.kt`

Step 1.3：创建 DAO —— `SubjectDAO.kt`

Step 1.4：创建 Database —— `SubjectDatabase.kt`

Step 1.5：创建 Repository —— `SubjectRepository.kt`

Step 1.6：创建 ViewModel —— `SubjectViewModel.kt`

Step 2.1：把 `MainActivity.kt` 改成基础版 Room UI

Step 3.1：新建 `DialogSubjectScreen.kt`

Step 3.2：把 `MainActivity.kt` 切换到 Dialog 版本

3. `suspend function` 和 `Flow` 的区别

4. 为什么更新时要用 `copy()`

`suspend function` vs `Flow`

`ViewModel` vs `AndroidViewModel`

`DAO` vs `Repository`

为什么 Room 里读全部数据要用 `Flow`？

为什么新增时不用传 `uid`？