Google आपकी पसंदीदा भाषा में कॉन्टेंट का अनुवाद करने के लिए, एआई टेक्नोलॉजी का इस्तेमाल करता है. एआई से मिले अनुवादों में गलतियां हो सकती हैं.

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 एक्सटेंशन उपलब्ध कराता है.

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

Core KTX

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

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

Groovy

dependencies {
    implementation "androidx.core:core-ktx:1.19.1"
}

Kotlin

dependencies {
    implementation("androidx.core:core-ktx:1.19.1")
}

यहां उन पैकेज की सूची दी गई है जो Core KTX मॉड्यूल में शामिल हैं:

कलेक्शन केटीएक्स

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

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

Groovy

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

Kotlin

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

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

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

ग्रूवी

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

Kotlin

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

Fragment 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

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

Groovy

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

Kotlin

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

यहां दिए गए उदाहरण में, एसिंक्रोनस तरीके से प्रीकंप्यूट किए गए टेक्स्ट को बनाने के लिए, 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 ऑब्जेक्ट के तौर पर दिखाता है.

Groovy

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

Kotlin

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

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

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

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

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

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

Groovy

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

Kotlin

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

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

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 के मुहावरेदार तरीके से काम करने की सुविधा देता है.

ग्रूवी

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 स्ट्रीम बनाई जा सकती है.

Groovy

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

Kotlin

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

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

रूम केटीएक्स

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

ग्रूवी

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

Kotlin

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

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

Groovy

dependencies {
    implementation "androidx.sqlite:sqlite-ktx:2.7.1"
}

Kotlin

dependencies {
    implementation("androidx.sqlite:sqlite-ktx:2.7.1")
}

डेटाबेस ट्रांज़ैक्शन करने के लिए, transaction एक्सटेंशन का इस्तेमाल करने का उदाहरण यहां दिया गया है:

db.transaction {
    // insert data
}

ViewModel KTX

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

Groovy

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

Kotlin

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

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

Groovy

dependencies {
    implementation "androidx.work:work-runtime-ktx:2.12.0"
}

Kotlin

dependencies {
    implementation("androidx.work:work-runtime-ktx:2.12.0")
}

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 कोड को मुहावरेदार तरीके से लिखा जा सकता है. ज़्यादा जानकारी के लिए, ये विषय देखें:

Google Maps Platform KTX

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

Play Core KTX

Play Core KTX, Kotlin कोरूटीन के लिए सहायता जोड़ता है. इससे, एक बार में किए जाने वाले अनुरोधों और Flow के लिए Kotlin कोरूटीन का इस्तेमाल किया जा सकता है. Flow का इस्तेमाल, स्टेटस अपडेट को मॉनिटर करने के लिए किया जाता है. इसके लिए, Play Core लाइब्रेरी में SplitInstallManager और AppUpdateManager में एक्सटेंशन फ़ंक्शन जोड़े जाते हैं.

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 समस्या ट्रैकर का इस्तेमाल करें.

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

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

Groovy

Kotlin

AndroidX मॉड्यूल

Core KTX

Groovy

Kotlin

कलेक्शन केटीएक्स

Groovy

Kotlin

Fragment KTX

ग्रूवी

Kotlin

Lifecycle KTX

Groovy

Kotlin

LiveData KTX

Groovy

Kotlin

Navigation KTX

Groovy

Kotlin

Palette KTX

ग्रूवी

Kotlin

Reactive Streams KTX

Groovy

Kotlin

रूम केटीएक्स

ग्रूवी

Kotlin

SQLite KTX

Groovy

Kotlin

ViewModel KTX

Groovy

Kotlin

WorkManager KTX

Groovy

Kotlin

अन्य KTX मॉड्यूल

Firebase KTX

Google Maps Platform KTX

Play Core KTX

Groovy

Kotlin

ज़्यादा जानकारी