इस पेज का अनुवाद Cloud Translation API से किया गया है.

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 फ़ाइल में यह जानकारी जोड़ें:

ग्रूवी

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

Kotlin

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

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

कलेक्शन 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

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

ग्रूवी

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

Kotlin

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

फ़्रैगमेंट केटीएक्स मॉड्यूल की मदद से, फ़्रैगमेंट लेन-देन को आसान बनाया जा सकता है 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 प्रॉपर्टी.

ग्रूवी

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 ऑब्जेक्ट के तौर पर दिखाता है.

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 कोरूटीन इस्तेमाल करें.

नेविगेशन लाइब्रेरी के हर कॉम्पोनेंट का अपना KTX वर्शन होता है, जो API को छोटा और 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 सहायता की सुविधा देता है.

ग्रूवी

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 पब्लिशर.

ग्रूवी

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)
}

रूम KTX

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

ग्रूवी

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 से जुड़े कोड को रैप करते हैं. इससे, आपकी साइट पर बॉयलरप्लेट कोड.

ग्रूवी

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 के लिए एक नया स्कोप बनाकर.

ग्रूवी

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 केटीएक्स

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

ग्रूवी

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.

ग्रूवी

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 केटीएक्स Android Jetpack का हिस्सा है.

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

ग्रूवी

Kotlin

AndroidX मॉड्यूल

कोर केटीएक्स

ग्रूवी

Kotlin

कलेक्शन KTX

Groovy

Kotlin

फ़्रैगमेंट KTX

ग्रूवी

Kotlin

लाइफ़साइकल केटीएक्स

ग्रूवी

Kotlin

लाइवडेटा केटीएक्स

Groovy

Kotlin

नेविगेशन केटीएक्स

ग्रूवी

Kotlin

पैलेट केटीएक्स

ग्रूवी

Kotlin

रीऐक्टिव स्ट्रीम केटीएक्स

ग्रूवी

Kotlin

रूम KTX

ग्रूवी

Kotlin

एसक्यूलाइट केटीएक्स

ग्रूवी

Kotlin

व्यूमॉडल केटीएक्स

ग्रूवी

Kotlin

WorkManager केटीएक्स

ग्रूवी

Kotlin

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

Firebase केटीएक्स

Google Maps Platform केटीएक्स

Play Core KTX खेलें

ग्रूवी

Kotlin

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