Android开发Kotlin协程实战指南：从入门到解决实际问题

// 传统Thread+Handler方式
Thread {
    val user = api.getUserInfo() // 网络请求（耗时）
    runOnUiThread {
        tv_user.text = user.name // 更新UI
    }
}.start()

// 协程方式
lifecycleScope.launch {
    val cache = withContext(Dispatchers.IO) { getCache() } // 读缓存（IO线程）
    val user = withContext(Dispatchers.IO) { api.getUserInfo() } // 网络请求（IO线程）
    tv_user.text = user.name // 直接更新UI（主线程）
}

dependencies {
    // 协程核心库
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3")
    // Android专属支持（绑定生命周期、主线程调度器）
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3")
}

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // 用lifecycleScope启动协程（自动绑定Activity生命周期）
        lifecycleScope.launch {
            Log.d("Coroutine", "协程启动了：${Thread.currentThread().name}")
            delay(1000) // 模拟耗时操作（不会阻塞主线程！）
            Log.d("Coroutine", "协程完成了：${Thread.currentThread().name}")
        }
    }
}

lifecycleScope.launch {
    // 1. 切换到IO线程做网络请求（耗时操作）
    val user = withContext(Dispatchers.IO) {
        api.getUserInfo() // 假设api.getUserInfo()是网络请求
    }
    // 2. 自动切回Main线程，更新UI
    tv_user.text = user.name
}

viewModelScope.launch {
    // 1. 启动两个并发任务（都在IO线程）
    val userDeferred = async(Dispatchers.IO) { api.getUserInfo() }
    val ordersDeferred = async(Dispatchers.IO) { api.getOrders() }

    // 2. 等待两个任务完成（不会阻塞线程）
    val user = userDeferred.await()
    val orders = ordersDeferred.await()

    // 3. 合并结果更新UI
    _uiState.value = UiState.Success(user, orders)
}

// 在ViewModel中使用viewModelScope
class MainViewModel : ViewModel() {
    fun fetchData() {
        viewModelScope.launch {
            val data = api.fetchData() // 网络请求
            _data.value = data
        }
    }
}

class MainActivity : AppCompatActivity() {
    private var fetchJob: Job? = null

    fun startFetch() {
        fetchJob = lifecycleScope.launch {
            val data = api.fetchData()
            tv_data.text = data
        }
    }

    fun cancelFetch() {
        fetchJob?.cancel() // 手动取消协程
    }
}

lifecycleScope.launch {
    try {
        val data = withContext(Dispatchers.IO) { api.fetchData() }
        tv_data.text = data
    } catch (e: IOException) {
        // 处理网络错误
        tv_error.text = "网络连接失败"
    } catch (e: Exception) {
        // 处理其他错误
        tv_error.text = "加载失败"
    }
}

// 1. 创建全局异常处理器
val globalExceptionHandler = CoroutineExceptionHandler { _, throwable ->
    Log.e("CoroutineError", "全局异常: ${throwable.message}")
    // 比如弹Toast提示用户
    Toast.makeText(this, "加载失败", Toast.LENGTH_SHORT).show()
}

// 2. 在启动协程时传入处理器
lifecycleScope.launch(globalExceptionHandler) {
    val data = withContext(Dispatchers.IO) { api.fetchData() }
    tv_data.text = data
}

// 传统Retrofit Callback方式
api.getUserInfo().enqueue(object : Callback<User> {
    override fun onResponse(call: Call<User>, response: Response<User>) {
        if (response.isSuccessful) {
            runOnUiThread { tv_user.text = response.body()?.name }
        }
    }

    override fun onFailure(call: Call<User>, t: Throwable) {
        runOnUiThread { tv_error.text = "加载失败" }
    }
})

interface UserApi {
    @GET("user/info")
    suspend fun getUserInfo(): Response<User> // 加suspend修饰
}

lifecycleScope.launch {
    val response = withContext(Dispatchers.IO) { api.getUserInfo() }
    if (response.isSuccessful) {
        tv_user.text = response.body()?.name
    } else {
        tv_error.text = "加载失败（${response.code()}）"
    }
}