android-kotlin

Compare original and translation side by side

🇺🇸

Original

English

🇨🇳

Translation

Chinese

android-kotlin

Purpose

用途

This skill provides guidance on using Kotlin for Android development, focusing on key components like ViewModel for state management, LiveData or StateFlow for reactive data, coroutines with viewModelScope for asynchronous operations, Gradle KTS for build configuration, and KTX for Android extensions. It helps in building robust, maintainable Android apps.

本技能为使用Kotlin进行Android开发提供指导，重点讲解ViewModel（状态管理）、LiveData或StateFlow（响应式数据）、搭配viewModelScope的协程（异步操作）、Gradle KTS（构建配置）以及KTX（Android扩展）等核心组件。它有助于构建健壮、可维护的Android应用。

When to Use

适用场景

Use this skill when developing Android apps in Kotlin that require: managing UI state with ViewModel; handling asynchronous tasks like network calls using coroutines; observing data changes with LiveData or StateFlow; configuring projects via Gradle KTS; or simplifying code with KTX extensions. Apply it in scenarios involving activities, fragments, or services where lifecycle-aware components are needed.

当你使用Kotlin开发Android应用，且需要以下功能时可使用本技能：通过ViewModel管理UI状态；使用协程处理网络请求等异步任务；通过LiveData或StateFlow观察数据变化；通过Gradle KTS配置项目；或借助KTX扩展简化代码。适用于需要生命周期感知组件的Activity、Fragment或Service场景。

Key Capabilities

核心能力

ViewModel: Persists UI-related data across configuration changes; use
```
androidx.lifecycle.ViewModel
```
class.
LiveData/StateFlow: Observes data changes; LiveData integrates with lifecycle, StateFlow uses Kotlin flows for reactive programming.
Coroutines: Manage asynchronous code with
```
viewModelScope.launch {}
```
for scoped coroutines that cancel on ViewModel destruction.
Gradle KTS: Write build scripts in Kotlin script format for better type safety, e.g.,
```
build.gradle.kts
```
.
KTX: Provides extension functions for Android APIs, like
```
ContextCompat
```
from
```
androidx.core
```
.

ViewModel：在配置变更时保留UI相关数据；使用
```
androidx.lifecycle.ViewModel
```
类。
LiveData/StateFlow：观察数据变化；LiveData与生命周期集成，StateFlow使用Kotlin流实现响应式编程。
协程：通过
```
viewModelScope.launch {}
```
管理异步代码，这种作用域协程会在ViewModel销毁时自动取消。
Gradle KTS：以Kotlin脚本格式编写构建脚本，具备更好的类型安全性，例如
```
build.gradle.kts
```
。
KTX：为Android API提供扩展函数，如
```
androidx.core
```
中的
```
ContextCompat
```
。

Usage Patterns

使用模式

To implement MVVM architecture, create a ViewModel to hold data and business logic, then observe it in activities or fragments. For asynchronous operations, always launch coroutines within viewModelScope to avoid leaks. Use LiveData for simple observations or StateFlow for more advanced flows. When configuring Gradle, switch to KTS by renaming

build.gradle

build.gradle.kts

and updating syntax. Integrate KTX by adding dependencies in build.gradle.kts, e.g.,

implementation "androidx.core:core-ktx:1.7.0"

要实现MVVM架构，需创建ViewModel来存储数据和业务逻辑，然后在Activity或Fragment中观察它。对于异步操作，务必在viewModelScope内启动协程以避免内存泄漏。简单数据观察使用LiveData，更复杂的流场景使用StateFlow。配置Gradle时，将

build.gradle

重命名为

build.gradle.kts

并更新语法即可切换为KTS。通过在build.gradle.kts中添加依赖（例如

implementation "androidx.core:core-ktx:1.7.0"

）来集成KTX。

Common Commands/API

常用命令/API

Gradle commands: Run builds with
```
./gradlew build --stacktrace
```
for debugging; use
```
./gradlew assembleDebug
```
to build debug APK.

ViewModel API: Extend

ViewModel

class; example:

class MyViewModel : ViewModel() { val data = MutableLiveData<String>() }

Coroutines API: Import

kotlinx.coroutines

; use

viewModelScope.launch { delay(1000); data.value = "Updated" }

for delayed updates.

LiveData/StateFlow: Create with

val liveData = MutableLiveData<String>()

; or

val stateFlow = MutableStateFlow("")

KTX extensions: Use

requireContext().toast("Message")

from

androidx.fragment.app.Fragment

KTX for showing toasts.

Config formats: In build.gradle.kts, define dependencies as

dependencies { implementation("com.android.tools.build:gradle:7.0.0") }

; set API keys via environment variables like

buildConfigField "String", "API_KEY", "\"$SYSTEM_ENV_API_KEY\""

Gradle命令：运行
```
./gradlew build --stacktrace
```
进行调试构建；使用
```
./gradlew assembleDebug
```
构建调试版APK。

ViewModel API：继承

ViewModel

类；示例：

class MyViewModel : ViewModel() { val data = MutableLiveData<String>() }

。

协程API：导入

kotlinx.coroutines

；使用

viewModelScope.launch { delay(1000); data.value = "Updated" }

实现延迟更新。

LiveData/StateFlow：通过

val liveData = MutableLiveData<String>()

创建LiveData；或通过

val stateFlow = MutableStateFlow("")

创建StateFlow。

KTX扩展：使用

androidx.fragment.app.Fragment

KTX中的

requireContext().toast("Message")

显示提示框。

配置格式：在build.gradle.kts中，依赖定义为

dependencies { implementation("com.android.tools.build:gradle:7.0.0") }

；通过环境变量设置API密钥，例如

buildConfigField "String", "API_KEY", "\"$SYSTEM_ENV_API_KEY\""

。

Integration Notes

集成说明

To integrate ViewModel, add

androidx.lifecycle:lifecycle-viewmodel-ktx:2.4.0

to build.gradle.kts, then inject it using

ViewModelProvider(this).get(MyViewModel::class.java)

. For coroutines, include

org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.0

and ensure

viewModelScope

is used in ViewModel subclasses. When using StateFlow, combine with

lifecycleScope.launchWhenStarted { viewModel.stateFlow.collect { updateUI(it) } }

in fragments. For auth, handle API keys by setting them as environment variables (e.g.,

$ANDROID_API_KEY

) and accessing via

BuildConfig.API_KEY

. Ensure AndroidX compatibility by migrating from support libraries.

要集成ViewModel，需在build.gradle.kts中添加

androidx.lifecycle:lifecycle-viewmodel-ktx:2.4.0

依赖，然后通过

ViewModelProvider(this).get(MyViewModel::class.java)

注入。对于协程，需包含

org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.0

依赖，并确保在ViewModel子类中使用

viewModelScope

。使用StateFlow时，在Fragment中结合

lifecycleScope.launchWhenStarted { viewModel.stateFlow.collect { updateUI(it) } }

。处理身份验证时，将API密钥设置为环境变量（例如

$ANDROID_API_KEY

），并通过

BuildConfig.API_KEY

访问。通过迁移出支持库确保AndroidX兼容性。

Error Handling

错误处理

Handle exceptions in coroutines with try-catch blocks:

viewModelScope.launch { try { val result = apiCall() } catch (e: Exception) { data.value = "Error: ${e.message}" } }

. For LiveData, use

observe

with lifecycle owner and handle null values:

viewModel.data.observe(this) { if (it != null) updateUI(it) else showError() }

. In Gradle, debug builds with

--stacktrace

--debug

flags, e.g.,

./gradlew build --stacktrace

. Monitor StateFlow errors by wrapping emissions in try-catch during collection. Always check for null in KTX extensions, like

if (context != null) context.startActivity(intent)

在协程中使用try-catch块处理异常：

viewModelScope.launch { try { val result = apiCall() } catch (e: Exception) { data.value = "Error: ${e.message}" } }

。对于LiveData，结合生命周期所有者使用

observe

并处理空值：

viewModel.data.observe(this) { if (it != null) updateUI(it) else showError() }

。在Gradle中，使用

--stacktrace

或

--debug

标志调试构建，例如

./gradlew build --stacktrace

。在收集StateFlow数据时，通过try-catch包装发射操作来监控错误。始终检查KTX扩展中的空值，例如

if (context != null) context.startActivity(intent)

。

Concrete Usage Examples

具体使用示例

ViewModel with LiveData: Create a ViewModel for user data:

class UserViewModel : ViewModel() { val userData = MutableLiveData<String>() fun loadData() { userData.value = "Loaded" } }

. In an activity:

val viewModel: UserViewModel by viewModels(); viewModel.userData.observe(this) { textView.text = it }

. Call

viewModel.loadData()

on button click.

Coroutines in ViewModel: Fetch data asynchronously:

class DataViewModel : ViewModel() { fun fetchData() = viewModelScope.launch { val result = withContext(Dispatchers.IO) { apiService.getData() } data.value = result } }

. Observe in fragment:

viewModel.data.observe(viewLifecycleOwner) { if (it.isSuccess) showData(it) else handleError() }

搭配LiveData的ViewModel：创建用于用户数据的ViewModel：

class UserViewModel : ViewModel() { val userData = MutableLiveData<String>() fun loadData() { userData.value = "Loaded" } }

。在Activity中：

val viewModel: UserViewModel by viewModels(); viewModel.userData.observe(this) { textView.text = it }

。点击按钮时调用

viewModel.loadData()

。

ViewModel中的协程：异步获取数据：

class DataViewModel : ViewModel() { fun fetchData() = viewModelScope.launch { val result = withContext(Dispatchers.IO) { apiService.getData() } data.value = result } }

。在Fragment中观察：

viewModel.data.observe(viewLifecycleOwner) { if (it.isSuccess) showData(it) else handleError() }

。

Graph Relationships

关联关系

Related to: mobile cluster (as a sub-skill), kotlin-core skill (shares language base), android-core skill (overlaps on platform), viewmodel skill (direct dependency), coroutines skill (for async handling).
Connections: Integrates with mobile ecosystem; depends on kotlin for syntax; links to android for platform specifics; collaborates with viewmodel and coroutines tags for advanced features.

相关技能：移动技术集群（作为子技能）、kotlin-core技能（共享语言基础）、android-core技能（平台重叠）、viewmodel技能（直接依赖）、coroutines技能（异步处理）。
关联连接：与移动开发生态系统集成；依赖Kotlin语法；关联Android平台特性；与viewmodel和coroutines标签协作实现高级功能。