AsyncTask 作为 kotlin 协程

Question

AsyncTask 的典型用途：我想在另一个线程中运行一个任务，完成该任务后，我想在我的 UI 线程中执行一些操作，即隐藏一个进度条。

任务将在TextureView.SurfaceTextureListener.onSurfaceTextureAvailable 开始，完成后我想隐藏进度条。同步执行此操作不起作用，因为它会阻止构建 UI 的线程，使屏幕变黑，甚至不显示我之后想要隐藏的进度条。

到目前为止，我使用这个：

inner class MyTask : AsyncTask<ProgressBar, Void, ProgressBar>() {
    override fun doInBackground(vararg params: ProgressBar?) : ProgressBar {
        // do async
        return params[0]!!
    }

    override fun onPostExecute(result: ProgressBar?) {
        super.onPostExecute(result)
        result?.visibility = View.GONE
    }
}

但是这些课程非常丑陋，所以我想摆脱它们。 我想用 kotlin 协程来做到这一点。我尝试了一些变体，但它们似乎都不起作用。我最有可能怀疑的工作是这样的：

runBlocking {
        // do async
}
progressBar.visibility = View.GONE

但这不能正常工作。据我了解，runBlocking 不会像AsyncTask 那样启动新线程，这就是我需要它做的事情。但是使用thread 协程，我看不到一种合理的方式来在它完成时得到通知。另外，我也不能把progressBar.visibility = View.GONE放到一个新线程中，因为只有UI线程可以做这样的操作。

我是协程的新手，所以我不太明白我在这里缺少什么。

Answer 1

要使用协程，您需要做以下几件事：

• 实现CoroutineScope接口。
• 对 Job 和 CoroutineContext 实例的引用。
• 在调用在后台线程中运行代码的函数时，使用 suspend 函数修饰符挂起协程而不阻塞主线程。
• 使用 withContext(Dispatchers.IO) 函数在后台线程中运行代码并使用 launch 函数启动协程。

通常我为此使用一个单独的类，例如“Presenter”或“ViewModel”：

class Presenter : CoroutineScope {
    private var job: Job = Job()
    override val coroutineContext: CoroutineContext
        get() = Dispatchers.Main + job // to run code in Main(UI) Thread

    // call this method to cancel a coroutine when you don't need it anymore,
    // e.g. when user closes the screen
    fun cancel() {
        job.cancel()
    }

    fun execute() = launch {
        onPreExecute()
        val result = doInBackground() // runs in background thread without blocking the Main Thread
        onPostExecute(result)
    }

    private suspend fun doInBackground(): String = withContext(Dispatchers.IO) { // to run code in Background Thread
        // do async work
        delay(1000) // simulate async work
        return@withContext "SomeResult"
    }

    // Runs on the Main(UI) Thread
    private fun onPreExecute() {
        // show progress
    }

    // Runs on the Main(UI) Thread
    private fun onPostExecute(result: String) {
        // hide progress
    }
}

使用ViewModel，代码使用viewModelScope更简洁：

class MyViewModel : ViewModel() {
    
    fun execute() = viewModelScope.launch {
        onPreExecute()
        val result = doInBackground() // runs in background thread without blocking the Main Thread
        onPostExecute(result)
    }

    private suspend fun doInBackground(): String = withContext(Dispatchers.IO) { // to run code in Background Thread
        // do async work
        delay(1000) // simulate async work
        return@withContext "SomeResult"
    }

    // Runs on the Main(UI) Thread
    private fun onPreExecute() {
        // show progress
    }

    // Runs on the Main(UI) Thread
    private fun onPostExecute(result: String) {
        // hide progress
    }
}

要使用viewModelScope，请将下一行添加到应用的 build.gradle 文件的依赖项：

implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:$LIFECYCLE_VERSION"

在撰写本文时final LIFECYCLE_VERSION = "2.3.0-alpha04"

Answer 2

另一种方法是在CoroutineScope上创建通用扩展函数：

fun <R> CoroutineScope.executeAsyncTask(
        onPreExecute: () -> Unit,
        doInBackground: () -> R,
        onPostExecute: (R) -> Unit
) = launch {
    onPreExecute()
    val result = withContext(Dispatchers.IO) { // runs in background thread without blocking the Main Thread
        doInBackground()
    }
    onPostExecute(result)
}

现在我们可以将它与任何CoroutineScope 一起使用：

• 在ViewModel:

    class MyViewModel : ViewModel() {
  
        fun someFun() {
            viewModelScope.executeAsyncTask(onPreExecute = {
                // ...
            }, doInBackground = {
                // ...
                "Result" // send data to "onPostExecute"
            }, onPostExecute = {
                // ... here "it" is a data returned from "doInBackground"
            })
        }
    }
  

• 在Activity 或Fragment：

    lifecycleScope.executeAsyncTask(onPreExecute = {
        // ...
    }, doInBackground = {
        // ...
        "Result" // send data to "onPostExecute"
    }, onPostExecute = {
        // ... here "it" is a data returned from "doInBackground"
    })
  

要使用viewModelScope 或lifecycleScope，将下一行添加到应用的build.gradle 文件的依赖项：

implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:$LIFECYCLE_VERSION" // for viewModelScope
implementation "androidx.lifecycle:lifecycle-runtime-ktx:$LIFECYCLE_VERSION" // for lifecycleScope

在撰写本文时final LIFECYCLE_VERSION = "2.3.0-alpha05"。

Answer 3

您可以让 ProgressBar 在 UI 主线程上运行，同时使用协程异步运行您的任务。

在你的重写 fun onCreate() 方法中，

GlobalScope.launch(Dispatchers.Main) { // Coroutine Dispatcher confined to Main UI Thread
    yourTask() // your task implementation
}

你可以初始化，

private var jobStart: Job? = null

在 Kotlin 中，var 声明意味着属性是可变的。如果你 将其声明为 val，它是不可变的、只读的且不能重新分配。

在 onCreate() 方法之外，yourTask() 可以实现为一个挂起函数，它不会阻塞主调用者线程。

当函数在等待返回结果的过程中被挂起时，它正在运行的线程被解除阻塞，以供其他函数执行。

private suspend fun yourTask() = withContext(Dispatchers.Default){ // with a given coroutine context
    jobStart = launch {
       try{
        // your task implementation
       } catch (e: Exception) {
             throw RuntimeException("To catch any exception thrown for yourTask", e)
      }
    }
  }

对于您的进度条，您可以创建一个按钮以在单击按钮时显示进度条。

buttonRecognize!!.setOnClickListener {
    trackProgress(false)
}

在 onCreate() 之外，

private fun trackProgress(isCompleted:Boolean) {
    buttonRecognize?.isEnabled = isCompleted // ?. safe call
    buttonRecognize!!.isEnabled // !! non-null asserted call

    if(isCompleted) {
        loading_progress_bar.visibility = View.GONE
    } else {
        loading_progress_bar.visibility = View.VISIBLE
    }
}

另一个提示是检查您的协程是否确实在运行 另一个线程，例如。 DefaultDispatcher-worker-1，

Log.e("yourTask", "Running on thread ${Thread.currentThread().name}")

希望这有帮助。

Answer 4

首先，您必须使用launch(context) 运行协程，而不是使用runBlocking： https://kotlinlang.org/docs/reference/coroutines/coroutine-context-and-dispatchers.html

其次，要得到onPostExecute的效果，必须使用

Activity.runOnUiThread(Runnable) 或View.post(Runnable)。

Answer 5

这不使用协程，但它是让任务在后台运行并在之后在 UI 上执行某些操作的快速解决方案。

我不确定这种方法与其他方法相比的优缺点，但它很有效并且非常容易理解：

Thread {
    // do the async Stuff
    runOnUIThread {
        // do the UI stuff
    }
    // maybe do some more stuff
}.start()

使用此解决方案，您可以轻松地在两个实体之间传递值和对象。你也可以无限嵌套。

Answer 6

以下方法可能能够满足您的需求。它需要更少的样板代码，并且适用于 100% 的用例

GlobalScope.launch {
                bitmap = BitmapFactory.decodeStream(url.openStream())

            }.invokeOnCompletion {
                createNotification()
            }