Android Coroutine Recipes

本文的原始碼可以在YangQiRen/coroutine-recipes中找到

基於Coroutine v1.0.0版本

引入依賴

implementation 
'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.0.0'
implementation 
'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.0.0'

如何啟動協程（Coroutine）

在 kotlinx.coroutines 庫中，您可以使用 launch 或 async 函數來啟動新的協程。

從概念上講， async 就像 launch 。它啟動一個單獨的協程，這是一個輕量級線程，可與所有其他協程同時工作。區別在於， launch 返回一個 Job 且不攜帶任何結果值，而 async 返回一個 Deferred 輕量無阻塞的未來，表示希望稍後提供結果。您可以使用 .await() 延期的值來獲得其最終結果，但是 Deferred 它也是一個 Job ，因此可以根據需要取消它。

***重點***

如果裡面的代碼 launch 以異常終止，然後將其視為未捕獲線程中的異常會使Android應用程序崩潰。內部未捕獲的異常 async 代碼存儲在結果中 Deferred 並且不會在其他任何地方交付，除非經過處理，否則它將被靜默丟棄。

協程調度員（Coroutine Dispatcher）

在Android中，我們通常使用兩個調度程序：
  • uiDispatcher將執行分派到Android主UI線程（用於父協程）。
  • bgDispatcher在後台線程中分派執行（用於子協程）。
//將執行分派到Android主線程中
val uiDispatcher：CoroutineDispatcher  = Dispatchers.Main 
//將共享線程池表示為協程分派器
val bgDispatcher：CoroutineDispatcher =  Dispatchers.I0
在下面的例子中，我們將使用 CommonPool 用於 bgContext 這限制並行運行為值64個線程或核的數量的線程的數目。

您可能要考慮使用 newFixedThreadPoolContext 緩存線程池或使用自己的緩存線程池實現。

協程範圍

要啟動協程，您需要提供 CoroutineScope 或使用 GlobalScope 。 
// GlobalScope example
class MainFragment : Fragment() {
    fun loadData() = GlobalScope.launch {  ...  }
}
// CoroutineScope example
class MainFragment : Fragment() {

    val uiScope = CoroutineScope(Dispatchers.Main)

    fun loadData() = uiScope.launch {  ...  }
}
// Fragment implements CoroutineScope example
class MainFragment : Fragment(), CoroutineScope {

    override val coroutineContext: CoroutineContext
        get() = Dispatchers.Main

    fun loadData() = launch {  ...  }
}

launch + async (execute task)

父協程通過分派器的 launch 功能啟動 Main 。

 子協程通過調度程序的 async 功能啟動 IO 。

 注意：父協程始終等待其所有子進程完成。

 注意：如果發生未經檢查的異常，應用程序將崩潰。
val uiScope = CoroutineScope(Dispatchers.Main)
fun loadData() = uiScope.launch {
    view.showLoading() // ui thread
    val task = async(bgDispatcher) { // background thread
        // your blocking call
    }
    val result = task.await()
    view.showData(result) // ui thread
}

launch + withContext (execute task)

儘管前面的示例運行良好，但我們通過啟動第二個協程來進行後台工作來浪費資源。如果僅啟動一個協程並用於 withContext 切換協程上下文，則可以優化代碼。

 父協程通過分派器的 launch 功能啟動 Main 。

 背景作業通過執行 withContext 與功能的 IO 調度。
val uiScope = CoroutineScope(Dispatchers.Main)
fun loadData() = uiScope.launch {
    view.showLoading() // ui thread
    val result = withContext(bgDispatcher) { // background thread
        // your blocking call
    }
    view.showData(result) // ui thread
}

launch + withContext (execute two tasks sequentially)

父協程通過分派器的 launch 功能啟動 Main 。

背景作業通過執行 withContext 與功能的 IO 調度。

注意： result1 和 result2 順序執行。

注意：如果發生未經檢查的異常，應用程序將崩潰。
val uiScope = CoroutineScope(Dispatchers.Main)
fun loadData() = uiScope.launch {
    view.showLoading() // ui thread

    val result1 = withContext(bgDispatcher) { // background thread
        // your blocking call
    }

    val result2 = withContext(bgDispatcher) { // background thread
        // your blocking call
    }
    
    val result = result1 + result2
    
    view.showData(result) // ui thread
}

launch + async + async (execute two tasks parallel)

父協程通過分派器的 launch 功能啟動 Main 。

 背景作業通過執行 async 與功能的 IO 調度。

 注意： task1 和 task2 是並行執行。

注意：如果發生未經檢查的異常，應用程序將崩潰。
val uiScope = CoroutineScope(Dispatchers.Main)
fun loadData() = uiScope.launch {
    view.showLoading() // ui thread

    val task1 = async(bgDispatcher) { // background thread
        // your blocking call
    }

    val task2 = async(bgDispatcher) { // background thread
        // your blocking call
    }

    val result = task1.await() + task2.await()

    view.showData(result) // ui thread
}

How to launch a coroutine with a timeout

如果要為協程作業設置超時，請使用暫停的函數包裝該函數 withTimeoutOrNull ，如果超時，該函數將返回 null 。 
val uiScope = CoroutineScope(Dispatchers.Main)
fun loadData() = uiScope.launch {
    view.showLoading() // ui thread
    val task = async(bgDispatcher) { // background thread
        // your blocking call
    }
    // suspend until task is finished or return null in 2 sec
    val result = withTimeoutOrNull(2000) { task.await() }
    view.showData(result) // ui thread
}

How to cancel a coroutine

job

該函數 loadData 返回一個 Job 可能被取消的對象。當父協程被取消時，其所有子進程也將被遞歸取消。

如果 stopPresenting 函數被調用，同時 dataProvider.loadData 仍在進行中，該功能 view.showData 將永遠不會被調用。
val uiScope = CoroutineScope(Dispatchers.Main)
var job: Job? = null
fun startPresenting() {
    job = loadData()
}
fun stopPresenting() {
    job?.cancel()
}

fun loadData() = uiScope.launch {
    view.showLoading() // ui thread
    val result = withContext(bgDispatcher) { // background thread
        // your blocking call
    }
    view.showData(result) // ui thread
}

parent job

取消協程的另一種方法是創建SupervisorJob對象，並通過重載的+運算符在作用域構造函數中指定它。在此處閱讀有關結合協程上下文元素的更多信息。
注意：如果取消父作業，則需要創建新的Job對象才能啟動新的協程，這就是我們使用cancelChildren的原因。
var job = SupervisorJob()
val uiScope = CoroutineScope(Dispatchers.Main + job)
fun startPresenting() {
    loadData()
}
fun stopPresenting() {
    scope.coroutineContext.cancelChildren()
}
fun loadData() = uiScope.launch {
    view.showLoading() // ui thread
    val result = withContext(bgDispatcher) { // background thread
        // your blocking call
    }
    view.showData(result) // ui thread
}

lifecycle aware coroutine scope

隨著android體系結構組件的發布，我們可以創建生命週期感知的協程範圍，該範圍將在 Activity#onDestroy 事件發生時自行取消。

用於生命週期的協程範圍的示例 LifecycleObserver 。
class MainScope : CoroutineScope, LifecycleObserver {

    private val job = SupervisorJob()
    override val coroutineContext: CoroutineContext
        get() = job + Dispatchers.Main

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun destroy() = coroutineContext.cancelChildren()
}
// usage
class MainFragment : Fragment() {
    private val uiScope = MainScope()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        lifecycle.addObserver(mainScope)
    }

    private fun loadData() = uiScope.launch {
        val result = withContext(bgDispatcher) {
            // your blocking call
        }
    }
}

How to handle exceptions with coroutines

try-catch block

父協程通過分派器的 launch 功能啟動 Main 。

子協程通過調度程序的 async 功能啟動 IO 。

注意：您可以使用 try-catch 塊來捕獲異常並進行處理。

留言

張貼留言

這個網誌中的熱門文章

Android - 使用 adb 安装apk

adb就是Android debug bridge的簡寫，用來和模擬器或實機互動的工具，可以參考 官方文件 。 adb在 \sdk\platform-tools 目錄底下，直接點選是無法正常使用的，一定要透過 命令提示字元 。 啟動 命令提示字元 的方法： windowsKey + R，然後輸入cmd.exe。 或是找到命令提示字元的捷徑點開。 啟動後，會看到目前的目錄，請將目錄改到\sdk\platform-tools，方法是輸入cd <path>。 確定目錄在\sdk\platform-tools下面後，輸入adb shell，adb就會 啟動 。 通常我們是要使用adb去安裝apk檔案到手機內。先將手機設定好，開啟debug偵錯，然後透過adb來確認有無連接上手機，輸入： adb devices 。若有連接上的話，會看到手機的序號，是一串字碼，反之，則什麼都沒有。 安裝apk 的方法是， 先把apk檔案放到\sdk\platform-tools下， 或是把目錄改到apk檔案所在的目錄。 然後輸入 adb install name.apk ，就會安裝，安裝完會顯示success。 若是要重新安裝，不須解除安裝，僅需輸入adb install  -r  name.apk。多一個-r。 原文連結如下：http://wisdomskyduan.blogspot.com/2014/10/android-adbapkusb.html
閱讀完整內容

Android TextView autosizing 自動調整大小

圖片
遇見問題：當一個控件顯示的文本有點長的時候，可能在屏幕小的設備上就會變得顯示不完整，特別是那種不允許文本省略的按鈕。 最近又有這個需求，並且發現官方已經支持這個自適應大小的TextView了。 Android 8.0（API級別26）允許您指示TextView文本大小自動擴展或收縮，以根據其TextView特徵和邊界填充其佈局。此設置可以更輕鬆地使用動態內容優化不同屏幕上的文本大小。
閱讀完整內容

Kotlin - 實現Android中的Parcelable

圖片
使用 Parcelable 的最基本用例是當我們需要將模型從一個活動傳遞到另一個活動時。當傳遞原始類型時，很簡單，但是當我們想要傳遞自己的對象時，我們需要對它們做一些事情： class ActivityA : Activity() { override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) val intent = Intent(this, ActivityB::class.java) val person = Person("name", 32, "email@email.com", 1234) intent.putExtra("A_STRING", "some string") intent.putExtra("A_NUMBER", 1234) intent.putExtra("AN_OBJECT", person) // compilation error startActivity(intent) } } 如果我們認為我們使用的 Person 對象與上一篇文章相同，則會在第11行收到編譯錯誤，因為我們無法照原樣傳遞 Person 模型。 我們的模型不符合以上任何條件，因此我們需要對此做些事情，我們有一些選擇： Implement Serializable： 希望您不再這樣做，儘管它有效且易於實施，但由於它基於反射，因此性能相當差。 Json String representation ： 您也可以這樣做，並將模型作為String傳遞。同樣，這也非常簡單，特別是如果您已經Gson在項目中使用了類似功能，但又不是最佳選擇。 Implement Parcelable： 這顯然是正確的答案。根據官方文檔，這是推薦的方式。它也適用於   marshalling/unmarshallingJava 對象，例如序列化，但性能更高。 因此，Parcelable是最好
閱讀完整內容