Android केटीएक्स Android Jetpack का हिस्सा है.
Android KTX, Kotlin एक्सटेंशन का एक सेट है जो Android के साथ शामिल है Jetpack और अन्य Android लाइब्रेरी का इस्तेमाल किया जा सकता है. KTX एक्सटेंशन कम शब्दों में जानकारी देते हैं, मुहावरे Kotlin से Jetpack, Android प्लैटफ़ॉर्म, और दूसरे एपीआई. ऐसा करने के लिए, एक्सटेंशन, Kotlin लैंग्वेज की कई सुविधाओं का इस्तेमाल करते हैं. इनमें ये सुविधाएं शामिल हैं:
- एक्सटेंशन फ़ंक्शन
- एक्सटेंशन प्रॉपर्टी
- Lambdas
- नाम वाले पैरामीटर
- पैरामीटर की डिफ़ॉल्ट वैल्यू
- कोरूटीन
उदाहरण के लिए, अगर
SharedPreferences
, आपको ऐसा करना होगा
कोई एडिटर बनाएं
इससे पहले कि आप प्राथमिकताओं के डेटा में बदलाव कर पाएँ. आपको यह भी लागू करना होगा
या बदलाव करने के बाद, वे बदलाव लागू हो जाएंगे, जैसा कि यहां दिखाया गया है:
उदाहरण:
sharedPreferences
.edit() // create an Editor
.putBoolean("key", value)
.apply() // write to disk asynchronously
इस्तेमाल के इस उदाहरण में, Kotlin lambdas को सबसे सही तरीके से इस्तेमाल किया जा सकता है. इनकी मदद से,
यह एक ज़्यादा छोटा तरीका है. इसे लागू करने के लिए, कोड का एक ब्लॉक पास किया जाता है, ताकि एडिटर
बनाया गया, कोड को लागू करने देना और फिर SharedPreferences
API को अनुमति देना
बदलावों को अपने-आप लागू कर दें.
यहां Android KTX Core के एक फ़ंक्शन का उदाहरण दिया गया है,
SharedPreferences.edit
यह SharedPreferences
में बदलाव करने का फ़ंक्शन जोड़ता है. इस फ़ंक्शन को
इसके पहले आर्ग्युमेंट के तौर पर, वैकल्पिक boolean
फ़्लैग का इस्तेमाल किया जाता है. इससे पता चलता है कि फ़ाइल को मिटाना है या नहीं
या बदलावों को लागू करें. इसे किसी कार्रवाई की वजह से,
Lambda के रूप में, SharedPreferences
एडिटर.
// SharedPreferences.edit extension function signature from Android KTX - Core
// inline fun SharedPreferences.edit(
// commit: Boolean = false,
// action: SharedPreferences.Editor.() -> Unit)
// Commit a new value asynchronously
sharedPreferences.edit { putBoolean("key", value) }
// Commit a new value synchronously
sharedPreferences.edit(commit = true) { putBoolean("key", value) }
कॉलर यह चुन सकता है कि बदलाव करने हैं या उन्हें लागू करना है. action
SharedPreferences.Editor
पर, Lambda फ़ंक्शन अपने-आप में एक अनजान एक्सटेंशन फ़ंक्शन है
जो अपने हस्ताक्षर के अनुसार, Unit
दिखाता है. यही वजह है कि
करने के लिए, आप सीधे साइट पर काम करने
SharedPreferences.Editor
.
आखिर में, SharedPreferences.edit()
हस्ताक्षर में inline
कीवर्ड शामिल होता है.
यह कीवर्ड, Kotlin कंपाइलर को बताता है कि इसे कॉपी करके चिपकाना चाहिए (या
इनलाइन) फ़ंक्शन का इस्तेमाल करने पर, हर बार फ़ंक्शन के लिए कंपाइल किया गया बाइटकोड.
इससे हर action
के लिए, नई क्लास इंस्टैंशिएट करने के ओवरहेड से बचा जा सकता है
समय पर इस फ़ंक्शन को कॉल किया जाता है.
यह, lambdas का इस्तेमाल करके कोड पास करने का पैटर्न होता है. इससे, समझने लायक डिफ़ॉल्ट सेटिंग लागू होती हैं, जो
को बदला जा सकता है. साथ ही, inline
का इस्तेमाल करके, इन व्यवहार को मौजूदा एपीआई में जोड़ा जा सकता है
एक्सटेंशन फ़ंक्शन, Android KTX के ज़रिए दिए गए सुधारों में खास तौर पर होते हैं
लाइब्रेरी.
अपने प्रोजेक्ट में Android KTX का इस्तेमाल करना
Android KTX का इस्तेमाल शुरू करने के लिए, अपने प्रोजेक्ट में नीचे दी गई डिपेंडेंसी जोड़ें
build.gradle
फ़ाइल:
ग्रूवी
repositories { google() }
Kotlin
repositories { google() }
AndroidX मॉड्यूल
Android KTX को मॉड्यूल में व्यवस्थित किया गया है, जहां हर मॉड्यूल में एक या एक से ज़्यादा मॉड्यूल होते हैं पैकेज.
आपको अपने ऐप्लिकेशन के हर मॉड्यूल आर्टफ़ैक्ट के लिए एक डिपेंडेंसी शामिल करनी होगी
build.gradle
फ़ाइल. आर्टफ़ैक्ट में वर्शन नंबर जोड़ना न भूलें.
हर आर्टफ़ैक्ट से जुड़े सेक्शन में, नए वर्शन के नंबर देखे जा सकते हैं
इस विषय के बारे में ज़्यादा जानकारी मिलेगी.
Android KTX में एक सिंगल कोर मॉड्यूल होता है, जो Kotlin की सुविधा देता है सामान्य फ़्रेमवर्क API और कई डोमेन-विशिष्ट एक्सटेंशन के लिए एक्सटेंशन.
कोर मॉड्यूल को छोड़कर, सभी KTX मॉड्यूल आर्टफ़ैक्ट को
आपकी build.gradle
फ़ाइल में Java डिपेंडेंसी है. उदाहरण के लिए, आपके पास
androidx.fragment:fragment
डिपेंडेंसी को इससे बदलें:
androidx.fragment:fragment-ktx
. यह सिंटैक्स बेहतर तरीके से मैनेज करने में मदद करता है
वर्शनिंग. साथ ही, इसमें डिपेंडेंसी के एलान की अन्य ज़रूरी शर्तें भी शामिल नहीं की गई हैं.
कोर केटीएक्स
Core KTX मॉड्यूल उन सामान्य लाइब्रेरी के लिए एक्सटेंशन उपलब्ध कराता है जो
Android फ़्रेमवर्क पर आधारित है. इन लाइब्रेरी में Java-आधारित डिपेंडेंसी नहीं होती जो
आपको इसे build.gradle
में जोड़ना होगा.
इस मॉड्यूल को शामिल करने के लिए, अपने ऐप्लिकेशन की build.gradle
फ़ाइल में यह जानकारी जोड़ें:
Groovy
dependencies { implementation "androidx.core:core-ktx:1.13.1" }
Kotlin
dependencies { implementation("androidx.core:core-ktx:1.13.1") }
Core KTX मॉड्यूल में मौजूद पैकेज की सूची यहां दी गई है:
- androidx.core.animation
- androidx.core.content
- androidx.core.content.res
- androidx.core.database
- androidx.core.database.sqlite
- androidx.core.graphics
- androidx.core.graphics.drawable
- androidx.core.location
- androidx.core.net
- androidx.core.os
- androidx.core.text
- androidx.core.transition
- androidx.core.util
- androidx.core.view
- androidx.core.widget
कलेक्शन KTX
संग्रह एक्सटेंशन में Android के साथ काम करने के लिए उपयोगिता फ़ंक्शन होते हैं
मेमोरी की कम खपत करने वाली कलेक्शन लाइब्रेरी. इनमें ArrayMap
, LongSparseArray
,
LruCache
, और अन्य.
इस मॉड्यूल का इस्तेमाल करने के लिए, अपने ऐप्लिकेशन की build.gradle
फ़ाइल में यह जानकारी जोड़ें:
Groovy
dependencies { implementation "androidx.collection:collection-ktx:1.4.3" }
Kotlin
dependencies { implementation("androidx.collection:collection-ktx:1.4.3") }
कलेक्शन एक्सटेंशन, Kotlin ऑपरेटर के ओवरलोड का फ़ायदा लेते हैं कलेक्शन जोड़ने जैसी चीज़ों को आसान बनाते हैं, जैसा कि नीचे दिखाया गया है उदाहरण:
// Combine 2 ArraySets into 1.
val combinedArraySet = arraySetOf(1, 2, 3) + arraySetOf(4, 5, 6)
// Combine with numbers to create a new sets.
val newArraySet = combinedArraySet + 7 + 8
फ़्रैगमेंट KTX
कॉन्टेंट बनाने फ़्रैगमेंट केटीएक्स मॉड्यूल फ़्रैगमेंट एपीआई को आसान बनाने के लिए, कई एक्सटेंशन उपलब्ध कराता है.
इस मॉड्यूल को शामिल करने के लिए, अपने ऐप्लिकेशन की build.gradle
फ़ाइल में यह जानकारी जोड़ें:
Groovy
dependencies { implementation "androidx.fragment:fragment-ktx:1.8.2" }
Kotlin
dependencies { implementation("androidx.fragment:fragment-ktx:1.8.2") }
फ़्रैगमेंट केटीएक्स मॉड्यूल की मदद से, फ़्रैगमेंट लेन-देन को आसान बनाया जा सकता है Lambdas, उदाहरण के लिए:
fragmentManager().commit {
addToBackStack("...")
setCustomAnimations(
R.anim.enter_anim,
R.anim.exit_anim)
add(fragment, "...")
}
आप viewModels
औरViewModel
activityViewModels
प्रॉपर्टी प्रतिनिधि:
// Get a reference to the ViewModel scoped to this Fragment
val viewModel by viewModels<MyViewModel>()
// Get a reference to the ViewModel scoped to its Activity
val viewModel by activityViewModels<MyViewModel>()
लाइफ़साइकल केटीएक्स
लाइफ़साइकल केटीएक्स में, हर एक के लिए LifecycleScope
तय किया गया है
Lifecycle
ऑब्जेक्ट. कोई भी कोरूटीन
Lifecycle
के खत्म होने पर, इस स्कोप में लॉन्च किया गया कैंपेन रद्द हो जाएगा. आप
तो Lifecycle
के CoroutineScope
को ऐक्सेस करने के लिए,
lifecycle.coroutineScope
या lifecycleOwner.lifecycleScope
प्रॉपर्टी.
इस मॉड्यूल को शामिल करने के लिए, अपने ऐप्लिकेशन की build.gradle
फ़ाइल में यह जानकारी जोड़ें:
Groovy
dependencies { implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.8.4" }
Kotlin
dependencies { implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.8.4") }
नीचे दिया गया उदाहरण, इन कामों के लिए lifecycleOwner.lifecycleScope
का इस्तेमाल करने का तरीका बताता है
एसिंक्रोनस तरीके से प्रीकंप्यूट किया गया टेक्स्ट बनाएं:
class MyFragment: Fragment() {
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
viewLifecycleOwner.lifecycleScope.launch {
val params = TextViewCompat.getTextMetricsParams(textView)
val precomputedText = withContext(Dispatchers.Default) {
PrecomputedTextCompat.create(longTextContent, params)
}
TextViewCompat.setPrecomputedText(textView, precomputedText)
}
}
}
लाइवडेटा केटीएक्स
LiveData का इस्तेमाल करते समय, आपको वैल्यू को एसिंक्रोनस तरीके से कैलकुलेट करना पड़ सकता है. इसके लिए
उदाहरण के लिए, हो सकता है कि आप किसी उपयोगकर्ता की प्राथमिकताओं को फिर से हासिल करना और उन्हें अपने
यूज़र इंटरफ़ेस (यूआई). ऐसे मामलों के लिए, LiveData KTX एक liveData
बिल्डर फ़ंक्शन उपलब्ध कराता है
किसी suspend
फ़ंक्शन को कॉल करता है और नतीजे को LiveData
ऑब्जेक्ट के तौर पर दिखाता है.
इस मॉड्यूल को शामिल करने के लिए, अपने ऐप्लिकेशन की build.gradle
फ़ाइल में यह जानकारी जोड़ें:
ग्रूवी
dependencies { implementation "androidx.lifecycle:lifecycle-livedata-ktx:2.8.4" }
Kotlin
dependencies { implementation("androidx.lifecycle:lifecycle-livedata-ktx:2.8.4") }
यहां दिए गए उदाहरण में, loadUser()
एक सस्पेंड फ़ंक्शन है, जिसका एलान कहीं और किया गया है.
loadUser()
को एसिंक्रोनस रूप से कॉल करने के लिए, liveData
बिल्डर फ़ंक्शन का इस्तेमाल किया जा सकता है
इसके बाद, emit()
का इस्तेमाल करके नतीजा निकाला जा सकता है:
val user: LiveData<User> = liveData {
val data = database.loadUser() // loadUser is a suspend function.
emit(data)
}
LiveData
के साथ कोरूटीन इस्तेमाल करने के बारे में ज़्यादा जानकारी के लिए, यहां देखें
आर्किटेक्चर कॉम्पोनेंट के साथ Kotlin कोरूटीन इस्तेमाल करें.
नेविगेशन केटीएक्स
नेविगेशन लाइब्रेरी के हर कॉम्पोनेंट का अपना KTX वर्शन होता है, जो API को छोटा और Kotlin-आइडियोमैटिक बनाया जा सकता है.
इन मॉड्यूल को शामिल करने के लिए, अपने ऐप्लिकेशन की build.gradle
फ़ाइल में यह जोड़ें:
Groovy
dependencies { implementation "androidx.navigation:navigation-runtime-ktx:2.7.7" implementation "androidx.navigation:navigation-fragment-ktx:2.7.7" implementation "androidx.navigation:navigation-ui-ktx:2.7.7" }
Kotlin
dependencies { implementation("androidx.navigation:navigation-runtime-ktx:2.7.7") implementation("androidx.navigation:navigation-fragment-ktx:2.7.7") implementation("androidx.navigation:navigation-ui-ktx:2.7.7") }
डेस्टिनेशन को ऐक्सेस करने के लिए, एक्सटेंशन फ़ंक्शन और प्रॉपर्टी डेलिगेशन का इस्तेमाल करना आर्ग्युमेंट और डेस्टिनेशन पर नेविगेट करें, जैसा कि नीचे दिए गए उदाहरण में दिखाया गया है:
class MyDestination : Fragment() {
// Type-safe arguments are accessed from the bundle.
val args by navArgs<MyDestinationArgs>()
...
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
view.findViewById<Button>(R.id.next)
.setOnClickListener {
// Fragment extension added to retrieve a NavController from
// any destination.
findNavController().navigate(R.id.action_to_next_destination)
}
}
...
}
पैलेट केटीएक्स
कॉन्टेंट बनाने Palette KTX मॉड्यूल रंग पटल के साथ काम करने के लिए, मुहावरेदार Kotlin सहायता की सुविधा देता है.
इस मॉड्यूल का इस्तेमाल करने के लिए, अपने ऐप्लिकेशन की build.gradle
फ़ाइल में यह जानकारी जोड़ें:
ग्रूवी
dependencies { implementation "androidx.palette:palette-ktx:1.0.0" }
Kotlin
dependencies { implementation("androidx.palette:palette-ktx:1.0.0") }
उदाहरण के लिए, Palette
इंस्टेंस के साथ काम करते समय,
पाएं ऑपरेटर ([ ]
) का इस्तेमाल करके, किसी target
के लिए selected
स्वैच:
val palette = Palette.from(bitmap).generate()
val swatch = palette[target]
रीऐक्टिव स्ट्रीम केटीएक्स
Reactive Streams केटीएक्स मॉड्यूल की मदद से, मॉनिटर किया जा सकने वाला LiveData
स्ट्रीम बनाया जा सकता है
ReactiveStreams
पब्लिशर.
इस मॉड्यूल को शामिल करने के लिए, अपने ऐप्लिकेशन की build.gradle
फ़ाइल में यह जानकारी जोड़ें:
ग्रूवी
dependencies { implementation "androidx.lifecycle:lifecycle-reactivestreams-ktx:2.8.4" }
Kotlin
dependencies { implementation("androidx.lifecycle:lifecycle-reactivestreams-ktx:2.8.4") }
उदाहरण के लिए, उपयोगकर्ताओं की एक छोटी सूची के साथ एक डेटाबेस मान लें. अपने ऐप्लिकेशन में, आपको
डेटाबेस को मेमोरी में लोड करें और फिर अपने यूज़र इंटरफ़ेस (यूआई) में उपयोगकर्ता का डेटा दिखाएं. लक्ष्य हासिल करना
तो RxJava का इस्तेमाल करना चाहिए.
Room
Jetpack कॉम्पोनेंट वापस लाया जा सकता है
Flowable
के तौर पर उपयोगकर्ता सूची को चुना जा सकता है. इस स्थिति में, आपको Rx को भी मैनेज करना होगा
आपके फ़्रैगमेंट या गतिविधि के दौरान प्रकाशक सदस्यता का इस्तेमाल करता है.
हालांकि, LiveDataReactiveStreams
के साथ आपको RxJava से फ़ायदा मिल सकता है. साथ ही, इसके और
यह काम करने के साथ-साथ, अलग-अलग तरह के ऑपरेटर और काम शेड्यूल करने की क्षमताओं का इस्तेमाल करता है
LiveData
कितनी आसान है, जैसा कि इस उदाहरण में दिखाया गया है:
val fun getUsersLiveData() : LiveData<List<User>> {
val users: Flowable<List<User>> = dao.findUsers()
return LiveDataReactiveStreams.fromPublisher(users)
}
रूम KTX
रूम एक्सटेंशन, डेटाबेस ट्रांज़ैक्शन के लिए कोरूटीन की सुविधा देते हैं.
इस मॉड्यूल का इस्तेमाल करने के लिए, अपने ऐप्लिकेशन की build.gradle
फ़ाइल में यह जानकारी जोड़ें:
Groovy
dependencies { implementation "androidx.room:room-ktx:2.6.1" }
Kotlin
dependencies { implementation("androidx.room:room-ktx:2.6.1") }
यहां कुछ ऐसे उदाहरण दिए गए हैं जिनमें रूम, अब कोरूटीन का इस्तेमाल करता है. पहला उदाहरण
User
ऑब्जेक्ट की सूची लौटाने के लिए suspend
फ़ंक्शन का इस्तेमाल करता है, जबकि दूसरा
Kotlin के Flow
का इस्तेमाल करता है
User
सूची को एसिंक्रोनस रूप से लौटाने के लिए. ध्यान दें कि Flow
का इस्तेमाल करते समय,
साथ ही, उन टेबल में हुए किसी भी बदलाव की सूचना दी जाएगी जिनके लिए क्वेरी की जा रही है.
@Query("SELECT * FROM Users")
suspend fun getUsers(): List<User>
@Query("SELECT * FROM Users")
fun getUsers(): Flow<List<User>>
एसक्यूलाइट केटीएक्स
SQLite एक्सटेंशन, ट्रांज़ैक्शन में SQL से जुड़े कोड को रैप करते हैं. इससे, आपकी साइट पर बॉयलरप्लेट कोड.
इस मॉड्यूल का इस्तेमाल करने के लिए, अपने ऐप्लिकेशन की build.gradle
फ़ाइल में यह जानकारी जोड़ें:
Groovy
dependencies { implementation "androidx.sqlite:sqlite-ktx:2.4.0" }
Kotlin
dependencies { implementation("androidx.sqlite:sqlite-ktx:2.4.0") }
डेटाबेस बनाने के लिए, transaction
एक्सटेंशन का इस्तेमाल करने का उदाहरण यहां दिया गया है
लेन-देन:
db.transaction {
// insert data
}
व्यूमॉडल केटीएक्स
ViewModel KTX लाइब्रेरी एक viewModelScope()
फ़ंक्शन उपलब्ध कराती है, जो इसे
आपके ViewModel
से कोरूटीन लॉन्च करना आसान है. कॉन्टेंट बनाने
CoroutineScope
Dispatchers.Main
पर सीमित है और अपने-आप रद्द हो जाएगा
जब ViewModel
हटा दिया जाएगा. इसके बजाय, viewModelScope()
का इस्तेमाल किया जा सकता है
हर ViewModel
के लिए एक नया स्कोप बनाकर.
इस मॉड्यूल को शामिल करने के लिए, अपने ऐप्लिकेशन की build.gradle
फ़ाइल में यह जानकारी जोड़ें:
Groovy
dependencies { implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:2.8.4" }
Kotlin
dependencies { implementation("androidx.lifecycle:lifecycle-viewmodel-ktx:2.8.4") }
उदाहरण के लिए, यहां दिया गया viewModelScope()
फ़ंक्शन, कोरूटीन लॉन्च करता है
जो बैकग्राउंड थ्रेड में नेटवर्क अनुरोध करता है. यह लाइब्रेरी,
सेटअप और संबंधित दायरा हटाना:
class MainViewModel : ViewModel() {
// Make a network request without blocking the UI thread
private fun makeNetworkRequest() {
// launch a coroutine in viewModelScope
viewModelScope.launch {
remoteApi.slowFetch()
...
}
}
// No need to override onCleared()
}
WorkManager केटीएक्स
WorkManager KTX, कोरूटीन के लिए बेहतरीन सहायता देता है.
इस मॉड्यूल को शामिल करने के लिए, अपने ऐप्लिकेशन की build.gradle
फ़ाइल में यह जानकारी जोड़ें:
Groovy
dependencies { implementation "androidx.work:work-runtime-ktx:2.9.1" }
Kotlin
dependencies { implementation("androidx.work:work-runtime-ktx:2.9.1") }
Worker
की अवधि बढ़ाने के बजाय, अब
CoroutineWorker
तक बढ़ाएं,
जिसका एपीआई थोड़ा अलग है. उदाहरण के लिए, अगर आपको एक आसान
कुछ नेटवर्क कार्रवाइयां करने के लिए CoroutineWorker
, ये काम किए जा सकते हैं:
class CoroutineDownloadWorker(context: Context, params: WorkerParameters)
: CoroutineWorker(context, params) {
override suspend fun doWork(): Result = coroutineScope {
val jobs = (0 until 100).map {
async {
downloadSynchronously("https://www.google.com")
}
}
// awaitAll will throw an exception if a download fails, which
// CoroutineWorker will treat as a failure
jobs.awaitAll()
Result.success()
}
}
CoroutineWorker
का इस्तेमाल करने के बारे में ज़्यादा जानकारी के लिए, इसे देखें
CoroutineWorker में थ्रेडिंग.
WorkManager KTX, Operations
और
मौजूदा कोरूटीन को निलंबित करने के लिए, ListenableFutures
.
यहां उदाहरण के तौर पर बताया गया है कि
Operation
को इन्होंने लौटाया
enqueue()
:
// Inside of a coroutine...
// Run async operation and suspend until completed.
WorkManager.getInstance()
.beginWith(longWorkRequest)
.enqueue().await()
// Resume after work completes...
अन्य KTX मॉड्यूल
AndroidX के बाहर मौजूद, अतिरिक्त KTX मॉड्यूल भी शामिल किए जा सकते हैं.
Firebase केटीएक्स
Android के लिए इस्तेमाल किए जाने वाले कुछ Firebase SDK टूल में, Kotlin एक्सटेंशन लाइब्रेरी होती है इसकी मदद से, ऐप्लिकेशन में Firebase का इस्तेमाल करते समय मुहावरेदार Kotlin कोड लिखा जा सकता है. इसके लिए ज़्यादा जानकारी के लिए, ये विषय देखें:
Google Maps Platform केटीएक्स
Google Maps Platform Android SDK के लिए KTX एक्सटेंशन उपलब्ध हैं जो आपको Kotlin लैंग्वेज की कई सुविधाओं का फ़ायदा मिल सकता है, जैसे कि एक्सटेंशन फ़ंक्शन, नाम वाले पैरामीटर, और डिफ़ॉल्ट आर्ग्युमेंट, और कॉन्फ़िगरेशन बनाना, और कोरूटीन. ज़्यादा जानकारी के लिए, ये विषय देखें:
Play Core KTX खेलें
Play Core KTX वन-शॉट अनुरोधों और फ़्लो के लिए, Kotlin कोरूटीन के साथ काम करता है
एक्सटेंशन फ़ंक्शन जोड़कर, स्टेटस अपडेट पर नज़र रखने के लिए
Play Core लाइब्रेरी में मौजूद SplitInstallManager
और AppUpdateManager
.
इस मॉड्यूल को शामिल करने के लिए, अपने ऐप्लिकेशन की build.gradle
फ़ाइल में यह जानकारी जोड़ें:
Groovy
dependencies { implementation "com.google.android.play:core-ktx:1.8.1" }
Kotlin
dependencies { implementation("com.google.android.play:core-ktx:1.8.1") }
यहां स्थिति पर नज़र रखने वाले Flow
का उदाहरण दिया गया है:
// Inside of a coroutine...
// Request in-app update status updates.
manager.requestUpdateFlow().collect { updateResult ->
when (updateResult) {
is AppUpdateResult.Available -> TODO()
is AppUpdateResult.InProgress -> TODO()
is AppUpdateResult.Downloaded -> TODO()
AppUpdateResult.NotAvailable -> TODO()
}
}
ज़्यादा जानकारी
Android KTX के बारे में ज़्यादा जानने के लिए, DevBytes का वीडियो देखें.
किसी समस्या की शिकायत करने या सुविधा का सुझाव देने के लिए, Android KTX समस्या को ट्रैक करने वाला टूल.