Android KTX   Android Jetpack का हिस्सा है.

Android KTX, Kotlin एक्सटेंशन का एक सेट है. इसे Android Jetpack और अन्य Android लाइब्रेरी के साथ शामिल किया गया है. KTX एक्सटेंशन, Jetpack, Android प्लैटफ़ॉर्म, और अन्य एपीआई के लिए कम शब्दों में, आसानी से समझ आने वाला Kotlin कोड उपलब्ध कराते हैं. ऐसा करने के लिए, ये एक्सटेंशन Kotlin भाषा की कई सुविधाओं का फ़ायदा लेते हैं. इनमें ये सुविधाएं शामिल हैं:

• एक्सटेंशन फ़ंक्शन
• एक्सटेंशन प्रॉपर्टी
• Lambdas
• नाम वाले पैरामीटर
• पैरामीटर की डिफ़ॉल्ट वैल्यू
• कोरूटीन

उदाहरण के लिए, SharedPreferences के साथ काम करते समय, प्राथमिकता डेटा में बदलाव करने से पहले, आपको एडिटर बनाना होगा. बदलाव करने के बाद, आपको उन्हें लागू करना होगा या कमिट करना होगा. उदाहरण के लिए:

sharedPreferences
        .edit()  // create an Editor
        .putBoolean("key", value)
        .apply() // write to disk asynchronously

इस्तेमाल के इस उदाहरण के लिए, Kotlin लैम्ब्डा फ़ंक्शन सबसे सही हैं. इनकी मदद से, एडिटर बनाने के बाद कोड का एक ब्लॉक पास करके, कोड को रन किया जा सकता है. इसके बाद, SharedPreferences API को बदलावों को एक साथ लागू करने की अनुमति दी जा सकती है.

यहां Android KTX के मुख्य फ़ंक्शन, SharedPreferences.edit का एक उदाहरण दिया गया है. यह फ़ंक्शन, SharedPreferences में बदलाव करने की सुविधा जोड़ता है. यह फ़ंक्शन अपने पहले आर्ग्युमेंट के तौर पर, वैकल्पिक boolean फ़्लैग लेता है. इससे यह पता चलता है कि बदलावों को कमिट करना है या लागू करना है. इसमें, 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 पर एक ऐसा एक्सटेंशन फ़ंक्शन है जिसका कोई नाम नहीं है. यह Unit दिखाता है, जैसा कि इसके हस्ताक्षर से पता चलता है. इसलिए, ब्लॉक में, सीधे SharedPreferences.Editor पर काम किया जा सकता है.

आखिर में, SharedPreferences.edit() सिग्नेचर में inline कीवर्ड शामिल है. यह कीवर्ड, Kotlin कंपाइलर को बताता है कि फ़ंक्शन का इस्तेमाल किए जाने पर, उसे कंपाइल किए गए बाइटकोड को कॉपी करके चिपकाना चाहिए या इनलाइन करना चाहिए. इससे, हर बार इस फ़ंक्शन को कॉल करने पर, हर action के लिए नई क्लास को इंस्टैंशिएट करने के ओवरहेड से बचा जा सकता है.

लैम्ब्डा का इस्तेमाल करके कोड पास करने, बदले जा सकने वाले सही डिफ़ॉल्ट लागू करने, और inlineएक्सटेंशन फ़ंक्शन का इस्तेमाल करके मौजूदा एपीआई में इन व्यवहारों को जोड़ने का यह पैटर्न, Android KTX लाइब्रेरी से मिलने वाले बेहतर अनुभवों के लिए खास है.

अपने प्रोजेक्ट में Android KTX का इस्तेमाल करना

Android KTX का इस्तेमाल शुरू करने के लिए, अपने प्रोजेक्ट की build.gradle फ़ाइल में यह डिपेंडेंसी जोड़ें:

Groovy

repositories {
    google()
}

Kotlin

repositories {
    google()
}

AndroidX मॉड्यूल

Android KTX को मॉड्यूल में व्यवस्थित किया जाता है. हर मॉड्यूल में एक या एक से ज़्यादा पैकेज होते हैं.

आपको अपने ऐप्लिकेशन की build.gradle फ़ाइल में, हर मॉड्यूल आर्टफ़ैक्ट के लिए एक डिपेंडेंसी शामिल करनी होगी. आर्टफ़ैक्ट में वर्शन नंबर जोड़ना न भूलें. इस विषय में, हर आर्टफ़ैक्ट के सेक्शन में जाकर, नए वर्शन के नंबर देखे जा सकते हैं.

Android KTX में एक सिंगल कोर मॉड्यूल होता है, जो सामान्य फ़्रेमवर्क एपीआई और डोमेन के हिसाब से बने कई एक्सटेंशन के लिए Kotlin एक्सटेंशन उपलब्ध कराता है.

कोर मॉड्यूल को छोड़कर, सभी KTX मॉड्यूल आर्टफ़ैक्ट, आपकी build.gradle फ़ाइल में मौजूद Java डिपेंडेंसी को बदल देते हैं. उदाहरण के लिए, किसी androidx.fragment:fragment डिपेंडेंसी को androidx.fragment:fragment-ktx से बदला जा सकता है. इस सिंटैक्स से, वर्शन को बेहतर तरीके से मैनेज करने में मदद मिलती है. साथ ही, इससे डिपेंडेंसी के एलान से जुड़ी अतिरिक्त ज़रूरी शर्तें नहीं जोड़ी जाती हैं.

Core KTX

Core KTX मॉड्यूल, Android फ़्रेमवर्क का हिस्सा इन लाइब्रेरी में, Java पर आधारित ऐसी डिपेंडेंसी नहीं होतीं जिन्हें आपको build.gradle में जोड़ना पड़े.

इस मॉड्यूल को शामिल करने के लिए, अपने ऐप्लिकेशन की build.gradle फ़ाइल में ये चीज़ें जोड़ें:

ग्रूवी

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

Collection KTX

कलेक्शन एक्सटेंशन में, Android की मेमोरी के हिसाब से काम करने वाली कलेक्शन लाइब्रेरी के साथ काम करने के लिए, काम के फ़ंक्शन होते हैं. इनमें ArrayMap, LongSparseArray, LruCache वगैरह शामिल हैं.

इस मॉड्यूल का इस्तेमाल करने के लिए, अपने ऐप्लिकेशन की build.gradle फ़ाइल में ये चीज़ें जोड़ें:

Groovy

dependencies {
    implementation "androidx.collection:collection-ktx:1.4.5"
}

Kotlin

dependencies {
    implementation("androidx.collection:collection-ktx:1.4.5")
}

कलेक्शन एक्सटेंशन, 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

Fragment KTX

फ़्रैगमेंट KTX मॉड्यूल, फ़्रैगमेंट एपीआई को आसान बनाने के लिए कई एक्सटेंशन उपलब्ध कराता है.

इस मॉड्यूल को शामिल करने के लिए, अपने ऐप्लिकेशन की build.gradle फ़ाइल में ये चीज़ें जोड़ें:

ग्रूवी

dependencies {
    implementation "androidx.fragment:fragment-ktx:1.8.3"
}

Kotlin

dependencies {
    implementation("androidx.fragment:fragment-ktx:1.8.3")
}

फ़्रैगमेंट KTX मॉड्यूल की मदद से, लैम्ब्डा के साथ फ़्रैगमेंट लेन-देन को आसान बनाया जा सकता है. उदाहरण के लिए:

fragmentManager().commit {
   addToBackStack("...")
   setCustomAnimations(
           R.anim.enter_anim,
           R.anim.exit_anim)
   add(fragment, "...")
}

viewModels और activityViewModels प्रॉपर्टी डेलिगेट का इस्तेमाल करके, एक लाइन में ViewModel से भी कनेक्ट किया जा सकता है:

// 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>()

Lifecycle KTX

लाइफ़साइकल KTX, हर Lifecycle ऑब्जेक्ट के लिए एक LifecycleScope तय करता है. Lifecycle के खत्म होने पर, इस स्कोप में लॉन्च किया गया कोई भी कोरूटीन रद्द हो जाता है. lifecycle.coroutineScope या lifecycleOwner.lifecycleScope प्रॉपर्टी का इस्तेमाल करके, Lifecycle की CoroutineScope को ऐक्सेस किया जा सकता है.

इस मॉड्यूल को शामिल करने के लिए, अपने ऐप्लिकेशन की build.gradle फ़ाइल में ये चीज़ें जोड़ें:

Groovy

dependencies {
    implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.8.7"
}

Kotlin

dependencies {
    implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.8.7")
}

यहां दिए गए उदाहरण में, पहले से कैलकुलेट किया गया टेक्स्ट असिंक्रोनस तरीके से बनाने के लिए, 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 KTX

LiveData का इस्तेमाल करते समय, आपको वैल्यू का हिसाब अलग-अलग समय पर लगाना पड़ सकता है. उदाहरण के लिए, हो सकता है कि आपको किसी उपयोगकर्ता की प्राथमिकताएं वापस लानी हों और उन्हें अपने यूज़र इंटरफ़ेस (यूआई) पर दिखानी हों. इन मामलों के लिए, LiveData KTX एक liveData बिल्डर फ़ंक्शन उपलब्ध कराता है, जो suspend फ़ंक्शन को कॉल करता है और नतीजे को LiveData ऑब्जेक्ट के तौर पर दिखाता है.

इस मॉड्यूल को शामिल करने के लिए, अपने ऐप्लिकेशन की build.gradle फ़ाइल में ये चीज़ें जोड़ें:

Groovy

dependencies {
    implementation "androidx.lifecycle:lifecycle-livedata-ktx:2.8.7"
}

Kotlin

dependencies {
    implementation("androidx.lifecycle:lifecycle-livedata-ktx:2.8.7")
}

नीचे दिए गए उदाहरण में, loadUser() एक सस्पेंड फ़ंक्शन है जिसे कहीं और घोषित किया गया है. loadUser() को असिंक्रोनस तरीके से कॉल करने के लिए, liveData बिल्डर फ़ंक्शन का इस्तेमाल किया जा सकता है. इसके बाद, नतीजा दिखाने के लिए emit() का इस्तेमाल किया जा सकता है:

val user: LiveData<User> = liveData {
    val data = database.loadUser() // loadUser is a suspend function.
    emit(data)
}

LiveData के साथ कोरूटीन इस्तेमाल करने के बारे में ज़्यादा जानने के लिए, आर्किटेक्चर कॉम्पोनेंट के साथ Kotlin कोरूटीन इस्तेमाल करना लेख पढ़ें.

Navigation KTX

नेविगेशन लाइब्रेरी के हर कॉम्पोनेंट का अपना KTX वर्शन होता है. यह एपीआई को ज़्यादा छोटा और Kotlin के हिसाब से बनाता है.

इन मॉड्यूल को शामिल करने के लिए, अपने ऐप्लिकेशन की build.gradle फ़ाइल में ये चीज़ें जोड़ें:

Groovy

dependencies {
    implementation "androidx.navigation:navigation-runtime-ktx:2.7.5"
    implementation "androidx.navigation:navigation-fragment-ktx:2.7.5"
    implementation "androidx.navigation:navigation-ui-ktx:2.7.5"
}

Kotlin

dependencies {
    implementation("androidx.navigation:navigation-runtime-ktx:2.7.5")
    implementation("androidx.navigation:navigation-fragment-ktx:2.7.5")
    implementation("androidx.navigation:navigation-ui-ktx:2.7.5")
}

डेस्टिनेशन के आर्ग्युमेंट ऐक्सेस करने और डेस्टिनेशन पर जाने के लिए, एक्सटेंशन फ़ंक्शन और प्रॉपर्टी डेलिगेशन का इस्तेमाल करें. इस बारे में यहां दिए गए उदाहरण में बताया गया है:

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

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 इंस्टेंस के साथ काम करते समय, get ऑपरेटर ([ ]) का इस्तेमाल करके, किसी दिए गए target के लिए selected स्वैच को वापस पाया जा सकता है:

val palette = Palette.from(bitmap).generate()
val swatch = palette[target]

Reactive Streams KTX

Reactive Streams KTX मॉड्यूल की मदद से, ReactiveStreams पब्लिशर से ऑब्ज़र्वेबल LiveData स्ट्रीम बनाई जा सकती है.

इस मॉड्यूल को शामिल करने के लिए, अपने ऐप्लिकेशन की build.gradle फ़ाइल में ये चीज़ें जोड़ें:

Groovy

dependencies {
    implementation "androidx.lifecycle:lifecycle-reactivestreams-ktx:2.8.7"
}

Kotlin

dependencies {
    implementation("androidx.lifecycle:lifecycle-reactivestreams-ktx:2.8.7")
}

उदाहरण के लिए, मान लें कि आपके पास उपयोगकर्ताओं की एक छोटी सूची वाला डेटाबेस है. अपने ऐप्लिकेशन में, डेटाबेस को मेमोरी में लोड किया जाता है. इसके बाद, यूज़र इंटरफ़ेस (यूआई) में उपयोगकर्ता का डेटा दिखाया जाता है. ऐसा करने के लिए, 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)
}

Room KTX

Room एक्सटेंशन, डेटाबेस ट्रांज़ैक्शन के लिए कोरूटीन की सुविधा जोड़ते हैं.

इस मॉड्यूल का इस्तेमाल करने के लिए, अपने ऐप्लिकेशन की build.gradle फ़ाइल में ये चीज़ें जोड़ें:

ग्रूवी

dependencies {
    implementation "androidx.room:room-ktx:2.6.1"
}

Kotlin

dependencies {
    implementation("androidx.room:room-ktx:2.6.1")
}

यहां कुछ ऐसे उदाहरण दिए गए हैं जिनमें Room अब कोरूटीन का इस्तेमाल करता है. पहला उदाहरण, User ऑब्जेक्ट की सूची दिखाने के लिए suspend फ़ंक्शन का इस्तेमाल करता है. वहीं, दूसरा उदाहरण, User सूची को असिंक्रोनस तरीके से दिखाने के लिए, Kotlin के Flow फ़ंक्शन का इस्तेमाल करता है. ध्यान दें कि Flow का इस्तेमाल करने पर, आपको उन टेबल में हुए बदलावों की सूचना भी मिलती है जिनमें क्वेरी की जा रही है.

@Query("SELECT * FROM Users")
suspend fun getUsers(): List<User>

@Query("SELECT * FROM Users")
fun getUsers(): Flow<List<User>>

SQLite KTX

SQLite एक्सटेंशन, SQL से जुड़े कोड को लेन-देन में रैप करते हैं. इससे, छोटे-मोटे बदलाव वाले कई कोड हट जाते हैं.

इस मॉड्यूल का इस्तेमाल करने के लिए, अपने ऐप्लिकेशन की build.gradle फ़ाइल में ये चीज़ें जोड़ें:

ग्रूवी

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

ViewModel KTX लाइब्रेरी में एक viewModelScope() फ़ंक्शन होता है. इसकी मदद से, ViewModel से कोरूटीन लॉन्च करना आसान हो जाता है. CoroutineScope को Dispatchers.Main से जोड़ा गया है. ViewModel को हटाने पर, यह अपने-आप रद्द हो जाता है. हर ViewModel के लिए नया स्कोप बनाने के बजाय, viewModelScope() का इस्तेमाल किया जा सकता है.

इस मॉड्यूल को शामिल करने के लिए, अपने ऐप्लिकेशन की build.gradle फ़ाइल में ये चीज़ें जोड़ें:

Groovy

dependencies {
    implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:2.8.7"
}

Kotlin

dependencies {
    implementation("androidx.lifecycle:lifecycle-viewmodel-ktx:2.8.7")
}

उदाहरण के लिए, यहां दिया गया 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 KTX

WorkManager KTX, कोरूटीन के लिए बेहतरीन सहायता उपलब्ध कराता है.

इस मॉड्यूल को शामिल करने के लिए, अपने ऐप्लिकेशन की build.gradle फ़ाइल में ये चीज़ें जोड़ें:

ग्रूवी

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 में एक्सटेंशन फ़ंक्शन भी जोड़ता है.

यहां एक उदाहरण दिया गया है, जिसमें enqueue() से दिखाए गए Operation को निलंबित किया गया है:

// 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 KTX

Android के लिए उपलब्ध कुछ Firebase SDK टूल में Kotlin एक्सटेंशन लाइब्रेरी होती हैं. इनकी मदद से, अपने ऐप्लिकेशन में Firebase का इस्तेमाल करते समय, आसानी से Kotlin कोड लिखा जा सकता है. ज़्यादा जानकारी के लिए, ये विषय देखें:

• Firebase Android SDK टूल
• Firebase के लिए Kotlin के सामान्य एक्सटेंशन

Google Maps Platform KTX

Google Maps Platform के Android SDK टूल के लिए, KTX एक्सटेंशन उपलब्ध हैं. इनकी मदद से, Kotlin भाषा की कई सुविधाओं का फ़ायदा लिया जा सकता है. जैसे, एक्सटेंशन फ़ंक्शन, नाम वाले पैरामीटर और डिफ़ॉल्ट आर्ग्युमेंट, डिस्ट्रक्चरिंग एलान, और कोरूटीन. ज़्यादा जानकारी के लिए, ये लेख पढ़ें:

• Maps Android KTX
• Places Android KTX

Play Core KTX

Play Core KTX, एक बार में किए जाने वाले अनुरोधों के लिए Kotlin कोरुटिन और स्थिति से जुड़े अपडेट को मॉनिटर करने के लिए Flow की सुविधा जोड़ता है. इसके लिए, 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 के समस्या ट्रैकर का इस्तेमाल करें.