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

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 lambda, 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.17.0"
}

Kotlin

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

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

Collection KTX

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

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

Groovy

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

Kotlin

dependencies {
    implementation("androidx.collection:collection-ktx:1.5.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 मॉड्यूल, फ़्रैगमेंट एपीआई को आसान बनाने के लिए कई एक्सटेंशन उपलब्ध कराता है.

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

ग्रूवी

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

Kotlin

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

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 को ऐक्सेस किया जा सकता है.

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

ग्रूवी

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

Kotlin

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

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

ग्रूवी

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

Kotlin

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

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

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

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

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

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

Groovy

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

Kotlin

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

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

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 मॉड्यूल की मदद से, LiveData पब्लिशर से ReactiveStreams स्ट्रीम को ऑब्ज़र्व किया जा सकता है.

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

ग्रूवी

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

Kotlin

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

उदाहरण के लिए, मान लें कि किसी डेटाबेस में उपयोगकर्ताओं की एक छोटी सूची है. ऐप्लिकेशन में, डेटाबेस को मेमोरी में लोड किया जाता है. इसके बाद, उपयोगकर्ता के डेटा को यूज़र इंटरफ़ेस (यूआई) में दिखाया जाता है. इसके लिए, RxJava का इस्तेमाल किया जा सकता है. Room Jetpack कॉम्पोनेंट, उपयोगकर्ता सूची को Flowable के तौर पर वापस ला सकता है. इस स्थिति में, आपको अपने फ़्रैगमेंट या गतिविधि की लाइफ़साइकल के दौरान, Rx publisher सदस्यता को भी मैनेज करना होगा.

हालांकि, LiveDataReactiveStreams के साथ, RxJava और इसके ऑपरेटर के बड़े सेट का फ़ायदा लिया जा सकता है. साथ ही, काम शेड्यूल करने की सुविधाओं का इस्तेमाल किया जा सकता है. इसके अलावा, LiveData के साथ काम करने में आसानी होती है. यहां दिए गए उदाहरण में, यह दिखाया गया है:

val fun getUsersLiveData() : LiveData<List<User>> {
    val users: Flowable<List<User>> = dao.findUsers()
    return LiveDataReactiveStreams.fromPublisher(users)
}

Room KTX

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

ग्रूवी

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

Kotlin

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

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

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

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

SQLite KTX

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

ग्रूवी

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

Kotlin

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

यहां डेटाबेस ट्रांज़ैक्शन करने के लिए, 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.9.2"
}

Kotlin

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

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

Kotlin

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

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

इस मॉड्यूल को शामिल करने के लिए, अपने ऐप्लिकेशन की 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 issue tracker का इस्तेमाल करें.

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

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

Groovy

Kotlin

AndroidX मॉड्यूल

Core KTX

Groovy

Kotlin

Collection KTX

Groovy

Kotlin

Fragment KTX

ग्रूवी

Kotlin

Lifecycle KTX

ग्रूवी

Kotlin

LiveData KTX

ग्रूवी

Kotlin

Navigation KTX

Groovy

Kotlin

Palette KTX

ग्रूवी

Kotlin

Reactive Streams KTX

ग्रूवी

Kotlin

Room KTX

ग्रूवी

Kotlin

SQLite KTX

ग्रूवी

Kotlin

ViewModel KTX

ग्रूवी

Kotlin

WorkManager KTX

ग्रूवी

Kotlin

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

Firebase KTX

Google Maps Platform KTX

Play Core KTX

Groovy

Kotlin

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