如何在2026年构建并发布原生Android应用程序：从Jetpack Compose到Google Play商店

大多数关于Android的开发教程都只讲到“应用程序可以在模拟器上运行”这一阶段。但实际上，要将一个从空白项目开发出来的应用发布到Google Play商店供用户下载，还需要完成许多其他步骤，而这些内容在很多教程中都被忽略了：发布版本的构建、签名密钥的生成、应用包的制作、应用信息的填写、政策声明的提交，以及新开发者账户必须经历的测试环节。

在过去的几年里，Android开发领域也发生了很大的变化。Jetpack Compose现在已经成为了默认的UI开发工具包，XML布局方式已经过时了，Kotlin成为了官方模板中唯一支持的语言，而Google Play也对新开发者提出了更高的要求。

那些以`findViewById`方法作为入门内容或以上传APK文件作为结束环节的旧教程，已经无法反映当前的实际开发流程了。

这本手册会带你完整地走完整个开发过程。你将使用Jetpack Compose、Room、ViewModel以及Navigation 3框架来构建一个功能齐全的小型笔记应用，编写相应的测试用例，生成经过签名的发布版本包，然后通过Google Play Console将其正式发布到应用商店。

目录

• 先决条件

• 你将构建什么

• 如何搭建开发环境

• 如何创建新的Compose项目

• 如何使用版本目录配置依赖项

• Jetpack Compose对UI的设计理念

• 如何构建应用程序的结构

• 如何使用Room在本地存储数据

• 如何通过仓库和应用程序类暴露数据

• 如何使用ViewModel管理UI状态

• 如何构建笔记列表界面

• 如何构建笔记编辑界面

• 如何使用Navigation 3添加导航功能

• 如何处理主题设置与边缘到边缘显示效果

• 如何测试你的Compose组件

• 如何为应用发布做准备

• 如何生成上传密钥并为应用签名

• 如何构建Android应用包

• 如何创建Google Play开发者账户

• 如何在Play Console中创建你的应用

• 如何完成应用内容声明的填写

• 如何设置应用在商店中的展示信息

• 如何进行内部测试与封闭测试

• 如何将应用发布到生产环境

• 如何在应用发布后推送更新

• 总结

先决条件

您应该已经熟悉基本的编程概念，并且至少读过一些关于Kotlin的资料。不需要具备Android开发的经验，因为所有与Android相关的概念都会在相关内容中得到解释。

在工具方面，您需要以下设备：

• 一台运行macOS、Windows或Linux操作系统的电脑，内存容量至少为16GB（8GB也可以使用，但模拟器的运行速度会较慢）

• 最新版本的Android Studio

• 一部真实的Android手机（开发阶段可选，但在后续进行Play Console账户验证时是必需的）

• 一个Google账户，以及25美元的费用，用于支付一次性的Google Play开发者注册费

您将构建什么

这个示例应用程序名为“Quick Notes”。它会显示按最近编辑时间排序的笔记列表，同时允许用户通过浮动操作按钮创建新笔记、点击笔记进行编辑或删除笔记。所有数据都会存储在设备本地的SQLite数据库中，因此该应用程序可以在离线状态下运行，且不需要后端服务器。

虽然一个笔记应用看起来很简单，但它实际上涵盖了任何真实应用程序所必需的所有功能：列表界面和详细信息界面、用于在两者之间切换的返回按钮、持久化的数据存储机制、能够在屏幕旋转等配置变化后仍然保持数据完整性的机制，以及用户输入处理功能。一旦您了解了这些组件的工作原理，就可以用它们来构建其他类型的应用程序。

最终形成的应用程序架构如下：

+-------------------------------------------------------------+
|                         用户界面层                            |
|  MainActivity -> NavDisplay -> NoteListScreen               |
|                             -> NoteEditorScreen             |
|                  监听状态变化，发送相关事件           |
+------------------------------+------------------------------+
                               |
                               v
+-------------------------------------------------------------+
|                      笔记数据模型                         |
|      负责存储用户界面状态，能在屏幕旋转等操作后保持数据完整     |
+------------------------------+------------------------------+
                               |
                               v
+-------------------------------------------------------------+
|                       数据访问层                            |
|   NoteRepository -> NoteDao -> NotesDatabase (Room/SQLite)  |
+-------------------------------------------------------------+

该图示展示了这三层结构，箭头指向下方，表示各层之间的依赖关系。

位于最上层的用户界面层包含了活动主体以及两个显示界面。它仅与数据模型进行交互，从不直接访问数据库。

中间的数据模型负责存储各个界面需要显示的数据，并且能够在屏幕旋转等操作导致数据丢失的情况下保证数据的完整性。

最底层的数据层包裹着“Room”，而“Room”实际上是在SQLite基础上构建的一个类型化层。数据会以Flow的形式逐层向上传递，因此当数据库内容发生变化时，用户界面会自动更新。

这种分层架构正是谷歌在其官方应用开发指南中推荐的。

如何搭建你的开发环境

请从developer.android.com/studio下载Android Studio并运行安装程序。首次启动时，设置向导会自动下载Android SDK、平台工具（包括adb）以及模拟器的系统镜像。除非有特殊原因，否则请接受默认设置。Android Studio自带JDK，因此无需另行安装Java。

设置完成后，通过工具 > SDK管理器打开SDK Manager，确认已安装了最新的稳定版Android平台。在撰写本文时，这意味着至少需要安装Android 16（API级别36）。

Google Play要求新应用及应用更新必须针对较新的API级别进行开发，而且这一要求每年都会提高，通常在8月底进行调整。在开始开发之前，请先查看目标API级别要求页面,以确定应该选择哪个版本作为目标。

接下来，通过工具 > 设备管理器创建一个模拟器。请选择较新的Pixel手机配置文件以及包含Google Play服务的最新系统镜像。

如果你更愿意在真实设备上进行测试，可以在设备的设置 > 关于手机中连续点击7次版本号来启用开发者选项，然后在该菜单中打开USB调试（或无线调试）功能。

如何创建一个新的Compose项目

在Android Studio中，选择文件 > 新建 > 新项目，然后选择空活动模板。这个模板是基于Compose框架设计的。而名称相似的“空视图活动”模板则使用较旧的XML布局系统，因此请务必选择正确的模板。

填写项目相关信息。项目名称是用户看到的显示名称；包名则是你的应用在Google Play上唯一的标识符，其格式为反向域名形式，例如com.yourname.quicknotes。请仔细选择包名，因为一旦发布后就无法更改了。将“最低SDK版本”设置为API 24，这样几乎可以覆盖所有正在使用的Android设备；同时，请将构建配置语言保留为Kotlin DSL。

点击完成按钮，等待第一次Gradle同步操作结束。最终生成的项目结构大致如下：

QuickNotes/
├── app/
│   ├── build.gradle.kts
│   ├── proguard-rules.pro
│   └── src/
│       ├── main/
│       │   ├── AndroidManifest.xml
│       │   ├── java/com/yourname/quicknotes/
│       │   │   ├── MainActivity.kt
│       │   │   └── ui/theme/
│       │   └── res/
│       ├── test/
│       └── androidTest/
├── gradle/
│   └── libs.versions.toml
├── build.gradle.kts
└── settings.gradle.kts

该结构图展示了新建项目中的重要文件分布情况。

app文件夹是构成可安装应用程序的核心模块，其中的build.gradle.kts文件包含了Android项目的配置信息（如SDK版本、依赖库版本等）。

src/main目录存放着用于生产环境的代码、用于向系统声明应用程序组件的AndroidManifest.xml文件，以及图标、字符串等资源文件，这些资源都保存在res文件夹中。

test文件夹用于编写在计算机上运行的单元测试代码，而androidTest文件夹则用于存储需要在设备或模拟器上执行的测试脚本。

在项目根目录下，gradle/libs.versions.toml文件是一个版本管理目录，其中记录了所有依赖库的版本信息；settings.gradle.kts文件则列出了项目中所包含的所有模块。出于历史原因，Kotlin相关文件被保存在名为java的文件夹中，这是正常的做法。

点击绿色的运行按钮，经过短暂的构建过程后，模拟器屏幕上应该会显示“Hello Android!”这个提示信息，这说明你的开发工具链已经可以正常使用了。

如何使用版本管理目录配置依赖关系

现代的Android项目会将所有依赖库的版本信息保存在gradle/libs.versions.toml文件中，并通过构建脚本中的别名来引用这些依赖库。

打开这个文件，将其内容替换为以下内容：

[versions]
agp = "9.0.0"
kotlin = "2.3.0"
ksp = "2.3.4"
composeBom = "2026.01.00"
activityCompose = "1.12.2"
lifecycle = "2.10.0"
navigation3 = "1.0.0"
room = "2.8.4"
serialization = "1.9.0"
junit = "4.13.2"
androidxJunit = "1.3.0"

[libraries]
androidx-activity-compose = { group = "androidx.activity", name = "activity-compose", version.ref = "activityCompose" }
androidx-compose-bom = { group = "androidx.compose", name = "compose-bom", version_ref = "composeBom" }
androidx-compose-ui = { group = "androidx.compose.ui", name = "ui" }
androidx-compose-ui-tooling = { group = "androidxCompose.ui", name = "ui-tooling" }
androidx-compose-ui-tooling-preview = { group = "androidx.compose.ui", name = "ui-tooling-preview" }
androidx-compose-ui-test-junit4 = { group = "androidxcompose.ui", name = "ui-test-junit4" }
androidx-compose-ui-test-manifest = { group = "androidxCompose.ui", name = "ui-test-manifest" }
androidx-compose-material3 = { group = "androidx.compose.material3", name = "material3" }
androidx-compose-material-icons-core = { group = "androidxcompose_material", name = "material-icons-core" }
androidx-lifecycle-viewmodel-compose = { group = "androidx.lifecycle", name = "lifecycle-viewmodel-compose", version_ref = "lifecycle" }
androidx-lifecycle-runtime-compose = { group = "androidx 生命周期", name = "lifecycle-runtime-compose", version_ref = "lifecycle" }
androidx-navigation3-runtime = { group = "androidx.navigation3", name = "navigation3-runtime", version_ref = "navigation3" }
androidx-navigation3-ui = { group = "androidx/navigation3", name = "navigation3-ui", version_ref = "navigation3" }
androidx-room-runtime = { group = "androidx.room", name = "room-runtime", version_ref = "room" }
androidx-room-ktx = { group = "androidx.room", name = "room-ktx", version_ref = "room" }
androidx-room-compiler = { group = "androidx_room", name = "room-compiler", version_ref = "room" }
kotlinx-serialization-core = { group = "org.jetbrains.kotlinx", name = "kotlinx-serialization-core", version_ref = "serialization" }
junit = { group = "junit", name = "junit", version_ref = "junit" }
androidx-junit = { group = "androidx.test.ext", name = "junit", version_ref = "androidxJunit" }

[plugins]
android-application = { id = "com.android.application", version_ref = "agp" }
kotlin-compose = { id = "org.jetbrains.kotlin.plugin.compose", version_ref = "kotlin" }
kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version_ref = "kotlin" }
ksp = { id = "com.google.devtools.ksp", version_ref = "ksp" }
room = { id = "androidx.room", version_ref = "room" }

该目录分为三个部分：[versions] 部分会为每个版本号列出一次其名称；[libraries] 部分会将简短的别名映射到 Maven 坐标上；而 [plugins] 部分则会对 Gradle 插件执行同样的操作。

Gradle 会将每个别名中的连字符替换成点，因此在你编写构建脚本时，androidx-room-runtime 会变成 libs.androidx.room.runtime。Compose 库本身并没有自己的版本号，因为它们的版本号是从 Compose BOM（物料清单）中获取的；Compose BOM 指定了需要一起测试的一组 Compose 库。Kotlin Compose 编译器插件与 Kotlin 本身的版本号是相同的，这种情况从 Kotlin 2.0 开始就一直存在。

KSP 是 Room 使用的注解处理器，用于生成数据库相关的代码。这里列出的版本号在本文编写时都是最新的。Android Studio 会标记目录中过时的条目，你应该按照它的建议来使用最新的稳定版本。

plugins {
    alias(libs.plugins.android.application) apply false
    alias(libs.plugins.kotlincompose) apply false
    alias(libs.plugins.kotlinserialization) apply false
    alias(libs.plugins.ksp) apply false
    alias(libs.plugins.room) apply false
}

这段代码通过 apply false 来声明每个插件，这样这些插件只会被添加到构建类的路径中，而不会被应用到整个项目中。每个模块可以根据实际需要选择是否使用这些插件。

plugins {
    alias(libs.plugins.android.application)
    alias(libs.plugins.kotlincompose)
    alias(libs.plugins.kotlinserialization)
    alias(libs.plugins.ksp)
    alias(libs.plugins.room)
}

android {
    namespace = "com.yourname.quicknotes"
    compileSdk = 36

    defaultConfig {
        applicationId = "com.yourname.quicknotes"
        minSdk = 24
        targetSdk = 36
        versionCode = 1
        versionName = "1.0.0"
        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
    }

    buildTypes {
        release {
            isMinifyEnabled = true
            isShrinkResources = true
            proguardFiles(
                getDefaultProguardFile("proguard-android-optimize.txt"),
                "proguard-rules.pro"
            )
        }
    }

    buildFeatures {
        compose = true
    }
}

room {
    schemaDirectory("$projectDir/schemas")
}

dependencies {
    val composeBom = platform(libs.androidxcompose.bom)
    implementation(composeBom)
    androidTestImplementation(composeBom)

    implementation(libs.androidx.activity.compose)
    implementation(libs.androidxCompose.ui)
    implementation(libs.androidxCompose.ui.tooling.preview)
    implementation(libs.androidxCompose.material3)
    implementation(libs.androidxCompose.material.icons.core)
    implementation(libs.androidx.lifecycle.viewmodelcompose)
    implementation(libs.androidx 生命周期.runtimecompose)
    implementation(libs.androidx.navigation3.runtime)
    implementation(libs.androidx.navigation3.ui)
    implementation(libs.androidx.room.runtime)
    implementation(libs.androidx.room.ktx)
    implementation(libs.kotlinx.serialization.core)
    ksp(libs.androidx.room.compiler)

    testImplementation(libs.junit)
    androidTestImplementation/libs.androidx.junit)
    androidTestImplementation(libs.androidxCompose.ui.test.junit4)
    debugImplementation(libs.androidxCompose.ui.tooling)
    debugImplementation(libs.androidxCompose.ui.test.manifest)
}

这是项目中最重要的配置文件，因此请仔细阅读它。

@Composable
fun Counter() {
    var count by remember { mutableIntStateOf(0) }

    Button(onClick = { count++ }) {
        Text("已被点击 $count 次")
    }
}

com.yourname.quicknotes
├── data/
│   ├── Note.kt
│   ├── NoteDao.kt
│   ├── NotesDatabase.kt
│   └── NoteRepository.kt
├── ui/
│   ├── NotesViewModel.kt
│   ├── NoteListScreen.kt
│   ├── NoteEditorScreen.kt
│   └── theme/
├── navigation/
│   └── NavKeys.kt
├── MainActivity.kt
└── NotesApp.kt

package com.yourname.quicknotes.data

import androidx.room.Entity
import androidx_room.PrimaryKey

@Entity(tableName = "notes")
data class Note(
    @PrimaryKey(autoGenerate = true) val id: Long = 0,
    val title: String,
    val body: String,
    val.updated: Long = System.currentTimeMillis()
)

package com.yourname.quicknotes.data

import androidx.room Dao
import androidx.room.Delete
import androidx.room.Query
import androidx.room.Upsert
import kotlinx.coroutines.flow.Flow

@Dao
interface NoteDao {
    @Query("SELECT * FROM notes ORDER BY.updated DESC")
    fun observeAll(): Flow>

    @Query("SELECT * FROM notes WHERE id = :id")
    suspend fun getById(id: Long): Note?

    @Upsert
    suspend fun upsert(note: Note)

    @Delete
    suspend fun delete(note: Note)
}

package com.yourname.quicknotes.data

import androidx.room.Database
import androidx.room.RoomDatabase

@Database(entities = [Note::class], version = 1, exportSchema = true)
abstract class NotesDatabase : RoomDatabase() {
    abstract fun noteDao(): NoteDao
}

如何通过仓库和应用程序类来暴露数据

package com.yourname.quicknotes.data

import kotlinx.coroutines.flow.Flow

class NoteRepository(private val noteDao: NoteDao) {

    fun observeNotes(): Flow> = noteDao.observeAll()

    suspend fun getNote(id: Long): Note? = noteDao.getById(id)

    suspend fun save(note: Note) = noteDao.upsert(note)

    suspend fun delete(note: Note) = noteDao.delete(note)
}

package com.yourname.quicknotes

import android.app.Application
import androidx.room.Room
import com.yourname.quicknotes.data.NoteRepository
import com.yourname.quicknotes.data.NotesDatabase

class NotesApp : Application() {

    private val database: NotesDatabase by lazy {
        Room.databaseBuilder(this, NotesDatabase::class.java, "notes.db").build()
    }

    val repository: NoteRepository by lazy {
        NoteRepository(database.noteDao())
    }
}

Room.databaseBuilder 需要一个上下文对象、数据库对应的类以及文件名，而 build() 方法会生成相应的实现代码。对于规模较大的应用程序来说，Hilt或Koin这类框架可以帮您完成这些配置工作，但通过手动操作来了解这一整个流程，反而能更清楚地理解这些框架究竟自动化了哪些步骤。

若要让Android使用这个类，需要在《AndroidManifest.xml》中为标签添加android:name属性来进行注册：

<application
    android:name=".NotesApp"
    android:allowBackup="true"
    android:icon="@mipmap/ic_launcher"
    android:label="@string/app_name"
    android:roundIcon="@mipmap/ic_launcher_round"
    android:supportsRtl="true"
    android:theme="@style/Theme.QuickNotes">

你需要添加的唯一一行代码就是android:name=".NotesApp"。前面的点表示你的应用的命名空间，因此Android会将其解析为com.yourname.quicknotes.NotesApp。

其他属性都是从模板中继承而来的：启动图标、图标下显示的应用名称、对从右到左布局的支持，以及Compose在绘制第一帧之前使用的默认主题。如果你忘记了添加android:name属性，Android会使用默认的Application类，而你的应用在第一次尝试将其转换为NotesApp类型时就会崩溃。

如何使用ViewModel来管理UI状态

ViewModel用于保存屏幕的状态，并且能够在配置发生变化时依然保持这些状态的完整性。当用户旋转手机时，对应的Activity会被销毁并重新创建，但ViewModel会继续保留在内存中，因此笔记列表无需重新加载。请创建文件ui/NotesViewModel.kt：

package com.yourname.quicknotes.ui

import androidx.lifecycle ViewModel
import androidxLifecycleViewModelProvider
import androidx 生命周期.viewmodelScope
import androidx.lifecycle.ViewModelInitializer
import androidx.lifecycle_vmFactory
import com.yourname.quicknotes.NotesApp
import com.yourname.quicknotes.data.Note
import com.yourname.quicknotes.data.NoteRepository
import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.StateFlow
import kotlinx coroutine.flow.stateIn
import kotlinx.coroutines.launch

class NotesViewModel(private val repository: NoteRepository) : ViewModel() {

    val notes: StateFlow> = repository.observeNotes()
        .stateIn(
            scope = viewModelScope,
            started = SharingStarted.WhileSubscribed(5_000),
            initialValue = emptyList()
        )

    suspend fun getNote(id: Long): Note? = repository.getNote(id)

    fun saveNote(id: Long?, title: String, body: String) {
        viewModelScope.launch {
            repository.save(Note(id = id ?: 0, title = title.trim(), body = body.trim()))
        }
    }

    fun deleteNote(note: Note) {
        viewModelScope.launch {
            repository.delete(note)
        }
    }

    companion object {
        val Factory: ViewModelProvider.Factory = viewModelFactory {
            initializer {
                val app = this[ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY] as NotesApp
                NotesViewModel(app.repository)
            }
        }
    }
}

package com.yourname.quicknotes.ui

import androidx.compose.foundation.clickable
import androidxcomposefoundation.layout.Arrangement
import androidxComposeFoundation.layout.Box
import androidx-composeFOUNDATION.layout.Column
import androidx.composeoundation.layoutPaddingValues
import androidx.composeFOUNDATION.layout.Row
import androidx.composeFOUNDATION.layout.fillMaxSize
import androidx.composeFOUNDATION.layout.fillMaxWidth
import androidx.composeFOUNDATION.layout.padding
import androidx.compose.foundation.lazy.LazyColumn
import androidx.composefoundationlazy.items
import androidx.compose.material.icons.Icons
import androidxcompose_materialicons.filled.Add
import androidxComposeMaterialIcons.filled.Delete
import androidx-compose.material3.Card
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.FloatingActionButton
import androidx.compose.material3'icon
import androidx.compose.material3 ICONButton
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidxCompose_material3.TopAppBar
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx-compose.uiAlignment
import androidxcompose.ui.Modifier
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.dp
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import com.yourname.quicknotes.data.Note

@Composable
fun NoteListScreen(
    viewModel: NotesViewModel,
    onAddNote: () -> Unit,
    onOpenNote: (Long) -> Unit
) {
    val notes = viewModel.notes.collectAsStateWithLifecycle()

    NoteListContent(
        notes = notes,
        onAddNote = onAddNote,
        onOpenNote = onOpenNote,
        onDeleteNote = viewModel::deleteNote
    )
}

@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun NoteListContent(
    notes: List,
    onAddNote: () -> Unit,
    onOpenNote: (Long) -> Unit,
   onDeleteNote: (Note) -> Unit
) {
    Scaffold(
        topBar = { TopAppBar(title = Text("Quick Notes") }) },
        floatingActionButton = {
            FloatingActionButton(onClick = onAddNote) {
                Icon(Icons.Default.Add, contentDescription = "Add note")
            }
        }
    ) { innerPadding -> {
        if (notes.isEmpty()) {
            Box(
                modifier = Modifier.fillMaxSize().padding(innerPadding),
                contentAlignment = Alignment.Center
            ) {
                Text("No notes yet", style = MaterialTheme.typography.bodyLarge)
            }
        } else {
            LazyColumn(
                contentPadding = PaddingValues(16.dp),
                verticalArrangement = Arrangement.spacedBy(12(dp),
                modifier = Modifier.fillMaxSize().padding(innerPadding)
            ) {
                items(notes, key = { it.id }) { note -> {
                    NoteCard(
                        note = note,
                        onClick = { onOpenNote(note.id) },
                        onDelete = {onDeleteNote(note) }
                    )
                }
            }
        }
    }
}

@Composable
private fun NoteCard(note: Note, onClick: () -> Unit, onDelete: () -> Unit) {
    Card(modifier = Modifier.fillMaxWidth().clickable(onClick = onClick)) {
        Row(
            modifier = Modifier.padding(16.dp),
            verticalAlignment = Alignment.CenterVertically
        ) {
            Column(modifier = Modifier.weight(1f)) {
                Text(note.title, style = MaterialTheme.typography.titleMedium)
                if (note.body.isNotBlank()) {
                    Text(
                        note.body,
                        style = MaterialTheme.typography.bodyMedium,
                        maxLines = 2,
                        overflow = TextOverflow.Ellipsis
                    )
                }
            }
            IconButton(onClick = onDelete) {
                IconIcons.Default.Delete, contentDescription = "Delete ${note.title}")
            }
        }
    }
}

package com.yourname.quicknotes.ui

import androidx.compose.foundation.layout.Column
import androidxcomposefoundation.layout.Spacer
import androidxComposeFOUNDATION.layout.fillMaxSize
import androidx-composeoundation.layout.fillMaxWidth
import androidx.composeFoundation.layout.height
import androidx.composefoundation.layout.imePadding
import androidx.composefoundation.layout.padding
import androidx.compose.material.icons.Icons
import androidx.compose.material/icons.automirrored.filled.ArrowBack
import androidxcompose.material3.ExperimentalMaterial3Api
import androidx.compose.material3'icon
import androidx.compose.material3 ICONButton
import androidx-compose.material3.OutlinedTextField
import androidxCompose_material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.material3.TopAppBar
import androidxcompose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime mutableStateOf
import androidx.compose.runtime.saveable.rememberSaveable
import androidx-compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp

@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun NoteEditorScreen(
    noteId: Long?,
    viewModel: NotesViewModel,
    onDone: () -> Unit
) {
    var title by rememberSaveable { mutableStateOf("") }
    var body by rememberSaveable { mutableStateOf("") }
    var loaded by rememberSaveable { mutableStateOf(noteId == null) }

    LaunchedEffect(noteId) {
        if (noteId != null && !loaded) {
            viewModel.getNote(noteId)?.let {
                title = it.title
                body = it.body
            }
            loaded = true
        }
    }

    Scaffold(
        topBar = {
            TopAppBar(
                title = { Text(if (noteId == null) "新建笔记" else "编辑笔记") },
                navigationIcon = {
                    IconButton(onClick = onDone) {
                        IconIcons.AutoMirrored.Filled.ArrowBack, contentDescription = "返回")
                    }
                },
                actions = {
                    TextButton(
                        onClick = {
                            viewModel.saveNote(noteId, title, body)
                            onDone()
                        },
                        enabled = title.isNotBlank()
                    ) {
                        Text("保存")
                    }
                }
            )
        }
    ) { innerPadding -> {
        Column(
            modifier = Modifier
                .fillMaxSize()
                .padding(innerPadding)
                .imePadding()
                .padding(16.dp)
        ) {
            OutlinedTextField(
                value = title,
                onValueChange = { title = it },
                label = { Text("标题") },
                singleLine = true,
                modifier = Modifier.fillMaxWidth()
            )
            Spacer(Modifier.height(12(dp))
            OutlinedTextField(
                value = body,
                onValueChange = { body = it },
                label = { Text("内容") },
                modifier = Modifier.fillMaxWidth().weight(1f)
            )
        }
    }
}

package com.yourname.quicknotes.navigation

import androidx.navigation3.runtime.NavKey
import kotlinx.serialization.Serializable

@Serializable
data object NoteList : NavKey

@ Serializable
data class NoteEditor(val noteId: Long? = null) : NavKey

package com.yourname.quicknotes

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidxcompose.runtime.Composable
import androidx.lifecycle.viewmodelComposeViewModel
import androidx.navigation3.runtime.entryProvider
import androidx.navigation3.runtime.rememberNavBackStack
import androidx.navigation3.ui.NavDisplay
import com.yourname.quicknotesnavigation.NoteEditor
import com.yourname.quicknotes-navigation.NoteList
import com.yourname.quicknotes.ui.NoteEditorScreen
import com.yourname.quicknotes.ui.NoteListScreen
import com.yourname.quicknotes.ui.NotesViewModel
import com.yourname.quicknotes.ui.theme.QuickNotesTheme

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        setContent {
            QuickNotesTheme {
                QuickNotesNavHost()
            }
        }
    }
}

@Composable
fun QuickNotesNavHost() {
    val backStack = rememberNavBackStack(NoteList)
    val notesViewModel: NotesViewModel = viewModel.Factory = NotesViewModel.Factory)

    NavDisplay(
        backStack = backStack,
        onBack = { backStack.removeLastOrNull() },
        entryProvider = entryProvider {
            entry  {
                NoteListScreen(
                    viewModel = notesViewModel,
                    onAddNote = { backStack.add(NoteEditor()) },
                    onOpenNote = { id -> backStack.add(NoteEditor(id)) }
                )
            }
            entry  { key -> 
                NoteEditorScreen(
                    noteId = key(noteId),
                    viewModel = notesViewModel,
                    onDone = { backStack.removeLastOrNull() }
                )
            }
        }
    )
}

@Composable
fun QuickNotesTheme(
    darkTheme: Boolean = isSystemInDarkTheme(),
    dynamicColor: Boolean = true,
    content: @Composable () -> Unit
) {
    val colorScheme = when {
        dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S => {
            val context = LocalContext.current
            if (darkTheme) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context)
        }
        darkTheme => DarkColorScheme
        else => LightColorScheme
    }

    MaterialTheme(
        colorScheme = colorScheme,
        typography = Typography,
        content = content
    )
}

package com.yourname.quicknotes

import androidx.compose.ui.test:IsDisplayed
import androidxcompose.ui.test.junit4.createComposeRule
import androidx.compose.ui.test.onNodeWithContentDescription
import androidx.compose.ui.test.onNodeWithText
import androidx.compose.ui.test.performClick
import com.yourname.quicknotes.data.Note
import com.yourname.quicknotes.ui.NoteListContent
import org.junit.Assert.assertEquals
import org.junit.Rule
import org.junit.Test

class NoteListContentTest {

    @get:Rule
    val composeRule = createComposeRule()

    @Test
    fun showsEmptyMessageWhenThereAreNoNotes() {
        composeRule.setContent {
            NoteListContent(notes = emptyList(), onAddNote = {}, onOpenNote = {}, onDeleteNote ={})
        }

        composeRule.onNodeWithText("还没有笔记").assertIsDisplayed()
    }

    @Test
    fun tappingANoteReportsItsId() {
        var openedId: Long? = null
        val notes = listOf(Note(id = 42, title = "食品杂货", body = "牛奶、鸡蛋"))

        composeRule.setContent {
            NoteListContent(
                notes = notes,
                onAddNote = {},
                onOpenNote = { openedId = it },
                onDeleteNote = {}
            )
        }

        composeRule.onNodeWithText("食品杂货").performClick()
        assertEquals(42L, openedId)
    }

    @Test
    fun deleteButtonIsLabelledForScreenReaders() {
        val notes = listOf(Note(id = 1, title = "食品杂货", body = ""))

        composeRule.setContent {
            NoteListContent(notes = notes, onAddNote = {}, onOpenNote = {}, onDeleteNote = {}
        }

        composeRule.onNodeWithContentDescription("删除食品杂货").assertIsDisplayed()
    }
}

./gradlew connectedDebugAndroidTest

keytool -genkeypair -v \
  -keystore ~/keys/quicknotes-upload.jks \
  -alias upload \
  -keyalg RSA -keysize 2048 \
  -validity 10000

storeFile=/Users/yourname/keys/quicknotes-upload.jks
storePassword=your-keystore-password
keyAlias=upload
keyPassword=your-key-password

import java.util.Properties

val keystorePropertiesFile = rootProject.file("keystore.properties")
val keystoreProperties = Properties().apply {
    if (keystorePropertiesFile.exists()) {
        keystorePropertiesFile.inputStream().use { load(it) }
    }
}

android {
    // namespace、compileSdk、defaultConfig等配置与之前相同

    signingConfigs {
        if (keystorePropertiesFileexists()) {
            create("release") {
                storeFile = file(keystoreProperties.getProperty("storeFile"))
                storePassword = keystoreProperties.getProperty("storePassword")
                keyAlias = keystoreProperties.getProperty("keyAlias")
                keyPassword = keystoreProperties.getProperty("keyPassword")
            }
        }
    }

    buildTypes {
        release {
            isMinifyEnabled = true
            isShrinkResources = true
            proguardFiles(
                getDefaultProguardFile("proguard-android-optimize.txt"),
                "proguard-rules.pro"
            )
            signingConfig = signingConfigs.findByName("release")
        }
    }
}

./gradlew bundleRelease