Android开发实战案例深度解析与常见问题解决方案

引言

Android开发是一个充满挑战与机遇的领域。随着技术的不断演进，开发者需要掌握从基础架构到高级优化的全方位技能。本文将通过几个典型的实战案例，深入解析Android开发中的核心技术和常见问题，并提供详细的解决方案。无论你是初学者还是有经验的开发者，都能从中获得实用的指导。

案例一：使用Jetpack Compose构建现代UI

背景与需求

Jetpack Compose是Google推出的现代Android UI工具包，它使用声明式语法，简化了UI开发流程。本案例将展示如何使用Compose构建一个动态的待办事项列表应用。

实现步骤

1. 环境配置：确保Android Studio版本在4.2以上，并在build.gradle中添加Compose依赖。
2. 创建数据模型：定义一个简单的TodoItem类。
3. 构建UI组件：使用Compose的Column、Row和TextField等组件构建界面。
4. 状态管理：使用remember和mutableStateOf管理UI状态。
5. 事件处理：处理添加、删除和完成待办事项的事件。

代码示例

// TodoItem.kt
data class TodoItem(val id: Int, val text: String, val isCompleted: Boolean = false)

// MainActivity.kt
class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            TodoApp()
        }
    }
}

@Composable
fun TodoApp() {
    var todoItems by remember { mutableStateOf(listOf<TodoItem>()) }
    var text by remember { mutableStateOf("") }

    Column(modifier = Modifier.padding(16.dp)) {
        TextField(
            value = text,
            onValueChange = { text = it },
            label = { Text("Add a new todo") },
            modifier = Modifier.fillMaxWidth()
        )
        Button(
            onClick = {
                if (text.isNotBlank()) {
                    todoItems = todoItems + TodoItem(todoItems.size + 1, text)
                    text = ""
                }
            },
            modifier = Modifier.fillMaxWidth().padding(top = 8.dp)
        ) {
            Text("Add")
        }
        LazyColumn(modifier = Modifier.fillMaxWidth().padding(top = 16.dp)) {
            items(todoItems) { item ->
                TodoRow(item, onToggle = {
                    todoItems = todoItems.map { if (it.id == item.id) it.copy(isCompleted = !it.isCompleted) else it }
                }, onDelete = {
                    todoItems = todoItems.filter { it.id != item.id }
                })
            }
        }
    }
}

@Composable
fun TodoRow(item: TodoItem, onToggle: () -> Unit, onDelete: () -> Unit) {
    Row(
        modifier = Modifier
            .fillMaxWidth()
            .padding(vertical = 4.dp),
        verticalAlignment = Alignment.CenterVertically
    ) {
        Checkbox(
            checked = item.isCompleted,
            onCheckedChange = { onToggle() }
        )
        Text(
            text = item.text,
            modifier = Modifier.weight(1f),
            textDecoration = if (item.isCompleted) TextDecoration.LineThrough else null
        )
        IconButton(onClick = onDelete) {
            Icon(Icons.Default.Delete, contentDescription = "Delete")
        }
    }
}

常见问题与解决方案

1. 问题：Compose中状态更新不触发UI重绘。

   • 解决方案：确保使用remember和mutableStateOf正确管理状态。避免在Composable函数中使用非Compose状态管理库（如LiveData），除非通过observeAsState转换。

2. 问题：列表项频繁更新导致性能问题。

   • 解决方案：使用key参数为LazyColumn的items指定稳定键，例如items(todoItems, key = { it.id })，以避免不必要的重组。

案例二：使用Retrofit与Coroutines进行网络请求

背景与需求

网络请求是Android应用的核心功能之一。本案例将展示如何使用Retrofit结合Kotlin Coroutines进行高效的异步网络请求。

实现步骤

1. 添加依赖：在build.gradle中添加Retrofit、Gson和Coroutines依赖。
2. 定义API接口：使用Retrofit的注解定义网络请求。
3. 创建Retrofit实例：配置Base URL和转换器。
4. 发起请求：在ViewModel中使用协程发起请求，并处理结果。
5. 错误处理：使用try-catch或Result类型处理网络错误。

代码示例

// build.gradle (Module)
dependencies {
    implementation 'com.squareup.retrofit2:retrofit:2.9.0'
    implementation 'com.squareup.retrofit2:converter-gson:2.9.0'
    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.0'
    implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.5.1'
}

// ApiService.kt
interface ApiService {
    @GET("todos/{id}")
    suspend fun getTodoById(@Path("id") id: Int): Response<TodoItem>
}

// RetrofitClient.kt
object RetrofitClient {
    private const val BASE_URL = "https://jsonplaceholder.typicode.com/"
    
    val instance: ApiService by lazy {
        Retrofit.Builder()
            .baseUrl(BASE_URL)
            .addConverterFactory(GsonConverterFactory.create())
            .build()
            .create(ApiService::class.java)
    }
}

// TodoViewModel.kt
class TodoViewModel : ViewModel() {
    private val _todoState = MutableStateFlow<TodoItem?>(null)
    val todoState: StateFlow<TodoItem?> = _todoState
    
    fun fetchTodo(id: Int) {
        viewModelScope.launch {
            try {
                val response = RetrofitClient.instance.getTodoById(id)
                if (response.isSuccessful) {
                    _todoState.value = response.body()
                } else {
                    // Handle error
                    _todoState.value = null
                }
            } catch (e: Exception) {
                // Handle exception
                _todoState.value = null
            }
        }
    }
}

// MainActivity.kt (简化)
class MainActivity : ComponentActivity() {
    private val viewModel: TodoViewModel by viewModels()
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            val todo by viewModel.todoState.collectAsState()
            // UI to display todo
        }
    }
}

常见问题与解决方案

1. 问题：网络请求在后台线程执行，但UI更新需要在主线程。

   • 解决方案：使用Dispatchers.Main确保UI更新在主线程。例如，在ViewModel中使用viewModelScope.launch(Dispatchers.Main)，但通常协程默认在主线程，除非指定了其他调度器。

2. 问题：内存泄漏，例如在Activity中启动协程而未取消。

   • 解决方案：使用viewModelScope或lifecycleScope，它们会自动在生命周期结束时取消协程。避免在非生命周期感知的类中启动协程。

案例三：使用Room数据库进行本地数据存储

背景与需求

本地数据存储是应用持久化数据的关键。本案例将展示如何使用Room数据库存储和查询待办事项。

实现步骤

1. 添加依赖：在build.gradle中添加Room依赖。
2. 定义实体类：使用@Entity注解定义数据表。
3. 定义DAO接口：使用@Dao注解定义数据访问操作。
4. 定义数据库类：使用@Database注解创建Room数据库。
5. 在ViewModel中使用：通过Repository模式访问数据库。

代码示例

// build.gradle (Module)
dependencies {
    implementation 'androidx.room:room-runtime:2.4.3'
    implementation 'androidx.room:room-ktx:2.4.3'
    kapt 'androidx.room:room-compiler:2.4.3'
}

// TodoEntity.kt
@Entity(tableName = "todos")
data class TodoEntity(
    @PrimaryKey(autoGenerate = true) val id: Int = 0,
    val text: String,
    val isCompleted: Boolean = false
)

// TodoDao.kt
@Dao
interface TodoDao {
    @Query("SELECT * FROM todos")
    fun getAll(): Flow<List<TodoEntity>>
    
    @Insert(onConflict = OnConflictStrategy.REPLACE)
    suspend fun insert(todo: TodoEntity)
    
    @Update
    suspend fun update(todo: TodoEntity)
    
    @Delete
    suspend fun delete(todo: TodoEntity)
}

// TodoDatabase.kt
@Database(entities = [TodoEntity::class], version = 1)
abstract class TodoDatabase : RoomDatabase() {
    abstract fun todoDao(): TodoDao
    
    companion object {
        @Volatile
        private var INSTANCE: TodoDatabase? = null
        
        fun getDatabase(context: Context): TodoDatabase {
            return INSTANCE ?: synchronized(this) {
                val instance = Room.databaseBuilder(
                    context.applicationContext,
                    TodoDatabase::class.java,
                    "todo_database"
                ).build()
                INSTANCE = instance
                instance
            }
        }
    }
}

// TodoRepository.kt
class TodoRepository(private val todoDao: TodoDao) {
    val allTodos: Flow<List<TodoEntity>> = todoDao.getAll()
    
    suspend fun insert(todo: TodoEntity) {
        todoDao.insert(todo)
    }
    
    suspend fun update(todo: TodoEntity) {
        todoDao.update(todo)
    }
    
    suspend fun delete(todo: TodoEntity) {
        todoDao.delete(todo)
    }
}

// TodoViewModel.kt (扩展)
class TodoViewModel(application: Application) : AndroidViewModel(application) {
    private val repository: TodoRepository
    val allTodos: Flow<List<TodoEntity>>
    
    init {
        val todoDao = TodoDatabase.getDatabase(application).todoDao()
        repository = TodoRepository(todoDao)
        allTodos = repository.allTodos
    }
    
    fun insert(todo: TodoEntity) = viewModelScope.launch {
        repository.insert(todo)
    }
    
    fun update(todo: TodoEntity) = viewModelScope.launch {
        repository.update(todo)
    }
    
    fun delete(todo: TodoEntity) = viewModelScope.launch {
        repository.delete(todo)
    }
}

常见问题与解决方案

1. 问题：数据库操作在主线程执行导致ANR。

   • 解决方案：Room的DAO方法默认在后台线程执行，但确保在ViewModel中使用协程（viewModelScope.launch）来调用这些方法，避免在主线程直接调用。

2. 问题：数据库迁移问题，当实体类结构改变时。

   • 解决方案：使用Room的迁移机制。例如，添加一个新字段时，创建Migration对象并指定版本号，然后在数据库构建时添加迁移。

   ”`kotlin val MIGRATION_1_2 = object : Migration(1, 2) { override fun migrate(database: SupportSQLiteDatabase) {

      database.execSQL("ALTER TABLE todos ADD COLUMN priority INTEGER DEFAULT 0")
   

   } }

Room.databaseBuilder(context, TodoDatabase::class.java, “todo_database”)

   .addMigrations(MIGRATION_1_2)
   .build()

## 案例四：使用WorkManager进行后台任务调度

### 背景与需求
后台任务调度对于同步数据、发送通知等场景至关重要。本案例将展示如何使用WorkManager定期同步待办事项。

### 实现步骤
1. **添加依赖**：在`build.gradle`中添加WorkManager依赖。
2. **定义Worker类**：继承`CoroutineWorker`并实现`doWork`方法。
3. **配置工作请求**：设置约束条件（如网络可用、充电状态）和调度策略（如周期性任务）。
4. **调度工作**：使用`WorkManager`调度任务。
5. **观察工作状态**：通过`WorkManager`的`getWorkInfoByIdLiveData`或`getWorkInfoByIdFlow`观察任务状态。

### 代码示例
```kotlin
// build.gradle (Module)
dependencies {
    implementation 'androidx.work:work-runtime-ktx:2.7.1'
}

// SyncTodosWorker.kt
class SyncTodosWorker(appContext: Context, params: WorkerParameters) : CoroutineWorker(appContext, params) {
    override suspend fun doWork(): Result {
        return try {
            // 模拟网络请求
            delay(2000)
            // 同步逻辑，例如从服务器获取数据并存入Room数据库
            Result.success()
        } catch (e: Exception) {
            Result.failure()
        }
    }
}

// MainActivity.kt (调度任务)
class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        // 定义约束条件
        val constraints = Constraints.Builder()
            .setRequiredNetworkType(NetworkType.CONNECTED)
            .setRequiresCharging(true)
            .build()
        
        // 创建周期性工作请求（最小间隔15分钟）
        val syncRequest = PeriodicWorkRequestBuilder<SyncTodosWorker>(15, TimeUnit.MINUTES)
            .setConstraints(constraints)
            .build()
        
        // 调度工作
        WorkManager.getInstance(this).enqueueUniquePeriodicWork(
            "sync_todos",
            ExistingPeriodicWorkPolicy.KEEP,
            syncRequest
        )
        
        // 观察工作状态
        WorkManager.getInstance(this).getWorkInfoByIdLiveData(syncRequest.id)
            .observe(this) { workInfo ->
                when (workInfo?.state) {
                    WorkInfo.State.SUCCEEDED -> {
                        // 处理成功
                    }
                    WorkInfo.State.FAILED -> {
                        // 处理失败
                    }
                    else -> {}
                }
            }
    }
}

常见问题与解决方案

1. 问题：周期性任务的最小间隔是15分钟，无法更频繁。

   • 解决方案：如果需要更频繁的任务，可以考虑使用OneTimeWorkRequest并结合WorkManager的链式调度，或者使用其他后台任务调度方案（如AlarmManager），但需注意电池优化限制。

2. 问题：任务在设备重启后丢失。

   • 解决方案：WorkManager默认支持设备重启后的任务恢复。确保使用enqueueUniquePeriodicWork或enqueueUniqueOneTimeWork，并指定唯一的工作名称，这样WorkManager会自动处理重启后的任务调度。

案例五：使用Hilt进行依赖注入

背景与需求

依赖注入（DI）可以提高代码的可测试性和可维护性。本案例将展示如何使用Hilt在Android应用中管理依赖。

实现步骤

1. 添加依赖：在build.gradle中添加Hilt依赖。
2. 配置Hilt：在应用类中添加@HiltAndroidApp注解。
3. 定义模块：使用@Module和@Provides定义依赖提供方式。
4. 注入依赖：使用@Inject注解在类中注入依赖。
5. 作用域管理：使用@Singleton、@ActivityScoped等注解管理依赖的生命周期。

代码示例

// build.gradle (Module)
dependencies {
    implementation 'com.google.dagger:hilt-android:2.43'
    kapt 'com.google.dagger:hilt-compiler:2.43'
}

// MyApplication.kt
@HiltAndroidApp
class MyApplication : Application()

// NetworkModule.kt
@Module
@InstallIn(SingletonComponent::class)
object NetworkModule {
    @Provides
    @Singleton
    fun provideApiService(): ApiService {
        return Retrofit.Builder()
            .baseUrl("https://jsonplaceholder.typicode.com/")
            .addConverterFactory(GsonConverterFactory.create())
            .build()
            .create(ApiService::class.java)
    }
}

// TodoRepository.kt
class TodoRepository @Inject constructor(
    private val apiService: ApiService,
    private val todoDao: TodoDao
) {
    // Repository logic
}

// TodoViewModel.kt
@HiltViewModel
class TodoViewModel @Inject constructor(
    private val repository: TodoRepository
) : ViewModel() {
    // ViewModel logic
}

// MainActivity.kt
@AndroidEntryPoint
class MainActivity : ComponentActivity() {
    @Inject lateinit var viewModel: TodoViewModel
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // 使用viewModel
    }
}

常见问题与解决方案

1. 问题：Hilt无法注入某些类，例如Android框架类（如Context）。

   • 解决方案：使用Hilt的@ApplicationContext或@ActivityContext注解。例如，在模块中提供Context：

   @Module
   @InstallIn(SingletonComponent::class)
   object AppModule {
      @Provides
      @Singleton
      @ApplicationContext
      fun provideContext(application: Application): Context = application
   }
   

2. 问题：依赖注入导致循环依赖。

   • 解决方案：重新设计类结构，避免循环依赖。如果确实需要，可以使用Lazy<T>或Provider<T>来延迟注入。例如：

   class ClassA @Inject constructor(private val classBLazy: Lazy<ClassB>)
   

总结

本文通过五个实战案例，深入解析了Android开发中的关键技术，包括Jetpack Compose、Retrofit、Room、WorkManager和Hilt。每个案例都提供了详细的实现步骤、代码示例和常见问题解决方案。希望这些内容能帮助你更好地理解和应用Android开发的最佳实践，提升开发效率和应用质量。

在实际开发中，遇到问题时，建议先查阅官方文档，然后结合社区资源（如Stack Overflow、GitHub Issues）寻找解决方案。同时，保持代码的模块化和可测试性，使用现代架构（如MVVM、MVI）和工具（如Compose、Coroutines）来构建健壮的应用。祝你开发顺利！# Android开发实战案例深度解析与常见问题解决方案

引言

Android开发是一个充满挑战与机遇的领域。随着技术的不断演进，开发者需要掌握从基础架构到高级优化的全方位技能。本文将通过几个典型的实战案例，深入解析Android开发中的核心技术和常见问题，并提供详细的解决方案。无论你是初学者还是有经验的开发者，都能从中获得实用的指导。

案例一：使用Jetpack Compose构建现代UI

背景与需求

Jetpack Compose是Google推出的现代Android UI工具包，它使用声明式语法，简化了UI开发流程。本案例将展示如何使用Compose构建一个动态的待办事项列表应用。

实现步骤

1. 环境配置：确保Android Studio版本在4.2以上，并在build.gradle中添加Compose依赖。
2. 创建数据模型：定义一个简单的TodoItem类。
3. 构建UI组件：使用Compose的Column、Row和TextField等组件构建界面。
4. 状态管理：使用remember和mutableStateOf管理UI状态。
5. 事件处理：处理添加、删除和完成待办事项的事件。

代码示例

// TodoItem.kt
data class TodoItem(val id: Int, val text: String, val isCompleted: Boolean = false)

// MainActivity.kt
class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            TodoApp()
        }
    }
}

@Composable
fun TodoApp() {
    var todoItems by remember { mutableStateOf(listOf<TodoItem>()) }
    var text by remember { mutableStateOf("") }

    Column(modifier = Modifier.padding(16.dp)) {
        TextField(
            value = text,
            onValueChange = { text = it },
            label = { Text("Add a new todo") },
            modifier = Modifier.fillMaxWidth()
        )
        Button(
            onClick = {
                if (text.isNotBlank()) {
                    todoItems = todoItems + TodoItem(todoItems.size + 1, text)
                    text = ""
                }
            },
            modifier = Modifier.fillMaxWidth().padding(top = 8.dp)
        ) {
            Text("Add")
        }
        LazyColumn(modifier = Modifier.fillMaxWidth().padding(top = 16.dp)) {
            items(todoItems) { item ->
                TodoRow(item, onToggle = {
                    todoItems = todoItems.map { if (it.id == item.id) it.copy(isCompleted = !it.isCompleted) else it }
                }, onDelete = {
                    todoItems = todoItems.filter { it.id != item.id }
                })
            }
        }
    }
}

@Composable
fun TodoRow(item: TodoItem, onToggle: () -> Unit, onDelete: () -> Unit) {
    Row(
        modifier = Modifier
            .fillMaxWidth()
            .padding(vertical = 4.dp),
        verticalAlignment = Alignment.CenterVertically
    ) {
        Checkbox(
            checked = item.isCompleted,
            onCheckedChange = { onToggle() }
        )
        Text(
            text = item.text,
            modifier = Modifier.weight(1f),
            textDecoration = if (item.isCompleted) TextDecoration.LineThrough else null
        )
        IconButton(onClick = onDelete) {
            Icon(Icons.Default.Delete, contentDescription = "Delete")
        }
    }
}

常见问题与解决方案

1. 问题：Compose中状态更新不触发UI重绘。

   • 解决方案：确保使用remember和mutableStateOf正确管理状态。避免在Composable函数中使用非Compose状态管理库（如LiveData），除非通过observeAsState转换。

2. 问题：列表项频繁更新导致性能问题。

   • 解决方案：使用key参数为LazyColumn的items指定稳定键，例如items(todoItems, key = { it.id })，以避免不必要的重组。

案例二：使用Retrofit与Coroutines进行网络请求

背景与需求

网络请求是Android应用的核心功能之一。本案例将展示如何使用Retrofit结合Kotlin Coroutines进行高效的异步网络请求。

实现步骤

1. 添加依赖：在build.gradle中添加Retrofit、Gson和Coroutines依赖。
2. 定义API接口：使用Retrofit的注解定义网络请求。
3. 创建Retrofit实例：配置Base URL和转换器。
4. 发起请求：在ViewModel中使用协程发起请求，并处理结果。
5. 错误处理：使用try-catch或Result类型处理网络错误。

代码示例

// build.gradle (Module)
dependencies {
    implementation 'com.squareup.retrofit2:retrofit:2.9.0'
    implementation 'com.squareup.retrofit2:converter-gson:2.9.0'
    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.0'
    implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.5.1'
}

// ApiService.kt
interface ApiService {
    @GET("todos/{id}")
    suspend fun getTodoById(@Path("id") id: Int): Response<TodoItem>
}

// RetrofitClient.kt
object RetrofitClient {
    private const val BASE_URL = "https://jsonplaceholder.typicode.com/"
    
    val instance: ApiService by lazy {
        Retrofit.Builder()
            .baseUrl(BASE_URL)
            .addConverterFactory(GsonConverterFactory.create())
            .build()
            .create(ApiService::class.java)
    }
}

// TodoViewModel.kt
class TodoViewModel : ViewModel() {
    private val _todoState = MutableStateFlow<TodoItem?>(null)
    val todoState: StateFlow<TodoItem?> = _todoState
    
    fun fetchTodo(id: Int) {
        viewModelScope.launch {
            try {
                val response = RetrofitClient.instance.getTodoById(id)
                if (response.isSuccessful) {
                    _todoState.value = response.body()
                } else {
                    // Handle error
                    _todoState.value = null
                }
            } catch (e: Exception) {
                // Handle exception
                _todoState.value = null
            }
        }
    }
}

// MainActivity.kt (简化)
class MainActivity : ComponentActivity() {
    private val viewModel: TodoViewModel by viewModels()
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            val todo by viewModel.todoState.collectAsState()
            // UI to display todo
        }
    }
}

常见问题与解决方案

1. 问题：网络请求在后台线程执行，但UI更新需要在主线程。

   • 解决方案：使用Dispatchers.Main确保UI更新在主线程。例如，在ViewModel中使用viewModelScope.launch(Dispatchers.Main)，但通常协程默认在主线程，除非指定了其他调度器。

2. 问题：内存泄漏，例如在Activity中启动协程而未取消。

   • 解决方案：使用viewModelScope或lifecycleScope，它们会自动在生命周期结束时取消协程。避免在非生命周期感知的类中启动协程。

案例三：使用Room数据库进行本地数据存储

背景与需求

本地数据存储是应用持久化数据的关键。本案例将展示如何使用Room数据库存储和查询待办事项。

实现步骤

1. 添加依赖：在build.gradle中添加Room依赖。
2. 定义实体类：使用@Entity注解定义数据表。
3. 定义DAO接口：使用@Dao注解定义数据访问操作。
4. 定义数据库类：使用@Database注解创建Room数据库。
5. 在ViewModel中使用：通过Repository模式访问数据库。

代码示例

// build.gradle (Module)
dependencies {
    implementation 'androidx.room:room-runtime:2.4.3'
    implementation 'androidx.room:room-ktx:2.4.3'
    kapt 'androidx.room:room-compiler:2.4.3'
}

// TodoEntity.kt
@Entity(tableName = "todos")
data class TodoEntity(
    @PrimaryKey(autoGenerate = true) val id: Int = 0,
    val text: String,
    val isCompleted: Boolean = false
)

// TodoDao.kt
@Dao
interface TodoDao {
    @Query("SELECT * FROM todos")
    fun getAll(): Flow<List<TodoEntity>>
    
    @Insert(onConflict = OnConflictStrategy.REPLACE)
    suspend fun insert(todo: TodoEntity)
    
    @Update
    suspend fun update(todo: TodoEntity)
    
    @Delete
    suspend fun delete(todo: TodoEntity)
}

// TodoDatabase.kt
@Database(entities = [TodoEntity::class], version = 1)
abstract class TodoDatabase : RoomDatabase() {
    abstract fun todoDao(): TodoDao
    
    companion object {
        @Volatile
        private var INSTANCE: TodoDatabase? = null
        
        fun getDatabase(context: Context): TodoDatabase {
            return INSTANCE ?: synchronized(this) {
                val instance = Room.databaseBuilder(
                    context.applicationContext,
                    TodoDatabase::class.java,
                    "todo_database"
                ).build()
                INSTANCE = instance
                instance
            }
        }
    }
}

// TodoRepository.kt
class TodoRepository(private val todoDao: TodoDao) {
    val allTodos: Flow<List<TodoEntity>> = todoDao.getAll()
    
    suspend fun insert(todo: TodoEntity) {
        todoDao.insert(todo)
    }
    
    suspend fun update(todo: TodoEntity) {
        todoDao.update(todo)
    }
    
    suspend fun delete(todo: TodoEntity) {
        todoDao.delete(todo)
    }
}

// TodoViewModel.kt (扩展)
class TodoViewModel(application: Application) : AndroidViewModel(application) {
    private val repository: TodoRepository
    val allTodos: Flow<List<TodoEntity>>
    
    init {
        val todoDao = TodoDatabase.getDatabase(application).todoDao()
        repository = TodoRepository(todoDao)
        allTodos = repository.allTodos
    }
    
    fun insert(todo: TodoEntity) = viewModelScope.launch {
        repository.insert(todo)
    }
    
    fun update(todo: TodoEntity) = viewModelScope.launch {
        repository.update(todo)
    }
    
    fun delete(todo: TodoEntity) = viewModelScope.launch {
        repository.delete(todo)
    }
}

常见问题与解决方案

1. 问题：数据库操作在主线程执行导致ANR。

   • 解决方案：Room的DAO方法默认在后台线程执行，但确保在ViewModel中使用协程（viewModelScope.launch）来调用这些方法，避免在主线程直接调用。

2. 问题：数据库迁移问题，当实体类结构改变时。

   • 解决方案：使用Room的迁移机制。例如，添加一个新字段时，创建Migration对象并指定版本号，然后在数据库构建时添加迁移。

   ”`kotlin val MIGRATION_1_2 = object : Migration(1, 2) { override fun migrate(database: SupportSQLiteDatabase) {

      database.execSQL("ALTER TABLE todos ADD COLUMN priority INTEGER DEFAULT 0")
   

   } }

Room.databaseBuilder(context, TodoDatabase::class.java, “todo_database”)

   .addMigrations(MIGRATION_1_2)
   .build()

## 案例四：使用WorkManager进行后台任务调度

### 背景与需求
后台任务调度对于同步数据、发送通知等场景至关重要。本案例将展示如何使用WorkManager定期同步待办事项。

### 实现步骤
1. **添加依赖**：在`build.gradle`中添加WorkManager依赖。
2. **定义Worker类**：继承`CoroutineWorker`并实现`doWork`方法。
3. **配置工作请求**：设置约束条件（如网络可用、充电状态）和调度策略（如周期性任务）。
4. **调度工作**：使用`WorkManager`调度任务。
5. **观察工作状态**：通过`WorkManager`的`getWorkInfoByIdLiveData`或`getWorkInfoByIdFlow`观察任务状态。

### 代码示例
```kotlin
// build.gradle (Module)
dependencies {
    implementation 'androidx.work:work-runtime-ktx:2.7.1'
}

// SyncTodosWorker.kt
class SyncTodosWorker(appContext: Context, params: WorkerParameters) : CoroutineWorker(appContext, params) {
    override suspend fun doWork(): Result {
        return try {
            // 模拟网络请求
            delay(2000)
            // 同步逻辑，例如从服务器获取数据并存入Room数据库
            Result.success()
        } catch (e: Exception) {
            Result.failure()
        }
    }
}

// MainActivity.kt (调度任务)
class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        // 定义约束条件
        val constraints = Constraints.Builder()
            .setRequiredNetworkType(NetworkType.CONNECTED)
            .setRequiresCharging(true)
            .build()
        
        // 创建周期性工作请求（最小间隔15分钟）
        val syncRequest = PeriodicWorkRequestBuilder<SyncTodosWorker>(15, TimeUnit.MINUTES)
            .setConstraints(constraints)
            .build()
        
        // 调度工作
        WorkManager.getInstance(this).enqueueUniquePeriodicWork(
            "sync_todos",
            ExistingPeriodicWorkPolicy.KEEP,
            syncRequest
        )
        
        // 观察工作状态
        WorkManager.getInstance(this).getWorkInfoByIdLiveData(syncRequest.id)
            .observe(this) { workInfo ->
                when (workInfo?.state) {
                    WorkInfo.State.SUCCEEDED -> {
                        // 处理成功
                    }
                    WorkInfo.State.FAILED -> {
                        // 处理失败
                    }
                    else -> {}
                }
            }
    }
}

常见问题与解决方案

1. 问题：周期性任务的最小间隔是15分钟，无法更频繁。

   • 解决方案：如果需要更频繁的任务，可以考虑使用OneTimeWorkRequest并结合WorkManager的链式调度，或者使用其他后台任务调度方案（如AlarmManager），但需注意电池优化限制。

2. 问题：任务在设备重启后丢失。

   • 解决方案：WorkManager默认支持设备重启后的任务恢复。确保使用enqueueUniquePeriodicWork或enqueueUniqueOneTimeWork，并指定唯一的工作名称，这样WorkManager会自动处理重启后的任务调度。

案例五：使用Hilt进行依赖注入

背景与需求

依赖注入（DI）可以提高代码的可测试性和可维护性。本案例将展示如何使用Hilt在Android应用中管理依赖。

实现步骤

1. 添加依赖：在build.gradle中添加Hilt依赖。
2. 配置Hilt：在应用类中添加@HiltAndroidApp注解。
3. 定义模块：使用@Module和@Provides定义依赖提供方式。
4. 注入依赖：使用@Inject注解在类中注入依赖。
5. 作用域管理：使用@Singleton、@ActivityScoped等注解管理依赖的生命周期。

代码示例

// build.gradle (Module)
dependencies {
    implementation 'com.google.dagger:hilt-android:2.43'
    kapt 'com.google.dagger:hilt-compiler:2.43'
}

// MyApplication.kt
@HiltAndroidApp
class MyApplication : Application()

// NetworkModule.kt
@Module
@InstallIn(SingletonComponent::class)
object NetworkModule {
    @Provides
    @Singleton
    fun provideApiService(): ApiService {
        return Retrofit.Builder()
            .baseUrl("https://jsonplaceholder.typicode.com/")
            .addConverterFactory(GsonConverterFactory.create())
            .build()
            .create(ApiService::class.java)
    }
}

// TodoRepository.kt
class TodoRepository @Inject constructor(
    private val apiService: ApiService,
    private val todoDao: TodoDao
) {
    // Repository logic
}

// TodoViewModel.kt
@HiltViewModel
class TodoViewModel @Inject constructor(
    private val repository: TodoRepository
) : ViewModel() {
    // ViewModel logic
}

// MainActivity.kt
@AndroidEntryPoint
class MainActivity : ComponentActivity() {
    @Inject lateinit var viewModel: TodoViewModel
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // 使用viewModel
    }
}

常见问题与解决方案

1. 问题：Hilt无法注入某些类，例如Android框架类（如Context）。

   • 解决方案：使用Hilt的@ApplicationContext或@ActivityContext注解。例如，在模块中提供Context：

   @Module
   @InstallIn(SingletonComponent::class)
   object AppModule {
      @Provides
      @Singleton
      @ApplicationContext
      fun provideContext(application: Application): Context = application
   }
   

2. 问题：依赖注入导致循环依赖。

   • 解决方案：重新设计类结构，避免循环依赖。如果确实需要，可以使用Lazy<T>或Provider<T>来延迟注入。例如：

   class ClassA @Inject constructor(private val classBLazy: Lazy<ClassB>)
   

总结

本文通过五个实战案例，深入解析了Android开发中的关键技术，包括Jetpack Compose、Retrofit、Room、WorkManager和Hilt。每个案例都提供了详细的实现步骤、代码示例和常见问题解决方案。希望这些内容能帮助你更好地理解和应用Android开发的最佳实践，提升开发效率和应用质量。

在实际开发中，遇到问题时，建议先查阅官方文档，然后结合社区资源（如Stack Overflow、GitHub Issues）寻找解决方案。同时，保持代码的模块化和可测试性，使用现代架构（如MVVM、MVI）和工具（如Compose、Coroutines）来构建健壮的应用。祝你开发顺利！