AudibleFuture का इस्तेमाल करना

ListenableFuture, एसिंक्रोनस कंप्यूटेशन का नतीजा दिखाता है: a गणना जो अभी तक पूरा परिणाम दे भी सकती है या नहीं भी. यह है Future का टाइप इसकी मदद से, कंप्यूटेशन (हिसाब लगाना) के बाद कॉलबैक को रजिस्टर किया जा सकता है पूरा या अगर कंप्यूटेशन पहले ही पूरा हो जाता है, तो.

ListenableFuture, Android फ़्रेमवर्क का हिस्सा नहीं है. इसके बजाय, इसे दिया गया है Guava की ओर से. इस बारे में ज़्यादा जानकारी पाने के लिए इस क्लास को लागू करने के बारे में है, तो ListenableFuture के बारे में जानकारी देखें.

कई मौजूदा Jetpack लाइब्रेरी, जैसे कि CameraX या Health Services का एसिंक्रोनस तरीका है जहां रिटर्न टाइप एक ListenableFuture है, जो उसे लागू नहीं करता. कुछ मामलों में आपको ऐसा तरीका लागू करना पड़ सकता है जो ListenableFuture. जैसे, TileService की ज़रूरी शर्तों को पूरा करने के लिए.

ज़रूरी लाइब्रेरी

ग्रूवीKotlin
dependencies {
    implementation "com.google.guava:guava:31.0.1-android"

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

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

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

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

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

ListenableFuture का नतीजा पाना

कॉलबैक जोड़ना

Futures.addCallback(...) का इस्तेमाल करें हेल्पर तरीके का इस्तेमाल करें.ListenableFuture

KotlinJava
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
)

ListenableFuture<QueryResult> future = ...
Futures.addCallback(
    future,
    new FutureCallback<QueryResult>() {
        public void onSuccess(QueryResult result) {
            // handle success
        }

        public void onFailure(@NonNull Throwable thrown) {
            // handle failure
        }
    },
    // causes the callbacks to be executed on the main (UI) thread
    context.getMainExecutor()
);

Kotlin में निलंबित

Kotlin का इस्तेमाल करते समय, AudibleFuture के नतीजे का इंतज़ार करने का सबसे आसान तरीका await() का इस्तेमाल करना है.

import kotlinx.coroutines.guava.await

...

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

RxJava के साथ सिंक करना

RxJava Single को कॉलबैक करके ListenableFuture से बनाया जा सकता है SingleEmitter.

KotlinJava
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<QueryResult> future = ...
Single<QueryResult> single = Single.create(
        e -> Futures.addCallback(future, new FutureCallback<QueryResult>() {
            @Override
            public void onSuccess(QueryResult result) {
                e.onSuccess(result);
            }

            @Override
            public void onFailure(@NonNull Throwable thrown) {
                e.onError(thrown);
            }
        }, executor));

ListenableFuture बनाया जा रहा है

आने वाले समय को बेहतर बनाने के लिए

अगर आपका एपीआई एसिंक्रोनस नहीं है, लेकिन आपको पूरे हुए एपीआई के नतीजे को रैप करना होगा कार्रवाई को ListenableFuture में बदलने के बाद, आप ImmediateFuture बना सकते हैं. यह Futures.immediateFuture(...) का इस्तेमाल करके, ये काम किए जा सकते हैं फ़ैक्ट्रियों पर लागू होता है.

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

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

कोरूटीन का इस्तेमाल करना

Kotlin में, future{ ... } का इस्तेमाल, निलंबन फ़ंक्शन के नतीजे को ListenableFuture में बदलने के लिए किया जा सकता है.

import kotlinx.coroutines.guava.future

suspend fun getResultAsync(): QueryResult { ... }

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

कॉलबैक कन्वर्ट करना

कॉलबैक-आधारित एपीआई को ListenableFuture का इस्तेमाल करने वाले एपीआई में बदलने के लिए, इसका इस्तेमाल करें CallbackToFutureAdapter. यह एपीआई, androidx.concurrent:concurrent-futures आर्टफ़ैक्ट से मिला है.

ज़्यादा जानकारी के लिए androidx.concurrent देखें.

RxJava Single से बदला जा रहा है

RxJava का इस्तेमाल करते समय, Single को SettableFuture में बदला जा सकता है, जो ListenableFuture को लागू करता है.

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

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

public ListenableFuture<QueryResult> getResult() {
    Single<QueryResult> single = ...

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