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 Core के एक फ़ंक्शन का उदाहरण दिया गया है, 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 एक्सटेंशन उपलब्ध कराता है.

मुख्य मॉड्यूल को छोड़कर, केटीएक्स मॉड्यूल के सभी आर्टफ़ैक्ट आपकी 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.4"
}

Kotlin

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

कलेक्शन एक्सटेंशन, 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 फ़ाइल में ये चीज़ें जोड़ें:

ग्रूवी

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 ऑब्जेक्ट के लिए LifecycleScope तय करता है. Lifecycle के खत्म होने पर, इस स्कोप में लॉन्च किया गया कोई भी कोरूटीन रद्द हो जाता है. lifecycle.coroutineScope या lifecycleOwner.lifecycleScope प्रॉपर्टी का इस्तेमाल करके, Lifecycle की CoroutineScope को ऐक्सेस किया जा सकता है.

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

ग्रूवी

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

Kotlin

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

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

Groovy

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

Kotlin

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

नीचे दिए गए उदाहरण में, 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 फ़ाइल में यह जोड़ें:

ग्रूवी

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

Kotlin

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

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

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

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

Reactive Streams KTX

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

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

ग्रूवी

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

Kotlin

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

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

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

ग्रूवी

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

Kotlin

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

उदाहरण के लिए, यहां दिया गया 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 के समस्या ट्रैकर का इस्तेमाल करें.