ListenableFuture, एसिंक्रोनस कंप्यूटेशन के नतीजे को दिखाता है: ऐसा कंप्यूटेशन जिसका नतीजा अभी तक जनरेट हुआ हो या न हुआ हो. यह एक तरह का Future है. इसकी मदद से, कॉलबैक को रजिस्टर किया जा सकता है, ताकि कंप्यूटेशन पूरा होने के बाद या कंप्यूटेशन पहले से पूरा होने पर, तुरंत कॉलबैक को एक्ज़ीक्यूट किया जा सके.
ListenableFuture, Android फ़्रेमवर्क का हिस्सा नहीं है. इसके बजाय, इसे Guava उपलब्ध कराता है. इस क्लास को लागू करने के बारे में ज़्यादा जानकारी के लिए, ListenableFuture के बारे में जानकारी देखें.
CameraX या स्वास्थ्य सेवाएं जैसी कई मौजूदा Jetpack लाइब्रेरी में, एसिंक्रोनस तरीके होते हैं. इनमें रिटर्न टाइप ListenableFuture होता है, जो एक्ज़ीक्यूशन की स्थिति दिखाता है. कुछ मामलों में, आपको ऐसा तरीका लागू करना पड़ सकता है जो ListenableFuture दिखाता हो. जैसे, TileService की ज़रूरी शर्तों को पूरा करने के लिए.
ज़रूरी लाइब्रेरी
ग्रूवी
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 का नतीजा पाना
कॉलबैक जोड़ना
ListenableFuture में सफलता और असफलता के कॉलबैक अटैच करने के लिए, Futures.addCallback(...) हेल्पर तरीके का इस्तेमाल करें.
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 के साथ इंटरऑपरेबिलिटी
SingleEmitter में कॉलबैक रजिस्टर करके, ListenableFuture से RxJava Single बनाया जा सकता है.
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 बनाना
आने वाले समय में होने वाले बदलाव
अगर आपका एपीआई एसिंक्रोनस नहीं है, लेकिन आपको किसी पूरी हो चुकी कार्रवाई के नतीजे को 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 फ़ंक्शन के नतीजे को 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 को लागू करता है.
fun getResult(): ListenableFuture<QueryResult> { val single: Single<QueryResult> = ... val future = SettableFuture.create<QueryResult>() single.subscribe(future::set, future::setException) return future }