การใช้อนาคตที่ฟังได้

ListenableFuture แสดงผลลัพธ์ของการคำนวณแบบอะซิงโครนัส ซึ่งเป็นการคำนวณที่อาจสร้างผลลัพธ์เสร็จแล้วหรือยังไม่เสร็จก็ได้ ซึ่งเป็น Future ประเภทหนึ่งที่ช่วยให้คุณลงทะเบียน Callback เพื่อดำเนินการเมื่อการคำนวณเสร็จสมบูรณ์ หรือดำเนินการทันทีหากการคำนวณเสร็จสมบูรณ์แล้ว

ListenableFuture ไม่ได้เป็นส่วนหนึ่งของเฟรมเวิร์ก Android แต่ Guava เป็นผู้จัดหาให้แทน ดูข้อมูลเพิ่มเติมเกี่ยวกับการใช้งานคลาสนี้ได้ที่คำอธิบาย ListenableFuture

ไลบรารี Jetpack ที่มีอยู่หลายรายการ เช่น CameraX หรือบริการข้อมูลสุขภาพมีเมธอดแบบอะซิงโครนัสซึ่งประเภทการแสดงผลเป็น ListenableFuture ที่แสดงสถานะของการดำเนินการ ในบางกรณี คุณอาจต้องใช้เมธอดที่แสดงผล ListenableFuture เช่น เพื่อให้เป็นไปตามข้อกำหนดของ TileService

ไลบรารีที่จำเป็น

Groovy

dependencies {
    implementation "com.google.guava:guava:31.0.1-android"

    // To use CallbackToFutureAdapter
    implementation "androidx.concurrent:concurrent-futures:1.3.0"

    // Kotlin
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-guava:1.6.0"
}

Kotlin

dependencies {
    implementation("com.google.guava:guava:31.0.1-android")

    // To use CallbackToFutureAdapter
    implementation("androidx.concurrent:concurrent-futures:1.3.0")

    // Kotlin
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-guava:1.6.0")
}

การรับผลลัพธ์ของ ListenableFuture

การเพิ่ม Callback

ใช้เมธอดตัวช่วย Futures.addCallback(...) เพื่อแนบ Callback ที่สำเร็จและไม่สำเร็จลงใน ListenableFuture

val future: ListenableFuture<QueryResult> = ...
Futures.addCallback(
    future,
    object : FutureCallback<QueryResult> {
        override fun onSuccess(result: QueryResult) {
            // handle success.
        }

        override fun onFailure(t: Throwable) {
            // handle failure.
        }
    },
    // causes the callbacks to be executed on the main (UI) thread.
    context.mainExecutor
)

การระงับใน Kotlin

เมื่อใช้ Kotlin วิธีที่ง่ายที่สุดในการรอผลลัพธ์ของ ListenableFuture คือการใช้ await()

// import kotlinx.coroutines.guava.await

// ...

val future: ListenableFuture<QueryResult> = ...
val queryResult = future.await() // suspends awaiting success.

การทำงานร่วมกันกับ RxJava

คุณสร้าง RxJava Single จาก ListenableFuture ได้โดยการลงทะเบียน Callback ภายใน SingleEmitter

val future: ListenableFuture<QueryResult> = ...
val single = Single.create<QueryResult> {
    Futures.addCallback(future, object : FutureCallback<QueryResult> {
        override fun onSuccess(result: QueryResult) {
            it.onSuccess(result)
        }

        override fun onFailure(t: Throwable) {
            it.onError(t)
        }
    }, executor)
}

กำลังสร้าง ListenableFuture

การสร้างอนาคตที่ใกล้เข้ามา

หาก API ของคุณไม่ใช่แบบอะซิงโครนัส แต่คุณต้องรวมผลลัพธ์ของการดำเนินการที่เสร็จสมบูรณ์ไว้ใน ListenableFuture คุณสามารถสร้าง ImmediateFuture ได้ ซึ่งทำได้โดยใช้เมธอดแฟกทอรี Futures.immediateFuture(...)

fun getResult(): ListenableFuture<QueryResult> {
    try {
        val queryResult = getQueryResult()
        return Futures.immediateFuture(queryResult)
    } catch (e: Exception) {
        return Futures.immediateFailedFuture(e)
    }
}

การใช้โครูทีน

ใน Kotlin คุณสามารถใช้ future{ ... } เพื่อแปลงผลลัพธ์ของ Suspend Function เป็น ListenableFuture ได้

// import kotlinx.coroutines.guava.future

suspend fun getResultAsync(): QueryResult = /* ... */

fun getResultFuture(): ListenableFuture<QueryResult> {
    return coroutineScope.future {
        getResultAsync()
    }
}

การแปลง Callback

หากต้องการแปลง API ที่อิงตาม Callback เป็น API ที่ใช้ ListenableFuture ให้ใช้ CallbackToFutureAdapter API นี้ให้บริการโดยอาร์ติแฟกต์ androidx.concurrent:concurrent-futures

ดูข้อมูลเพิ่มเติมได้ที่ androidx.concurrent

การแปลงจาก RxJava Single

เมื่อใช้ RxJava คุณสามารถแปลง Single เป็น SettableFuture ซึ่งใช้ ListenableFuture ได้

fun getResult(): ListenableFuture<QueryResult> {
    val single: Single<QueryResult> = ...

    val future = SettableFuture.create<QueryResult>()
    single.subscribe(future::set, future::setException)
    return future
}