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

KTX एक्सटेंशन की सूची

androidx.activity

डिपेंडेंसी

ग्रूवी

dependencies {
    implementation "androidx.activity:activity-ktx:1.10.1"
}

Kotlin

dependencies {
    implementation("androidx.activity:activity-ktx:1.10.1")
}

एक्सटेंशन फ़ंक्शन

OnBackPressedDispatcher के लिए

OnBackPressedCallback

OnBackPressedDispatcher.addCallback(owner: LifecycleOwner? = null, enabled: Boolean = true, onBackPressed: OnBackPressedCallback.() -> Unit)

एक नया OnBackPressedCallback बनाएं और उसे जोड़ें. यह OnBackPressedCallback.handleOnBackPressed में onBackPressed को कॉल करता है.

ComponentActivity के लिए

Lazy<VM>

ComponentActivity.viewModels(noinline factoryProducer: () -> ViewModelProvider.Factory = null)

यह ComponentActivity के ViewModel को ऐक्सेस करने के लिए, Lazy डेलिगेट दिखाता है. अगर factoryProducer तय किया गया है, तो इससे मिले ViewModelProvider.Factory का इस्तेमाल, पहली बार ViewModel बनाने के लिए किया जाएगा.

androidx.benchmark

डिपेंडेंसी

Groovy

dependencies {
    implementation "androidx.benchmark:benchmark-junit4:1.4.0"
}

Kotlin

dependencies {
    implementation("androidx.benchmark:benchmark-junit4:1.4.0")
}

टॉप-लेवल फ़ंक्शन

यूनिट	`beginTraceSection(sectionName: String)`
यूनिट	`endTraceSection()`

androidx.benchmark.junit4

डिपेंडेंसी

Groovy

dependencies {
    implementation "androidx.benchmark:benchmark-junit4:1.4.0"
}

Kotlin

dependencies {
    implementation("androidx.benchmark:benchmark-junit4:1.4.0")
}

एक्सटेंशन फ़ंक्शन

BenchmarkRule के लिए

यूनिट

BenchmarkRule.measureRepeated(crossinline block: BenchmarkRule.Scope.() -> Unit)

कोड के किसी ब्लॉक की परफ़ॉर्मेंस की तुलना करना.

androidx.collection

डिपेंडेंसी

Groovy

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

Kotlin

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

एक्सटेंशन फ़ंक्शन

LongSparseArray के लिए

operator Boolean	`LongSparseArray<T>.contains(key: Long)` अगर कलेक्शन में key मौजूद है, तो यह फ़ंक्शन true दिखाता है.
यूनिट	`LongSparseArray<T>.forEach(action: (key: Long, value: T) -> Unit)` यह फ़ंक्शन, हर की/वैल्यू एंट्री के लिए दी गई कार्रवाई करता है.
T	`LongSparseArray<T>.getOrDefault(key: Long, defaultValue: T)` अगर key मौजूद है, तो उससे जुड़ी वैल्यू दिखाएगा. अगर key मौजूद नहीं है, तो defaultValue दिखाएगा.
T	`LongSparseArray<T>.getOrElse(key: Long, defaultValue: () -> T)` key से जुड़ी वैल्यू दिखाता है. अगर वैल्यू मौजूद नहीं है, तो defaultValue से वैल्यू दिखाता है.
बूलियन	`LongSparseArray<T>.isNotEmpty()` संग्रह में एलिमेंट मौजूद होने पर, 'सही है' वैल्यू दिखाता है.
LongIterator	`LongSparseArray<T>.keyIterator()` संग्रह की कुंजियों पर एक इटरेटर दिखाता है.
operator LongSparseArray<T>	`LongSparseArray<T>.plus(other: LongSparseArray<T>)` यह फ़ंक्शन, other से एंट्री जोड़कर या बदलकर नया कलेक्शन बनाता है.
बूलियन	`LongSparseArray<T>.remove(key: Long, value: T)` यह फ़ंक्शन, key के लिए एंट्री को सिर्फ़ तब हटाता है, जब उसे value पर मैप किया गया हो.
operator Unit	`LongSparseArray<T>.set(key: Long, value: T)` इसकी मदद से, कलेक्शन में वैल्यू सेव करने के लिए इंडेक्स ऑपरेटर का इस्तेमाल किया जा सकता है.
Iterator<T>	`LongSparseArray<T>.valueIterator()` कलेक्शन की वैल्यू पर एक इटरेटर दिखाता है.

SparseArrayCompat के लिए

operator Boolean	`SparseArrayCompat<T>.contains(key: Int)` अगर कलेक्शन में key मौजूद है, तो यह फ़ंक्शन true दिखाता है.
यूनिट	`SparseArrayCompat<T>.forEach(action: (key: Int, value: T) -> Unit)` यह फ़ंक्शन, हर की/वैल्यू एंट्री के लिए दी गई कार्रवाई करता है.
T	`SparseArrayCompat<T>.getOrDefault(key: Int, defaultValue: T)` अगर key मौजूद है, तो उससे जुड़ी वैल्यू दिखाएगा. अगर key मौजूद नहीं है, तो defaultValue दिखाएगा.
T	`SparseArrayCompat<T>.getOrElse(key: Int, defaultValue: () -> T)` key से जुड़ी वैल्यू दिखाता है. अगर वैल्यू मौजूद नहीं है, तो defaultValue से वैल्यू दिखाता है.
बूलियन	`SparseArrayCompat<T>.isNotEmpty()` संग्रह में एलिमेंट मौजूद होने पर, 'सही है' वैल्यू दिखाता है.
IntIterator	`SparseArrayCompat<T>.keyIterator()` संग्रह की कुंजियों पर एक इटरेटर दिखाता है.
operator SparseArrayCompat<T>	`SparseArrayCompat<T>.plus(other: SparseArrayCompat<T>)` यह फ़ंक्शन, other से एंट्री जोड़कर या बदलकर नया कलेक्शन बनाता है.
बूलियन	`SparseArrayCompat<T>.remove(key: Int, value: T)` यह फ़ंक्शन, key के लिए एंट्री को सिर्फ़ तब हटाता है, जब उसे value पर मैप किया गया हो.
operator Unit	`SparseArrayCompat<T>.set(key: Int, value: T)` इसकी मदद से, कलेक्शन में वैल्यू सेव करने के लिए इंडेक्स ऑपरेटर का इस्तेमाल किया जा सकता है.
Iterator<T>	`SparseArrayCompat<T>.valueIterator()` कलेक्शन की वैल्यू पर एक इटरेटर दिखाता है.

एक्सटेंशन प्रॉपर्टी

LongSparseArray के लिए

Int	`LongSparseArray<T>.size()` यह फ़ंक्शन, कलेक्शन में मौजूद कुंजी/वैल्यू पेयर की संख्या दिखाता है.

SparseArrayCompat के लिए

Int	`SparseArrayCompat<T>.size()` यह फ़ंक्शन, कलेक्शन में मौजूद कुंजी/वैल्यू पेयर की संख्या दिखाता है.

टॉप-लेवल फ़ंक्शन

ArrayMap< K, V>	`arrayMapOf()` यह एक नया, खाली ArrayMap दिखाता है.
ArrayMap< K, V>	`arrayMapOf(vararg pairs: Pair<K, V>)` यह फ़ंक्शन, दिए गए कॉन्टेंट के साथ एक नया ArrayMap दिखाता है. कॉन्टेंट को जोड़े की सूची के तौर पर दिया जाता है. इसमें पहला कॉम्पोनेंट कुंजी होता है और दूसरा कॉम्पोनेंट वैल्यू होता है.
ArraySet<T>	`arraySetOf()` यह एक नया और खाली ArraySet दिखाता है.
ArraySet<T>	`arraySetOf(vararg values: T)` यह दिए गए कॉन्टेंट के साथ एक नया ArraySet दिखाता है.
LruCache&lt K, V&gt	`lruCache(maxSize: Int, crossinline sizeOf: (key: K, value: V) -> Int = { _, _ -> 1 }, crossinline create: (key: K) -> V? = { null as V? }, crossinline onEntryRemoved: (evicted: Boolean, key: K, oldValue: V, newValue: V?) -> Unit = { _, _, _, _ -> })` यह दिए गए पैरामीटर के साथ LruCache बनाता है.

androidx.core.animation

डिपेंडेंसी

Groovy

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

Kotlin

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

एक्सटेंशन फ़ंक्शन

android.animation.Animator के लिए

AnimatorListener	`Animator.addListener(crossinline onEnd: (animator: Animator) -> Unit = {}, crossinline onStart: (animator: Animator) -> Unit = {}, crossinline onCancel: (animator: Animator) -> Unit = {}, crossinline onRepeat: (animator: Animator) -> Unit = {})` दी गई कार्रवाइयों का इस्तेमाल करके, इस ऐनिमेटर में एक लिसनर जोड़ें.
AnimatorPauseListener	`Animator.addPauseListener(crossinline onResume: (animator: Animator) -> Unit = {}, crossinline onPause: (animator: Animator) -> Unit = {})` दी गई कार्रवाइयों का इस्तेमाल करके, इस ऐनिमेटर में रोकने और फिर से शुरू करने वाला लिसनर जोड़ें.
AnimatorListener	`Animator.doOnCancel(crossinline action: (animator: Animator) -> Unit)` ऐसी कार्रवाई जोड़ें जिसे ऐनिमेशन रद्द होने पर शुरू किया जाएगा.
AnimatorListener	`Animator.doOnEnd(crossinline action: (animator: Animator) -> Unit)` ऐसी कार्रवाई जोड़ें जिसे ऐनिमेशन खत्म होने पर शुरू किया जाएगा.
AnimatorPauseListener	`Animator.doOnPause(crossinline action: (animator: Animator) -> Unit)` ऐसी कार्रवाई जोड़ें जिसे ऐनिमेशन के रुकने पर शुरू किया जाएगा.
AnimatorListener	`Animator.doOnRepeat(crossinline action: (animator: Animator) -> Unit)` ऐसी कार्रवाई जोड़ें जिसे ऐनिमेशन के दोहराए जाने पर शुरू किया जाएगा.
AnimatorPauseListener	`Animator.doOnResume(crossinline action: (animator: Animator) -> Unit)` ऐसी कार्रवाई जोड़ें जिसे ऐनिमेशन के रुकने के बाद फिर से शुरू होने पर शुरू किया जाएगा.
AnimatorListener	`Animator.doOnStart(crossinline action: (animator: Animator) -> Unit)` ऐसी कार्रवाई जोड़ें जिसे ऐनिमेशन शुरू होने पर लागू किया जाएगा.

androidx.core.content

डिपेंडेंसी

Groovy

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

Kotlin

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

एक्सटेंशन फ़ंक्शन

android.content.Context के लिए

T?	`Context.getSystemService()` क्लास के हिसाब से, सिस्टम-लेवल की सेवा के लिए हैंडल वापस करता है.
यूनिट	`Context.withStyledAttributes(set: AttributeSet? = null, attrs: IntArray, @AttrRes defStyleAttr: Int = 0, @StyleRes defStyleRes: Int = 0, block: TypedArray.() -> Unit)` यह TypedArray रिसीवर पर block को लागू करता है.
यूनिट	`Context.withStyledAttributes(@StyleRes resourceId: Int, attrs: IntArray, block: TypedArray.() -> Unit)` यह TypedArray रिसीवर पर block को लागू करता है.

android.content.SharedPreferences के लिए

यूनिट

SharedPreferences.edit(commit: Boolean = false, action: Editor.() -> Unit)

इस सेटिंग के इंस्टेंस में बदलाव करने की अनुमति देता है. इसके लिए, apply या commit को कॉल करना होगा, ताकि बदलावों को सेव किया जा सके.

टॉप-लेवल फ़ंक्शन

ContentValues

contentValuesOf(vararg pairs: Pair<String, Any?>)

यह फ़ंक्शन, दिए गए कुंजी/वैल्यू पेयर को एलिमेंट के तौर पर इस्तेमाल करके, नया ContentValues ऑब्जेक्ट दिखाता है.

androidx.core.content.res

डिपेंडेंसी

Groovy

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

Kotlin

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

एक्सटेंशन फ़ंक्शन

android.content.res.TypedArray के लिए

बूलियन	`TypedArray.getBooleanOrThrow(@StyleableRes index: Int)` index पर मौजूद एट्रिब्यूट के लिए बूलियन वैल्यू पाएं. अगर वैल्यू तय नहीं की गई है, तो IllegalArgumentException थ्रो करता है.
Int	`TypedArray.getColorOrThrow(@StyleableRes index: Int)` index पर मौजूद एट्रिब्यूट के लिए रंग की वैल्यू वापस लाता है. अगर वैल्यू तय नहीं की गई है, तो IllegalArgumentException दिखाता है.
ColorStateList	`TypedArray.getColorStateListOrThrow(@StyleableRes index: Int)` index पर मौजूद एट्रिब्यूट के लिए, कलर स्टेट लिस्ट की वैल्यू वापस लाता है. अगर वैल्यू तय नहीं की गई है, तो IllegalArgumentException दिखाता है.
फ़्लोट	`TypedArray.getDimensionOrThrow(@StyleableRes index: Int)` index पर मौजूद एट्रिब्यूट के लिए डाइमेंशन वैल्यू वापस लाता है. अगर डाइमेंशन वैल्यू तय नहीं की गई है, तो IllegalArgumentException दिखाता है.
Int	`TypedArray.getDimensionPixelOffsetOrThrow(@StyleableRes index: Int)` यह index पर मौजूद एट्रिब्यूट के लिए, डाइमेंशन पिक्सल ऑफ़सेट वैल्यू को वापस लाता है. अगर यह वैल्यू तय नहीं की गई है, तो IllegalArgumentException दिखाता है.
Int	`TypedArray.getDimensionPixelSizeOrThrow(@StyleableRes index: Int)` यह फ़ंक्शन, index पर मौजूद एट्रिब्यूट के लिए, डाइमेंशन पिक्सल साइज़ की वैल्यू को वापस लाता है. अगर डाइमेंशन पिक्सल साइज़ की वैल्यू तय नहीं की गई है, तो यह फ़ंक्शन IllegalArgumentException दिखाता है.
Drawable	`TypedArray.getDrawableOrThrow(@StyleableRes index: Int)` index पर मौजूद एट्रिब्यूट के लिए, ड्रॉएबल वैल्यू पाएं. अगर वैल्यू तय नहीं की गई है, तो IllegalArgumentException थ्रो करता है.
फ़्लोट	`TypedArray.getFloatOrThrow(@StyleableRes index: Int)` index पर मौजूद एट्रिब्यूट के लिए फ़्लोट वैल्यू वापस लाता है. अगर वैल्यू तय नहीं की गई है, तो IllegalArgumentException दिखाता है.
टाइपफ़ेस	`TypedArray.getFontOrThrow(@StyleableRes index: Int)` index पर मौजूद एट्रिब्यूट के लिए फ़ॉन्ट की वैल्यू वापस लाता है. अगर वैल्यू तय नहीं की गई है, तो IllegalArgumentException दिखाता है.
Int	`TypedArray.getIntOrThrow(@StyleableRes index: Int)` index पर मौजूद एट्रिब्यूट के लिए पूर्णांक वैल्यू वापस पाएं. अगर यह वैल्यू तय नहीं की गई है, तो IllegalArgumentException दिखाता है.
Int	`TypedArray.getIntegerOrThrow(@StyleableRes index: Int)` index पर मौजूद एट्रिब्यूट के लिए पूर्णांक वैल्यू वापस पाएं. अगर यह वैल्यू तय नहीं की गई है, तो IllegalArgumentException दिखाता है.
Int	`TypedArray.getResourceIdOrThrow(@StyleableRes index: Int)` यह index पर मौजूद एट्रिब्यूट के लिए, संसाधन आइडेंटिफ़ायर को वापस लाता है. अगर यह तय नहीं किया गया है, तो IllegalArgumentException दिखाता है.
String	`TypedArray.getStringOrThrow(@StyleableRes index: Int)` index पर मौजूद एट्रिब्यूट के लिए स्ट्रिंग वैल्यू वापस लाता है. अगर यह वैल्यू तय नहीं की गई है, तो IllegalArgumentException दिखाता है.
Array<CharSequence>	`TypedArray.getTextArrayOrThrow(@StyleableRes index: Int)` index पर मौजूद एट्रिब्यूट के लिए, टेक्स्ट ऐरे की वैल्यू वापस पाएं. अगर वैल्यू तय नहीं की गई है, तो IllegalArgumentException दिखाता है.
CharSequence	`TypedArray.getTextOrThrow(@StyleableRes index: Int)` index पर मौजूद एट्रिब्यूट के लिए टेक्स्ट वैल्यू वापस पाएं. अगर एट्रिब्यूट तय नहीं किया गया है, तो IllegalArgumentException थ्रो करता है.
R	`TypedArray.use(block: (TypedArray) -> R)` यह फ़ंक्शन, इस TypedArray पर दिए गए block फ़ंक्शन को लागू करता है. इसके बाद, इसे रीसाइकल करता है.

androidx.core.database

डिपेंडेंसी

Groovy

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

Kotlin

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

एक्सटेंशन फ़ंक्शन

android.database.Cursor के लिए

ByteArray?	`Cursor.getBlobOrNull(index: Int)` यह फ़ंक्शन, अनुरोध किए गए कॉलम की वैल्यू को नल हो सकने वाले बाइट ऐरे के तौर पर दिखाता है.
डबल?	`Cursor.getDoubleOrNull(index: Int)` यह फ़ंक्शन, अनुरोध किए गए कॉलम की वैल्यू को डबल के तौर पर दिखाता है. हालांकि, यह वैल्यू शून्य हो सकती है.
फ़्लोट?	`Cursor.getFloatOrNull(index: Int)` यह फ़ंक्शन, अनुरोध किए गए कॉलम की वैल्यू को ऐसे फ़्लोट के तौर पर दिखाता है जिसमें शून्य हो सकता है.
इंट?	`Cursor.getIntOrNull(index: Int)` अनुरोध किए गए कॉलम की वैल्यू को, नल हो सकने वाले पूर्णांक के तौर पर दिखाता है.
लंबी?	`Cursor.getLongOrNull(index: Int)` अनुरोध किए गए कॉलम की वैल्यू को, नल हो सकने वाली लंबी वैल्यू के तौर पर दिखाता है.
शॉर्ट?	`Cursor.getShortOrNull(index: Int)` यह फ़ंक्शन, अनुरोध किए गए कॉलम की वैल्यू को Nullable Short के तौर पर दिखाता है.
String?	`Cursor.getStringOrNull(index: Int)` अनुरोध किए गए कॉलम की वैल्यू को, नल हो सकने वाली स्ट्रिंग के तौर पर दिखाता है.

androidx.core.database.sqlite

डिपेंडेंसी

Groovy

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

Kotlin

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

एक्सटेंशन फ़ंक्शन

android.database.sqlite.SQLiteDatabase के लिए

T	`SQLiteDatabase.transaction(exclusive: Boolean = true, body: SQLiteDatabase.() -> T)` अगर body बिना किसी गड़बड़ी के पूरा हो जाता है, तो उसे लेन-देन में शामिल करें और उसे 'सफल' के तौर पर मार्क करें.

androidx.core.graphics

डिपेंडेंसी

Groovy

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

Kotlin

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

एक्सटेंशन फ़ंक्शन

android.graphics.Bitmap के लिए

बिटमैप	`Bitmap.applyCanvas(block: Canvas.() -> Unit)` यह बिटमैप पर ड्रॉ करने के लिए, एक नया कैनवस बनाता है. साथ ही, नए कैनवस पर बताए गए ब्लॉक को लागू करता है.
operator Boolean	`Bitmap.contains(p: Point)` अगर बताया गया पॉइंट, बिटमैप के अंदर है, तो यह फ़ंक्शन 'सही' दिखाता है.
operator Boolean	`Bitmap.contains(p: PointF)` अगर बताया गया पॉइंट, बिटमैप के अंदर है, तो यह फ़ंक्शन 'सही' दिखाता है.
operator Int	`Bitmap.get(x: Int, y: Int)` यह फ़ंक्शन, तय की गई जगह पर मौजूद पिक्सल की वैल्यू दिखाता है.
बिटमैप	`Bitmap.scale(width: Int, height: Int, filter: Boolean = true)` यह फ़ंक्शन, इस बिटमैप से स्केल किया गया एक नया बिटमैप बनाता है. हालांकि, ऐसा सिर्फ़ तब किया जाता है, जब यह मुमकिन हो.
operator Unit	`Bitmap.set(x: Int, y: Int, color: Int)` यह फ़ंक्शन, दिए गए `(x, y)` कोऑर्डिनेट पर, बिटमैप में तय किया गया color int लिखता है. हालांकि, ऐसा तब ही होता है, जब बिटमैप में बदलाव किया जा सकता हो.

android.graphics.Canvas के लिए

यूनिट	`Canvas.withClip(clipRect: Rect, block: Canvas.() -> Unit)` बताए गए ब्लॉक को Canvas.save/Canvas.clipRect और Canvas.restoreToCount के कॉल में रैप करें.
यूनिट	`Canvas.withClip(clipRect: RectF, block: Canvas.() -> Unit)` बताए गए ब्लॉक को Canvas.save/Canvas.clipRect और Canvas.restoreToCount के कॉल में रैप करें.
यूनिट	`Canvas.withClip(left: Int, top: Int, right: Int, bottom: Int, block: Canvas.() -> Unit)` बताए गए ब्लॉक को Canvas.save/Canvas.clipRect और Canvas.restoreToCount के कॉल में रैप करें.
यूनिट	`Canvas.withClip(left: Float, top: Float, right: Float, bottom: Float, block: Canvas.() -> Unit)` बताए गए ब्लॉक को Canvas.save/Canvas.clipRect और Canvas.restoreToCount के कॉल में रैप करें.
यूनिट	`Canvas.withClip(clipPath: Path, block: Canvas.() -> Unit)` बताए गए ब्लॉक को Canvas.save/Canvas.clipPath और Canvas.restoreToCount के कॉल में रैप करें.
यूनिट	`Canvas.withMatrix(matrix: Matrix = Matrix(), block: Canvas.() -> Unit)` ब्लॉक को Canvas.save/Canvas.concat और Canvas.restoreToCount के कॉल में रैप करें.
यूनिट	`Canvas.withRotation(degrees: Float = 0.0f, pivotX: Float = 0.0f, pivotY: Float = 0.0f, block: Canvas.() -> Unit)` बताए गए ब्लॉक को Canvas.save/Canvas.rotate और Canvas.restoreToCount के कॉल में रैप करें.
यूनिट	`Canvas.withSave(block: Canvas.() -> Unit)` बताए गए ब्लॉक को Canvas.save और Canvas.restoreToCount के कॉल में रैप करें.
यूनिट	`Canvas.withScale(x: Float = 1.0f, y: Float = 1.0f, pivotX: Float = 0.0f, pivotY: Float = 0.0f, block: Canvas.() -> Unit)` बताए गए ब्लॉक को Canvas.save/Canvas.scale और Canvas.restoreToCount के कॉल में रैप करें.
यूनिट	`Canvas.withSkew(x: Float = 0.0f, y: Float = 0.0f, block: Canvas.() -> Unit)` ब्लॉक को Canvas.save/Canvas.skew और Canvas.restoreToCount के कॉल में रैप करें.
यूनिट	`Canvas.withTranslation(x: Float = 0.0f, y: Float = 0.0f, block: Canvas.() -> Unit)` ब्लॉक को Canvas.save/Canvas.translate और Canvas.restoreToCount के कॉल में रैप करें.

android.graphics.Color के लिए

operator Float	`Color.component1()` यह फ़ंक्शन, रंग का पहला कॉम्पोनेंट दिखाता है.
operator Float	`Color.component2()` यह फ़ंक्शन, रंग के दूसरे कॉम्पोनेंट की वैल्यू दिखाता है.
operator Float	`Color.component3()` यह फ़ंक्शन, रंग का तीसरा कॉम्पोनेंट दिखाता है.
operator Float	`Color.component4()` यह रंग का चौथा कॉम्पोनेंट दिखाता है.
infix Color!	`Color.convertTo(colorSpace: Named)` कलर रिसीवर को तय किए गए कलर स्पेस में मौजूद किसी रंग में बदलता है.
infix Color!	`Color.convertTo(colorSpace: ColorSpace)` कलर रिसीवर को तय किए गए कलर स्पेस में मौजूद किसी रंग में बदलता है.
operator Color	`Color.plus(c: Color)` यह फ़ंक्शन, दो पारदर्शी रंगों को एक साथ कंपोज़ करता है.

android.graphics.ImageDecoder.Source के लिए

बिटमैप	`Source.decodeBitmap(crossinline action: ImageDecoder.(info: ImageInfo, source: Source) -> Unit)` सोर्स से बिटमैप बनाना
Drawable	`Source.decodeDrawable(crossinline action: ImageDecoder.(info: ImageInfo, source: Source) -> Unit)` किसी सोर्स से Drawable बनाना

android.graphics.Matrix के लिए

operator Matrix	`Matrix.times(m: Matrix)` इस Matrix को किसी अन्य मैट्रिक्स से गुणा करता है और नतीजे को नए मैट्रिक्स के तौर पर दिखाता है.
FloatArray	`Matrix.values()` इस मैट्रिक्स की नौ वैल्यू को फ़्लोटिंग पॉइंट नंबर की नई श्रेणी के तौर पर दिखाता है.

android.graphics.Paint के लिए

बूलियन

Paint.setBlendMode(blendModeCompat: BlendModeCompat?)

यह एक आसान तरीका है, जिसकी मदद से Paint के BlendMode को बैकवर्ड कंपैटिबल तरीके से कॉन्फ़िगर किया जा सकता है.

android.graphics.Path के लिए

infix Path	`Path.and(p: Path)` दो पाथ के इंटरसेक्शन को नए पाथ के तौर पर दिखाता है.
Iterable<PathSegment>	`Path.flatten(error: Float = 0.5f)` यह फ़ंक्शन, लाइन सेगमेंट की सीरीज़ का इस्तेमाल करके पाथ को फ़्लैट करता है या उसका अनुमान लगाता है.
operator Path	`Path.minus(p: Path)` दो पाथ के अंतर को नए पाथ के तौर पर दिखाता है.
infix Path	`Path.or(p: Path)` दो पाथ के यूनीयन को नए पाथ के तौर पर दिखाता है.
operator Path	`Path.plus(p: Path)` दो पाथ के यूनीयन को नए पाथ के तौर पर दिखाता है.
infix Path	`Path.xor(p: Path)` दो पाथ के यूनीयन में से इंटरसेक्शन को घटाकर, नए पाथ के तौर पर दिखाता है.

android.graphics.Picture के लिए

तस्वीर

Picture.record(width: Int, height: Int, block: Canvas.() -> Unit)

यह इस Picture में कमांड रिकॉर्ड करने के लिए, एक नया Canvas बनाता है. साथ ही, नए कैनवस पर तय किया गया block लागू करता है और इस Picture को दिखाता है.

android.graphics.Point के लिए

operator Int	`Point.component1()` यह फ़ंक्शन, इस पॉइंट का x कॉर्डिनेट दिखाता है.
operator Int	`Point.component2()` यह फ़ंक्शन, इस पॉइंट का y कॉर्डिनेट दिखाता है.
operator Point	`Point.minus(p: Point)` यह फ़ंक्शन, इस पॉइंट को तय किए गए पॉइंट के नेगेशन से ऑफ़सेट करता है और नतीजे को नए पॉइंट के तौर पर दिखाता है.
operator Point	`Point.minus(xy: Int)` यह फ़ंक्शन, इस पॉइंट को X और Y ऐक्सिस, दोनों पर बताई गई रकम के हिसाब से ऑफ़सेट करता है. साथ ही, नतीजे को नए पॉइंट के तौर पर दिखाता है.
operator Point	`Point.plus(p: Point)` इस पॉइंट को तय किए गए पॉइंट से ऑफ़सेट करता है और नतीजे को नए पॉइंट के तौर पर दिखाता है.
operator Point	`Point.plus(xy: Int)` यह फ़ंक्शन, इस पॉइंट को X और Y ऐक्सिस, दोनों पर तय की गई वैल्यू से ऑफ़सेट करता है. साथ ही, नतीजे को नए पॉइंट के तौर पर दिखाता है.
PointF	`Point.toPointF()` यह फ़ंक्शन, इस पॉइंट का PointF वर्शन दिखाता है.
operator Point	`Point.unaryMinus()` यह फ़ंक्शन, इस पॉइंट के नेगेशन को दिखाने वाला नया पॉइंट दिखाता है.

android.graphics.PointF के लिए

operator Float	`PointF.component1()` यह फ़ंक्शन, इस पॉइंट का x कॉर्डिनेट दिखाता है.
operator Float	`PointF.component2()` यह फ़ंक्शन, इस पॉइंट का y कॉर्डिनेट दिखाता है.
operator PointF	`PointF.minus(p: PointF)` यह फ़ंक्शन, इस पॉइंट को तय किए गए पॉइंट के नेगेशन से ऑफ़सेट करता है और नतीजे को नए पॉइंट के तौर पर दिखाता है.
operator PointF	`PointF.minus(xy: Float)` यह फ़ंक्शन, इस पॉइंट को X और Y ऐक्सिस, दोनों पर बताई गई रकम के हिसाब से ऑफ़सेट करता है. साथ ही, नतीजे को नए पॉइंट के तौर पर दिखाता है.
operator PointF	`PointF.plus(p: PointF)` इस पॉइंट को तय किए गए पॉइंट से ऑफ़सेट करता है और नतीजे को नए पॉइंट के तौर पर दिखाता है.
operator PointF	`PointF.plus(xy: Float)` यह फ़ंक्शन, इस पॉइंट को X और Y ऐक्सिस, दोनों पर तय की गई वैल्यू से ऑफ़सेट करता है. साथ ही, नतीजे को नए पॉइंट के तौर पर दिखाता है.
पॉइंट	`PointF.toPoint()` यह फ़ंक्शन, इस पॉइंट का Point वर्शन दिखाता है.
operator PointF	`PointF.unaryMinus()` यह फ़ंक्शन, इस पॉइंट के नेगेशन को दिखाने वाला नया पॉइंट दिखाता है.

android.graphics.PorterDuff.Mode के लिए

PorterDuffColorFilter

Mode.toColorFilter(color: Int)

यह एक नया PorterDuffColorFilter बनाता है. यह PorterDuff.Mode को ऐल्फ़ा कंपोज़िटिंग या ब्लेंडिंग मोड के तौर पर इस्तेमाल करता है. साथ ही, यह तय किए गए color का इस्तेमाल करता है.

PorterDuffXfermode

Mode.toXfermode()

यह एक नया PorterDuffXfermode बनाता है, जो इस PorterDuff.Mode का इस्तेमाल ऐल्फ़ा कंपोज़िटिंग या ब्लेंडिंग मोड के तौर पर करता है.

android.graphics.Rect के लिए

infix Rect	`Rect.and(r: Rect)` दो आयतों के इंटरसेक्शन को नई आयत के तौर पर दिखाता है.
operator Int	`Rect.component1()` यह फ़ंक्शन, रेक्टैंगल का पहला कॉम्पोनेंट "left" दिखाता है.
operator Int	`Rect.component2()` यह फ़ंक्शन, "top" वैल्यू दिखाता है. यह वैल्यू, रेक्टैंगल का दूसरा कॉम्पोनेंट होती है.
operator Int	`Rect.component3()` यह फ़ंक्शन, रेक्टैंगल के तीसरे कॉम्पोनेंट "right" की वैल्यू दिखाता है.
operator Int	`Rect.component4()` यह फ़ंक्शन, "bottom" दिखाता है. यह आयत का चौथा कॉम्पोनेंट होता है.
operator Boolean	`Rect.contains(p: Point)` अगर बताया गया पॉइंट, रेक्टैंगल के अंदर है, तो यह फ़ंक्शन 'सही' दिखाता है.
operator Region	`Rect.minus(r: Rect)` यह फ़ंक्शन, इस रेक्टैंगल और तय किए गए रेक्टैंगल के बीच के अंतर को नए क्षेत्र के तौर पर दिखाता है.
operator Rect	`Rect.minus(xy: Int)` यह फ़ंक्शन, एक नया रेक्टैंगल दिखाता है. यह रेक्टैंगल, X और Y ऐक्सिस पर तय की गई रकम के नेगेटिव मान से ऑफ़सेट होता है.
operator Rect	`Rect.minus(xy: Point)` यह फ़ंक्शन, एक नया रेक्टैंगल दिखाता है. यह रेक्टैंगल, दिए गए पॉइंट के नेगेटिव ऑफ़सेट से बना होता है.
infix Rect	`Rect.or(r: Rect)` दो आयतों के यूनियन को नई आयत के तौर पर दिखाता है.
operator Rect	`Rect.plus(r: Rect)` यह फ़ंक्शन, इस रेक्टैंगल और तय किए गए रेक्टैंगल को जोड़ता है. साथ ही, नतीजे को नए रेक्टैंगल के तौर पर दिखाता है.
operator Rect	`Rect.plus(xy: Int)` यह फ़ंक्शन, एक नया रेक्टैंगल दिखाता है. यह रेक्टैंगल, X और Y ऐक्सिस पर तय की गई वैल्यू के हिसाब से ऑफ़सेट होता है.
operator Rect	`Rect.plus(xy: Point)` यह फ़ंक्शन, एक नया रेक्टैंगल दिखाता है. यह रेक्टैंगल, तय किए गए पॉइंट से ऑफ़सेट होता है.
operator Rect	`Rect.times(factor: Int)` यह फ़ंक्शन, एक नया रेक्टैंगल दिखाता है. इसमें इस रेक्टैंगल के हर कॉम्पोनेंट को factor के हिसाब से स्केल किया जाता है.
RectF	`Rect.toRectF()` यह फ़ंक्शन, इस रेक्टैंगल का RectF दिखाता है.
क्षेत्र	`Rect.toRegion()` इस आयत का Region दिखाता है.
infix Region	`Rect.xor(r: Rect)` दो आयतों के यूनीयन में से इंटरसेक्शन को घटाकर, नई जगह के तौर पर दिखाता है.

android.graphics.RectF के लिए

infix RectF	`RectF.and(r: RectF)` दो आयतों के इंटरसेक्शन को नई आयत के तौर पर दिखाता है.
operator Float	`RectF.component1()` यह फ़ंक्शन, रेक्टैंगल का पहला कॉम्पोनेंट "left" दिखाता है.
operator Float	`RectF.component2()` यह फ़ंक्शन, "top" वैल्यू दिखाता है. यह वैल्यू, रेक्टैंगल का दूसरा कॉम्पोनेंट होती है.
operator Float	`RectF.component3()` यह फ़ंक्शन, रेक्टैंगल के तीसरे कॉम्पोनेंट "right" की वैल्यू दिखाता है.
operator Float	`RectF.component4()` यह फ़ंक्शन, "bottom" दिखाता है. यह आयत का चौथा कॉम्पोनेंट होता है.
operator Boolean	`RectF.contains(p: PointF)` अगर बताया गया पॉइंट, रेक्टैंगल के अंदर है, तो यह फ़ंक्शन 'सही' दिखाता है.
operator Region	`RectF.minus(r: RectF)` यह फ़ंक्शन, इस रेक्टैंगल और तय किए गए रेक्टैंगल के बीच के अंतर को नए क्षेत्र के तौर पर दिखाता है.
operator RectF	`RectF.minus(xy: Float)` यह फ़ंक्शन, एक नया रेक्टैंगल दिखाता है. यह रेक्टैंगल, X और Y ऐक्सिस पर तय की गई रकम के नेगेटिव मान से ऑफ़सेट होता है.
operator RectF	`RectF.minus(xy: PointF)` यह फ़ंक्शन, एक नया रेक्टैंगल दिखाता है. यह रेक्टैंगल, दिए गए पॉइंट के नेगेटिव ऑफ़सेट से बना होता है.
infix RectF	`RectF.or(r: RectF)` दो आयतों के यूनियन को नई आयत के तौर पर दिखाता है.
operator RectF	`RectF.plus(r: RectF)` यह फ़ंक्शन, इस रेक्टैंगल और तय किए गए रेक्टैंगल को जोड़ता है. साथ ही, नतीजे को नए रेक्टैंगल के तौर पर दिखाता है.
operator RectF	`RectF.plus(xy: Float)` यह फ़ंक्शन, एक नया रेक्टैंगल दिखाता है. यह रेक्टैंगल, X और Y ऐक्सिस पर तय की गई वैल्यू के हिसाब से ऑफ़सेट होता है.
operator RectF	`RectF.plus(xy: PointF)` यह फ़ंक्शन, एक नया रेक्टैंगल दिखाता है. यह रेक्टैंगल, तय किए गए पॉइंट से ऑफ़सेट होता है.
operator RectF	`RectF.times(factor: Int)` यह फ़ंक्शन, एक नया रेक्टैंगल दिखाता है. इसमें इस रेक्टैंगल के हर कॉम्पोनेंट को factor के हिसाब से स्केल किया जाता है.
operator RectF	`RectF.times(factor: Float)` यह फ़ंक्शन, एक नया रेक्टैंगल दिखाता है. इसमें इस रेक्टैंगल के हर कॉम्पोनेंट को factor के हिसाब से स्केल किया जाता है.
Rect	`RectF.toRect()` यह फ़ंक्शन, इस रेक्टैंगल का Rect वर्शन दिखाता है.
क्षेत्र	`RectF.toRegion()` इस आयत का Region दिखाता है.
RectF	`RectF.transform(m: Matrix)` इस फ़ंक्शन की मदद से, दिए गए मैट्रिक्स का इस्तेमाल करके, इस रेक्टैंगल को उसी जगह पर ट्रांसफ़ॉर्म किया जाता है. साथ ही, यह रेक्टैंगल वापस मिलता है.
infix Region	`RectF.xor(r: RectF)` दो आयतों के यूनीयन में से इंटरसेक्शन को घटाकर, नई जगह के तौर पर दिखाता है.

android.graphics.Region के लिए

infix Region	`Region.and(r: Rect)` इस क्षेत्र और तय किए गए Rect के इंटरसेक्शन को एक नए क्षेत्र के तौर पर दिखाता है.
infix Region	`Region.and(r: Region)` इस क्षेत्र और तय किए गए क्षेत्र के इंटरसेक्शन को नए क्षेत्र के तौर पर दिखाता है.
operator Boolean	`Region.contains(p: Point)` अगर क्षेत्र में बताया गया Point मौजूद है, तो 'सही' दिखाता है.
यूनिट	`Region.forEach(action: (rect: Rect) -> Unit)` इस क्षेत्र में मौजूद हर आयत पर, दी गई कार्रवाई करता है.
operator Iterator<Rect>	`Region.iterator()` इस क्षेत्र में मौजूद रेक्ट के लिए, Iterator दिखाता है.
operator Region	`Region.minus(r: Rect)` इस क्षेत्र और तय किए गए Rect के बीच के अंतर को नए क्षेत्र के तौर पर दिखाता है.
operator Region	`Region.minus(r: Region)` इस क्षेत्र और चुने गए क्षेत्र के बीच के अंतर को नए क्षेत्र के तौर पर दिखाएं.
operator Region	`Region.not()` यह फ़ंक्शन, इस क्षेत्र के नेगेशन को नए क्षेत्र के तौर पर दिखाता है.
infix Region	`Region.or(r: Rect)` इस क्षेत्र और तय किए गए Rect के यूनियन को नए क्षेत्र के तौर पर दिखाता है.
infix Region	`Region.or(r: Region)` इस क्षेत्र और तय किए गए क्षेत्र के यूनियन को एक नए क्षेत्र के तौर पर दिखाता है.
operator Region	`Region.plus(r: Rect)` इस क्षेत्र और तय किए गए Rect के यूनियन को नए क्षेत्र के तौर पर दिखाता है.
operator Region	`Region.plus(r: Region)` इस क्षेत्र और तय किए गए क्षेत्र के यूनियन को एक नए क्षेत्र के तौर पर दिखाता है.
operator Region	`Region.unaryMinus()` यह फ़ंक्शन, इस क्षेत्र के नेगेशन को नए क्षेत्र के तौर पर दिखाता है.
infix Region	`Region.xor(r: Rect)` इस क्षेत्र और तय किए गए Rect के इंटरसेक्शन को छोड़कर, यूनियन को एक नए क्षेत्र के तौर पर दिखाता है.
infix Region	`Region.xor(r: Region)` इस क्षेत्र और तय किए गए क्षेत्र के यूनीयन में से इंटरसेक्शन को घटाकर, एक नया क्षेत्र दिखाता है.

android.graphics.Shader के लिए

यूनिट

Shader.transform(block: Matrix.() -> Unit)

बताए गए ब्लॉक को Shader.getLocalMatrix और Shader.setLocalMatrix के कॉल में रैप करें.

kotlin.Int के लिए

operator Int	`Int.component1()` यह किसी कलर इंट का ऐल्फ़ा कॉम्पोनेंट दिखाता है.
operator Int	`Int.component2()` किसी कलर इंट का लाल कॉम्पोनेंट दिखाता है.
operator Int	`Int.component3()` किसी कलर इंट का ग्रीन कॉम्पोनेंट दिखाता है.
operator Int	`Int.component4()` किसी कलर इंट का नीला कॉम्पोनेंट दिखाता है.
infix Long	`Int.convertTo(colorSpace: Named)` यह फ़ंक्शन, रिसीवर में मौजूद कलर इंट को तय किए गए कलर स्पेस में कलर लॉन्ग में बदलता है.
infix Long	`Int.convertTo(colorSpace: ColorSpace)` यह फ़ंक्शन, रिसीवर में मौजूद कलर इंट को तय किए गए कलर स्पेस में कलर लॉन्ग में बदलता है.
रंग	`Int.toColor()` यह कलर इंट से नया Color इंस्टेंस बनाता है.
Long	`Int.toColorLong()` यह फ़ंक्शन, दिए गए ARGB color int को sRGB कलर स्पेस में RGBA color long में बदलता है.

kotlin.Long के लिए

operator Float	`Long.component1()` यह फ़ंक्शन, रंग का पहला कॉम्पोनेंट दिखाता है.
operator Float	`Long.component2()` यह फ़ंक्शन, रंग के दूसरे कॉम्पोनेंट की वैल्यू दिखाता है.
operator Float	`Long.component3()` यह फ़ंक्शन, रंग का तीसरा कॉम्पोनेंट दिखाता है.
operator Float	`Long.component4()` यह रंग का चौथा कॉम्पोनेंट दिखाता है.
infix Long	`Long.convertTo(colorSpace: Named)` इस फ़ंक्शन की मदद से, कलर लॉन्ग रिसीवर को तय किए गए कलर स्पेस में कलर लॉन्ग में बदला जाता है.
infix Long	`Long.convertTo(colorSpace: ColorSpace)` इस फ़ंक्शन की मदद से, कलर लॉन्ग रिसीवर को तय किए गए कलर स्पेस में कलर लॉन्ग में बदला जाता है.
रंग	`Long.toColor()` यह color long से एक नया Color इंस्टेंस बनाता है.
Int	`Long.toColorInt()` यह फ़ंक्शन, तय किए गए color long को ARGB color int में बदलता है.

kotlin.String के लिए

Int	`String.toColorInt()` इस String के हिसाब से, Int कलर दिखाता है.

एक्सटेंशन प्रॉपर्टी

kotlin.Int के लिए

Int	`Int.alpha()` यह किसी कलर इंट का ऐल्फ़ा कॉम्पोनेंट दिखाता है.
Int	`Int.blue()` किसी कलर इंट का नीला कॉम्पोनेंट दिखाता है.
Int	`Int.green()` किसी कलर इंट का ग्रीन कॉम्पोनेंट दिखाता है.
फ़्लोट	`Int.luminance()` यह फ़ंक्शन, sRGB एन्कोडिंग के आधार पर, किसी रंग की इंट वैल्यू की रिलेटिव ल्यूमिनेंस दिखाता है.
Int	`Int.red()` किसी कलर इंट का लाल कॉम्पोनेंट दिखाता है.

kotlin.Long के लिए

फ़्लोट	`Long.alpha()` कलर लॉन्ग के ऐल्फ़ा कॉम्पोनेंट की वैल्यू दिखाता है.
फ़्लोट	`Long.blue()` कलर लॉन्ग के नीले कॉम्पोनेंट की वैल्यू दिखाता है.
ColorSpace	`Long.colorSpace()` यह फ़ंक्शन, तय किए गए कलर लॉन्ग में कोड किए गए कलर स्पेस को दिखाता है.
फ़्लोट	`Long.green()` कलर लॉन्ग के ग्रीन कॉम्पोनेंट की वैल्यू दिखाता है.
बूलियन	`Long.isSrgb()` इससे पता चलता है कि रंग, sRGB कलर स्पेस में है या नहीं.
बूलियन	`Long.isWideGamut()` यह बताता है कि रंग, वाइड-गैमट कलर स्पेस में है या नहीं.
फ़्लोट	`Long.luminance()` किसी रंग की रिलेटिव ल्यूमिनेंस दिखाता है.
फ़्लोट	`Long.red()` कलर लॉन्ग के लाल कॉम्पोनेंट की वैल्यू दिखाता है.

टॉप-लेवल फ़ंक्शन

बिटमैप	`createBitmap(width: Int, height: Int, config: Config = Bitmap.Config.ARGB_8888)` यह फ़ंक्शन, तय की गई चौड़ाई और ऊंचाई वाला एक ऐसा बिटमैप दिखाता है जिसमें बदलाव किया जा सकता है.
बिटमैप	`createBitmap(width: Int, height: Int, config: Config = Bitmap.Config.ARGB_8888, hasAlpha: Boolean = true, colorSpace: ColorSpace = ColorSpace.get(ColorSpace.Named.SRGB))` यह फ़ंक्शन, तय की गई चौड़ाई और ऊंचाई वाला एक ऐसा बिटमैप दिखाता है जिसमें बदलाव किया जा सकता है.
मैट्रिक्स	`rotationMatrix(degrees: Float, px: Float = 0.0f, py: Float = 0.0f)` यह एक रोटेशन मैट्रिक्स बनाता है. इसे पिवट पॉइंट के चारों ओर डिग्री में रोटेशन ऐंगल के हिसाब से तय किया जाता है. पिवट पॉइंट, (px, py) कोऑर्डिनेट पर मौजूद होता है.
मैट्रिक्स	`scaleMatrix(sx: Float = 1.0f, sy: Float = 1.0f)` यह फ़ंक्शन, स्केल मैट्रिक्स बनाता है. इसमें `x` और `y` ऐक्सिस पर स्केल फ़ैक्टर, sx और sy होता है.
मैट्रिक्स	`translationMatrix(tx: Float = 0.0f, ty: Float = 0.0f)` यह फ़ंक्शन, ट्रांसलेशन मैट्रिक्स बनाता है. इसमें `x` और `y` ऐक्सिस पर ट्रांसलेशन की मात्रा tx और ty होती है.

androidx.core.graphics.drawable

डिपेंडेंसी

Groovy

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

Kotlin

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

एक्सटेंशन फ़ंक्शन

android.graphics.Bitmap के लिए

आइकॉन	`Bitmap.toAdaptiveIcon()` इस अडैप्टिव बिटमैप से आइकॉन बनाएं.
BitmapDrawable	`Bitmap.toDrawable(resources: Resources)` इस Bitmap से BitmapDrawable बनाएं.
आइकॉन	`Bitmap.toIcon()` इस बिटमैप से आइकॉन बनाएं.

android.graphics.Color के लिए

ColorDrawable

Color.toDrawable()

इस Color से ColorDrawable बनाएं (Color.toArgb के ज़रिए).

android.graphics.drawable.Drawable के लिए

बिटमैप	`Drawable.toBitmap(@Px width: Int = intrinsicWidth, @Px height: Int = intrinsicHeight, config: Config? = null)` इस Drawable का Bitmap वर्शन दिखाता है.
यूनिट	`Drawable.updateBounds(@Px left: Int = bounds.left, @Px top: Int = bounds.top, @Px right: Int = bounds.right, @Px bottom: Int = bounds.bottom)` यह फ़ंक्शन, इस ड्रॉएबल की सीमाओं को अपडेट करता है.

android.net.Uri के लिए

आइकॉन

Uri.toIcon()

इस Uri से एक आइकॉन बनाओ.

kotlin.ByteArray के लिए

आइकॉन

ByteArray.toIcon()

इस ByteArray से एक Icon बनाएं.

kotlin.Int के लिए

ColorDrawable

Int.toDrawable()

इस कलर वैल्यू से ColorDrawable बनाएं.

androidx.core.location

डिपेंडेंसी

Groovy

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

Kotlin

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

एक्सटेंशन फ़ंक्शन

android.location.Location के लिए

operator Double	`Location.component1()` इस जगह का अक्षांश दिखाता है.
operator Double	`Location.component2()` इस Location का देशांतर दिखाता है.

androidx.core.net

डिपेंडेंसी

Groovy

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

Kotlin

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

एक्सटेंशन फ़ंक्शन

android.net.Uri के लिए

फ़ाइल

Uri.toFile()

यह दिए गए Uri से File बनाता है.

java.io.File के लिए

Uri	`File.toUri()` यह दी गई फ़ाइल से यूआरआई बनाता है.

kotlin.String के लिए

Uri	`String.toUri()` यह फ़ंक्शन, दी गई कोड में बदली गई यूआरआई स्ट्रिंग से एक यूआरआई बनाता है.

androidx.core.os

डिपेंडेंसी

Groovy

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

Kotlin

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

एक्सटेंशन फ़ंक्शन

android.os.Handler के लिए

Runnable	`Handler.postAtTime(uptimeMillis: Long, token: Any? = null, crossinline action: () -> Unit)` यह Handler.postAtTime का ऐसा वर्शन है जो पैरामीटर को फिर से क्रम में लगाता है. इससे कार्रवाई को कोष्ठक के बाहर रखा जा सकता है.
Runnable	`Handler.postDelayed(delayInMillis: Long, token: Any? = null, crossinline action: () -> Unit)` यह Handler.postDelayed का ऐसा वर्शन है जिसमें पैरामीटर का क्रम बदला गया है. इससे कार्रवाई को कोष्ठक के बाहर रखा जा सकता है.

टॉप-लेवल फ़ंक्शन

बंडल	`bundleOf(vararg pairs: Pair<String, Any?>)` यह फ़ंक्शन, दिए गए कुंजी/वैल्यू पेयर को एलिमेंट के तौर पर इस्तेमाल करके, नया Bundle दिखाता है.
PersistableBundle	`persistableBundleOf(vararg pairs: Pair<String, Any?>)` यह फ़ंक्शन, दिए गए कुंजी/वैल्यू पेयर को एलिमेंट के तौर पर इस्तेमाल करके, नया PersistableBundle दिखाता है.
T	`trace(sectionName: String, block: () -> T)` दिए गए ब्लॉक को Trace.beginSection (दिए गए sectionName के साथ) और Trace.endSection के कॉल में रैप करें.

androidx.core.text

डिपेंडेंसी

Groovy

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

Kotlin

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

एक्सटेंशन फ़ंक्शन

android.text.Spannable के लिए

यूनिट	`Spannable.clearSpans()` इस टेक्स्ट से सभी स्पैन हटाएं.
operator Unit	`Spannable.set(start: Int, end: Int, span: Any)` टेक्स्ट की रेंज start…end में span जोड़ें.
operator Unit	`Spannable.set(range: IntRange, span: Any)` टेक्स्ट की range में span जोड़ें.

android.text.SpannableStringBuilder के लिए

SpannableStringBuilder	`SpannableStringBuilder.backgroundColor(color: Int, builderAction: SpannableStringBuilder.() -> Unit)` जोड़े गए टेक्स्ट को BackgroundColorSpan में builderAction में रैप करें.
SpannableStringBuilder	`SpannableStringBuilder.bold(builderAction: SpannableStringBuilder.() -> Unit)` जोड़े गए टेक्स्ट को बोल्ड StyleSpan में builderAction में रैप करें.
SpannableStringBuilder	`SpannableStringBuilder.color(color: Int, builderAction: SpannableStringBuilder.() -> Unit)` जोड़े गए टेक्स्ट को ForegroundColorSpan में builderAction में रैप करें.
SpannableStringBuilder	`SpannableStringBuilder.inSpans(vararg spans: Any, builderAction: SpannableStringBuilder.() -> Unit)` जोड़ा गया टेक्स्ट, spans में मौजूद builderAction में रैप करें.
SpannableStringBuilder	`SpannableStringBuilder.inSpans(span: Any, builderAction: SpannableStringBuilder.() -> Unit)` span में जोड़े गए टेक्स्ट को builderAction में रैप करें.
SpannableStringBuilder	`SpannableStringBuilder.italic(builderAction: SpannableStringBuilder.() -> Unit)` जोड़ा गया टेक्स्ट, इटैलिक StyleSpan में builderAction में रैप करें.
SpannableStringBuilder	`SpannableStringBuilder.scale(proportion: Float, builderAction: SpannableStringBuilder.() -> Unit)` RelativeSizeSpan में, जोड़े गए टेक्स्ट को builderAction में रैप करें.
SpannableStringBuilder	`SpannableStringBuilder.strikeThrough(builderAction: SpannableStringBuilder.() -> Unit)` जोड़े गए टेक्स्ट को StrikethroughSpan में builderAction में रैप करें.
SpannableStringBuilder	`SpannableStringBuilder.subscript(builderAction: SpannableStringBuilder.() -> Unit)` जोड़े गए टेक्स्ट को SubscriptSpan में builderAction में रैप करें.
SpannableStringBuilder	`SpannableStringBuilder.superscript(builderAction: SpannableStringBuilder.() -> Unit)` SuperscriptSpan में, जोड़े गए टेक्स्ट को builderAction में रैप करें.
SpannableStringBuilder	`SpannableStringBuilder.underline(builderAction: SpannableStringBuilder.() -> Unit)` UnderlineSpan में builderAction में जोड़े गए टेक्स्ट को रैप करें.

android.text.Spanned के लिए

Array<out T>	`Spanned.getSpans(start: Int = 0, end: Int = length)` T के सभी इंस्टेंस वाले स्पैन पाएं.
String	`Spanned.toHtml(option: Int = TO_HTML_PARAGRAPH_LINES_CONSECUTIVE)` इस Spanned में मौजूद स्पैन से एचटीएमएल की एक स्ट्रिंग दिखाता है.

kotlin.CharSequence के लिए

बूलियन	`CharSequence.isDigitsOnly()` यह फ़ंक्शन बताता है कि दिए गए CharSequence में सिर्फ़ अंक हैं या नहीं.
Spannable	`CharSequence.toSpannable()` यह CharSequence से एक नया Spannable दिखाता है. अगर सोर्स पहले से ही SpannableString का इंस्टेंस है, तो यह सोर्स को ही दिखाता है.
स्पैन किया गया	`CharSequence.toSpanned()` यह CharSequence से एक नया Spanned दिखाता है. अगर सोर्स पहले से ही SpannedString का इंस्टेंस है, तो यह सोर्स को ही दिखाता है.
Int	`CharSequence.trimmedLength()` यह फ़ंक्शन, CharSequence की उस लंबाई को दिखाता है जिसमें String.trim फ़ंक्शन की तरह, शुरुआत और आखिर के स्पेस और ASCII कंट्रोल वर्णों को हटा दिया गया हो.

kotlin.String के लिए

String	`String.htmlEncode()` स्ट्रिंग को एचटीएमएल-कोड में बदलें.
स्पैन किया गया	`String.parseAsHtml(flags: Int = FROM_HTML_MODE_LEGACY, imageGetter: ImageGetter? = null, tagHandler: TagHandler? = null)` इस स्ट्रिंग को एचटीएमएल के तौर पर पार्स करके, Spanned दिखाता है.

एक्सटेंशन प्रॉपर्टी

java.util.Locale के लिए

Int	`Locale.layoutDirection()` किसी भाषा के लिए लेआउट की दिशा दिखाता है.

टॉप-लेवल फ़ंक्शन

SpannedString

buildSpannedString(builderAction: SpannableStringBuilder.() -> Unit)

यह फ़ंक्शन, नई स्ट्रिंग बनाता है. इसके लिए, यह दिए गए builderAction का इस्तेमाल करके, नए बनाए गए SpannableStringBuilder को पॉप्युलेट करता है. इसके बाद, इसे SpannedString में बदलता है.

androidx.core.transition

डिपेंडेंसी

Groovy

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

Kotlin

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

एक्सटेंशन फ़ंक्शन

android.transition.Transition के लिए

TransitionListener	`Transition.addListener(crossinline onEnd: (transition: Transition) -> Unit = {}, crossinline onStart: (transition: Transition) -> Unit = {}, crossinline onCancel: (transition: Transition) -> Unit = {}, crossinline onResume: (transition: Transition) -> Unit = {}, crossinline onPause: (transition: Transition) -> Unit = {})` दी गई कार्रवाइयों का इस्तेमाल करके, इस ट्रांज़िशन में लिसनर जोड़ें.
TransitionListener	`Transition.doOnCancel(crossinline action: (transition: Transition) -> Unit)` ऐसी कार्रवाई जोड़ें जिसे इस ट्रांज़िशन के रद्द होने पर शुरू किया जाएगा.
TransitionListener	`Transition.doOnEnd(crossinline action: (transition: Transition) -> Unit)` ऐसी कार्रवाई जोड़ें जिसे ट्रांज़िशन खत्म होने पर शुरू किया जाएगा.
TransitionListener	`Transition.doOnPause(crossinline action: (transition: Transition) -> Unit)` ऐसी कार्रवाई जोड़ें जिसे इस ट्रांज़िशन के रुकने पर शुरू किया जाएगा.
TransitionListener	`Transition.doOnResume(crossinline action: (transition: Transition) -> Unit)` ऐसी कार्रवाई जोड़ें जिसे तब शुरू किया जाएगा, जब ट्रांज़िशन कुछ समय के लिए रुकने के बाद फिर से शुरू हो जाएगा.
TransitionListener	`Transition.doOnStart(crossinline action: (transition: Transition) -> Unit)` ऐसी कार्रवाई जोड़ें जिसे यह ट्रांज़िशन शुरू होने पर लागू किया जाएगा.

androidx.core.util

डिपेंडेंसी

Groovy

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

Kotlin

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

एक्सटेंशन फ़ंक्शन

android.util.AtomicFile के लिए

ByteArray	`AtomicFile.readBytes()` इस फ़ाइल के पूरे कॉन्टेंट को बाइट ऐरे के तौर पर दिखाता है.
String	`AtomicFile.readText(charset: Charset = Charsets.UTF_8)` इस फ़ाइल के पूरे कॉन्टेंट को UTF-8 या तय किए गए charset का इस्तेमाल करके, स्ट्रिंग के तौर पर दिखाता है.
यूनिट	`AtomicFile.tryWrite(block: (out: FileOutputStream) -> Unit)` इस फ़ाइल पर, block के अंदर लिखने की कार्रवाइयां करें.
यूनिट	`AtomicFile.writeBytes(array: ByteArray)` इस फ़ाइल के कॉन्टेंट को बाइट के ऐरे के तौर पर सेट करता है.
यूनिट	`AtomicFile.writeText(text: String, charset: Charset = Charsets.UTF_8)` इस फ़ाइल के कॉन्टेंट को text के तौर पर सेट करता है. इसे UTF-8 या तय किए गए charset का इस्तेमाल करके एन्कोड किया जाता है.

android.util.LongSparseArray के लिए

operator Boolean	`LongSparseArray<T>.contains(key: Long)` अगर कलेक्शन में key मौजूद है, तो यह फ़ंक्शन true दिखाता है.
बूलियन	`LongSparseArray<T>.containsKey(key: Long)` अगर कलेक्शन में key मौजूद है, तो यह फ़ंक्शन true दिखाता है.
बूलियन	`LongSparseArray<T>.containsValue(value: T)` अगर कलेक्शन में value मौजूद है, तो यह फ़ंक्शन true दिखाता है.
यूनिट	`LongSparseArray<T>.forEach(action: (key: Long, value: T) -> Unit)` यह फ़ंक्शन, हर की/वैल्यू एंट्री के लिए दी गई कार्रवाई करता है.
T	`LongSparseArray<T>.getOrDefault(key: Long, defaultValue: T)` अगर key मौजूद है, तो उससे जुड़ी वैल्यू दिखाएगा. अगर key मौजूद नहीं है, तो defaultValue दिखाएगा.
T	`LongSparseArray<T>.getOrElse(key: Long, defaultValue: () -> T)` key से जुड़ी वैल्यू दिखाता है. अगर वैल्यू मौजूद नहीं है, तो defaultValue से वैल्यू दिखाता है.
बूलियन	`LongSparseArray<T>.isEmpty()` संग्रह में कोई एलिमेंट न होने पर, सही वैल्यू दिखाता है.
बूलियन	`LongSparseArray<T>.isNotEmpty()` संग्रह में एलिमेंट मौजूद होने पर, 'सही है' वैल्यू दिखाता है.
LongIterator	`LongSparseArray<T>.keyIterator()` संग्रह की कुंजियों पर एक इटरेटर दिखाता है.
operator LongSparseArray<T>	`LongSparseArray<T>.plus(other: LongSparseArray<T>)` यह फ़ंक्शन, other से एंट्री जोड़कर या बदलकर नया कलेक्शन बनाता है.
यूनिट	`LongSparseArray<T>.putAll(other: LongSparseArray<T>)` अन्य से एंट्री जोड़कर या बदलकर, इस कलेक्शन को अपडेट करें.
बूलियन	`LongSparseArray<T>.remove(key: Long, value: T)` यह फ़ंक्शन, key के लिए एंट्री को सिर्फ़ तब हटाता है, जब उसे value पर मैप किया गया हो.
operator Unit	`LongSparseArray<T>.set(key: Long, value: T)` इसकी मदद से, कलेक्शन में वैल्यू सेव करने के लिए इंडेक्स ऑपरेटर का इस्तेमाल किया जा सकता है.
Iterator<T>	`LongSparseArray<T>.valueIterator()` कलेक्शन की वैल्यू पर एक इटरेटर दिखाता है.

android.util.Pair के लिए

operator F	`Pair<F, S>.component1()` यह फ़ंक्शन, पेयर का पहला कॉम्पोनेंट दिखाता है.
operator S	`Pair<F, S>.component2()` यह फ़ंक्शन, जोड़े का दूसरा कॉम्पोनेंट दिखाता है.
Pair< F, S>	`Pair<F, S>.toKotlinPair()` इस Pair को kotlin.Pair के तौर पर दिखाता है.

android.util.Range के लिए

infix Range<T>	`Range<T>.and(other: Range<T>)` इस रेंज और other के इंटरसेक्शन को दिखाता है.
operator Range<T>	`Range<T>.plus(value: T)` इस और value को शामिल करने वाली सबसे छोटी रेंज दिखाता है.
operator Range<T>	`Range<T>.plus(other: Range<T>)` इस और other को शामिल करने वाली सबसे छोटी रेंज दिखाओ.
ClosedRange<T>	`Range<T>.toClosedRange()` इस Range को ClosedRange के तौर पर दिखाता है.

android.util.Size के लिए

operator Int	`Size.component1()` यह Size का पहला कॉम्पोनेंट "width" दिखाता है.
operator Int	`Size.component2()` यह फ़ंक्शन, साइज़ एट्रिब्यूट की दूसरी वैल्यू "ऊंचाई" दिखाता है.

android.util.SizeF के लिए

operator Float	`SizeF.component1()` यह SizeF का पहला कॉम्पोनेंट "width" दिखाता है.
operator Float	`SizeF.component2()` यह SizeF का दूसरा कॉम्पोनेंट "height" दिखाता है.

android.util.SparseArray के लिए

operator Boolean	`SparseArray<T>.contains(key: Int)` अगर कलेक्शन में key मौजूद है, तो यह फ़ंक्शन true दिखाता है.
बूलियन	`SparseArray<T>.containsKey(key: Int)` अगर कलेक्शन में key मौजूद है, तो यह फ़ंक्शन true दिखाता है.
बूलियन	`SparseArray<T>.containsValue(value: T)` अगर कलेक्शन में value मौजूद है, तो यह फ़ंक्शन true दिखाता है.
यूनिट	`SparseArray<T>.forEach(action: (key: Int, value: T) -> Unit)` यह फ़ंक्शन, हर की/वैल्यू एंट्री के लिए दी गई कार्रवाई करता है.
T	`SparseArray<T>.getOrDefault(key: Int, defaultValue: T)` अगर key मौजूद है, तो उससे जुड़ी वैल्यू दिखाएगा. अगर key मौजूद नहीं है, तो defaultValue दिखाएगा.
T	`SparseArray<T>.getOrElse(key: Int, defaultValue: () -> T)` key से जुड़ी वैल्यू दिखाता है. अगर वैल्यू मौजूद नहीं है, तो defaultValue से वैल्यू दिखाता है.
बूलियन	`SparseArray<T>.isEmpty()` संग्रह में कोई एलिमेंट न होने पर, सही वैल्यू दिखाता है.
बूलियन	`SparseArray<T>.isNotEmpty()` संग्रह में एलिमेंट मौजूद होने पर, 'सही है' वैल्यू दिखाता है.
IntIterator	`SparseArray<T>.keyIterator()` संग्रह की कुंजियों पर एक इटरेटर दिखाता है.
operator SparseArray<T>	`SparseArray<T>.plus(other: SparseArray<T>)` यह फ़ंक्शन, other से एंट्री जोड़कर या बदलकर नया कलेक्शन बनाता है.
यूनिट	`SparseArray<T>.putAll(other: SparseArray<T>)` अन्य से एंट्री जोड़कर या बदलकर, इस कलेक्शन को अपडेट करें.
बूलियन	`SparseArray<T>.remove(key: Int, value: T)` यह फ़ंक्शन, key के लिए एंट्री को सिर्फ़ तब हटाता है, जब उसे value पर मैप किया गया हो.
operator Unit	`SparseArray<T>.set(key: Int, value: T)` इसकी मदद से, कलेक्शन में वैल्यू सेव करने के लिए इंडेक्स ऑपरेटर का इस्तेमाल किया जा सकता है.
Iterator<T>	`SparseArray<T>.valueIterator()` कलेक्शन की वैल्यू पर एक इटरेटर दिखाता है.

android.util.SparseBooleanArray के लिए

operator Boolean	`SparseBooleanArray.contains(key: Int)` अगर कलेक्शन में key मौजूद है, तो यह फ़ंक्शन true दिखाता है.
बूलियन	`SparseBooleanArray.containsKey(key: Int)` अगर कलेक्शन में key मौजूद है, तो यह फ़ंक्शन true दिखाता है.
बूलियन	`SparseBooleanArray.containsValue(value: Boolean)` अगर कलेक्शन में value मौजूद है, तो यह फ़ंक्शन true दिखाता है.
यूनिट	`SparseBooleanArray.forEach(action: (key: Int, value: Boolean) -> Unit)` यह फ़ंक्शन, हर की/वैल्यू एंट्री के लिए दी गई कार्रवाई करता है.
बूलियन	`SparseBooleanArray.getOrDefault(key: Int, defaultValue: Boolean)` अगर key मौजूद है, तो उससे जुड़ी वैल्यू दिखाएगा. अगर key मौजूद नहीं है, तो defaultValue दिखाएगा.
बूलियन	`SparseBooleanArray.getOrElse(key: Int, defaultValue: () -> Boolean)` key से जुड़ी वैल्यू दिखाता है. अगर वैल्यू मौजूद नहीं है, तो defaultValue से वैल्यू दिखाता है.
बूलियन	`SparseBooleanArray.isEmpty()` संग्रह में कोई एलिमेंट न होने पर, सही वैल्यू दिखाता है.
बूलियन	`SparseBooleanArray.isNotEmpty()` संग्रह में एलिमेंट मौजूद होने पर, 'सही है' वैल्यू दिखाता है.
IntIterator	`SparseBooleanArray.keyIterator()` संग्रह की कुंजियों पर एक इटरेटर दिखाता है.
operator SparseBooleanArray	`SparseBooleanArray.plus(other: SparseBooleanArray)` यह फ़ंक्शन, other से एंट्री जोड़कर या बदलकर नया कलेक्शन बनाता है.
यूनिट	`SparseBooleanArray.putAll(other: SparseBooleanArray)` अन्य से एंट्री जोड़कर या बदलकर, इस कलेक्शन को अपडेट करें.
बूलियन	`SparseBooleanArray.remove(key: Int, value: Boolean)` यह फ़ंक्शन, key के लिए एंट्री को सिर्फ़ तब हटाता है, जब उसे value पर मैप किया गया हो.
operator Unit	`SparseBooleanArray.set(key: Int, value: Boolean)` इसकी मदद से, कलेक्शन में वैल्यू सेव करने के लिए इंडेक्स ऑपरेटर का इस्तेमाल किया जा सकता है.
BooleanIterator	`SparseBooleanArray.valueIterator()` कलेक्शन की वैल्यू पर एक इटरेटर दिखाता है.

android.util.SparseIntArray के लिए

operator Boolean	`SparseIntArray.contains(key: Int)` अगर कलेक्शन में key मौजूद है, तो यह फ़ंक्शन true दिखाता है.
बूलियन	`SparseIntArray.containsKey(key: Int)` अगर कलेक्शन में key मौजूद है, तो यह फ़ंक्शन true दिखाता है.
बूलियन	`SparseIntArray.containsValue(value: Int)` अगर कलेक्शन में value मौजूद है, तो यह फ़ंक्शन true दिखाता है.
यूनिट	`SparseIntArray.forEach(action: (key: Int, value: Int) -> Unit)` यह फ़ंक्शन, हर की/वैल्यू एंट्री के लिए दी गई कार्रवाई करता है.
Int	`SparseIntArray.getOrDefault(key: Int, defaultValue: Int)` अगर key मौजूद है, तो उससे जुड़ी वैल्यू दिखाएगा. अगर key मौजूद नहीं है, तो defaultValue दिखाएगा.
Int	`SparseIntArray.getOrElse(key: Int, defaultValue: () -> Int)` key से जुड़ी वैल्यू दिखाता है. अगर वैल्यू मौजूद नहीं है, तो defaultValue से वैल्यू दिखाता है.
बूलियन	`SparseIntArray.isEmpty()` संग्रह में कोई एलिमेंट न होने पर, सही वैल्यू दिखाता है.
बूलियन	`SparseIntArray.isNotEmpty()` संग्रह में एलिमेंट मौजूद होने पर, 'सही है' वैल्यू दिखाता है.
IntIterator	`SparseIntArray.keyIterator()` संग्रह की कुंजियों पर एक इटरेटर दिखाता है.
operator SparseIntArray	`SparseIntArray.plus(other: SparseIntArray)` यह फ़ंक्शन, other से एंट्री जोड़कर या बदलकर नया कलेक्शन बनाता है.
यूनिट	`SparseIntArray.putAll(other: SparseIntArray)` अन्य से एंट्री जोड़कर या बदलकर, इस कलेक्शन को अपडेट करें.
बूलियन	`SparseIntArray.remove(key: Int, value: Int)` यह फ़ंक्शन, key के लिए एंट्री को सिर्फ़ तब हटाता है, जब उसे value पर मैप किया गया हो.
operator Unit	`SparseIntArray.set(key: Int, value: Int)` इसकी मदद से, कलेक्शन में वैल्यू सेव करने के लिए इंडेक्स ऑपरेटर का इस्तेमाल किया जा सकता है.
IntIterator	`SparseIntArray.valueIterator()` कलेक्शन की वैल्यू पर एक इटरेटर दिखाता है.

android.util.SparseLongArray के लिए

operator Boolean	`SparseLongArray.contains(key: Int)` अगर कलेक्शन में key मौजूद है, तो यह फ़ंक्शन true दिखाता है.
बूलियन	`SparseLongArray.containsKey(key: Int)` अगर कलेक्शन में key मौजूद है, तो यह फ़ंक्शन true दिखाता है.
बूलियन	`SparseLongArray.containsValue(value: Long)` अगर कलेक्शन में value मौजूद है, तो यह फ़ंक्शन true दिखाता है.
यूनिट	`SparseLongArray.forEach(action: (key: Int, value: Long) -> Unit)` यह फ़ंक्शन, हर की/वैल्यू एंट्री के लिए दी गई कार्रवाई करता है.
Long	`SparseLongArray.getOrDefault(key: Int, defaultValue: Long)` अगर key मौजूद है, तो उससे जुड़ी वैल्यू दिखाएगा. अगर key मौजूद नहीं है, तो defaultValue दिखाएगा.
Long	`SparseLongArray.getOrElse(key: Int, defaultValue: () -> Long)` key से जुड़ी वैल्यू दिखाता है. अगर वैल्यू मौजूद नहीं है, तो defaultValue से वैल्यू दिखाता है.
बूलियन	`SparseLongArray.isEmpty()` संग्रह में कोई एलिमेंट न होने पर, सही वैल्यू दिखाता है.
बूलियन	`SparseLongArray.isNotEmpty()` संग्रह में एलिमेंट मौजूद होने पर, 'सही है' वैल्यू दिखाता है.
IntIterator	`SparseLongArray.keyIterator()` संग्रह की कुंजियों पर एक इटरेटर दिखाता है.
operator SparseLongArray	`SparseLongArray.plus(other: SparseLongArray)` यह फ़ंक्शन, other से एंट्री जोड़कर या बदलकर नया कलेक्शन बनाता है.
यूनिट	`SparseLongArray.putAll(other: SparseLongArray)` अन्य से एंट्री जोड़कर या बदलकर, इस कलेक्शन को अपडेट करें.
बूलियन	`SparseLongArray.remove(key: Int, value: Long)` key के लिए एंट्री सिर्फ़ तब हटाता है, जब इसे value पर सेट किया गया हो.
operator Unit	`SparseLongArray.set(key: Int, value: Long)` इसकी मदद से, कलेक्शन में वैल्यू सेव करने के लिए इंडेक्स ऑपरेटर का इस्तेमाल किया जा सकता है.
LongIterator	`SparseLongArray.valueIterator()` कलेक्शन की वैल्यू पर एक इटरेटर दिखाता है.

kotlin.Double के लिए

Half	`Double.toHalf()` यह दिए गए Double को दिखाने वाला Half इंस्टेंस दिखाता है.

kotlin.Float के लिए

Half	`Float.toHalf()` यह फ़ंक्शन, दिए गए Float को दिखाने वाला Half इंस्टेंस दिखाता है.

kotlin.Pair के लिए

Pair< F, S>

Pair<F, S>.toAndroidPair()

इस kotlin.Pair को Android Pair के तौर पर दिखाता है.

kotlin.Short के लिए

Half	`Short.toHalf()` यह दिए गए Short को दिखाने वाला Half इंस्टेंस दिखाता है.

kotlin.String के लिए

Half	`String.toHalf()` यह फ़ंक्शन, दी गई String को दिखाने वाला Half इंस्टेंस दिखाता है.

kotlin.ranges.ClosedRange के लिए

Range<T>

ClosedRange<T>.toRange()

इस ClosedRange को Range के तौर पर दिखाता है.

एक्सटेंशन प्रॉपर्टी

android.util.LongSparseArray के लिए

Int	`LongSparseArray<T>.size()` यह फ़ंक्शन, कलेक्शन में मौजूद कुंजी/वैल्यू पेयर की संख्या दिखाता है.

android.util.SparseArray के लिए

Int	`SparseArray<T>.size()` यह फ़ंक्शन, कलेक्शन में मौजूद कुंजी/वैल्यू पेयर की संख्या दिखाता है.

android.util.SparseBooleanArray के लिए

Int	`SparseBooleanArray.size()` यह फ़ंक्शन, कलेक्शन में मौजूद कुंजी/वैल्यू पेयर की संख्या दिखाता है.

android.util.SparseIntArray के लिए

Int	`SparseIntArray.size()` यह फ़ंक्शन, कलेक्शन में मौजूद कुंजी/वैल्यू पेयर की संख्या दिखाता है.

android.util.SparseLongArray के लिए

Int	`SparseLongArray.size()` यह फ़ंक्शन, कलेक्शन में मौजूद कुंजी/वैल्यू एंट्री की संख्या दिखाता है.

टॉप-लेवल फ़ंक्शन

LruCache&lt K, V&gt	`lruCache(maxSize: Int, crossinline sizeOf: (key: K, value: V) -> Int = { _, _ -> 1 }, crossinline create: (key: K) -> V? = { null as V? }, crossinline onEntryRemoved: (evicted: Boolean, key: K, oldValue: V, newValue: V?) -> Unit = { _, _, _, _ -> })` यह दिए गए पैरामीटर के साथ LruCache बनाता है.
infix Range<T>	`T.rangeTo(that: T)` यह तुलना की जा सकने वाली वैल्यू से लेकर उस वैल्यू तक की रेंज बनाता है.

androidx.core.view

डिपेंडेंसी

Groovy

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

Kotlin

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

एक्सटेंशन फ़ंक्शन

android.view.Menu के लिए

operator Boolean	`Menu.contains(item: MenuItem)` अगर इस मेन्यू में item मौजूद है, तो `true` दिखाता है.
यूनिट	`Menu.forEach(action: (item: MenuItem) -> Unit)` इस मेन्यू में मौजूद हर आइटम पर दी गई कार्रवाई करता है.
यूनिट	`Menu.forEachIndexed(action: (index: Int, item: MenuItem) -> Unit)` यह इस मेन्यू में मौजूद हर आइटम पर दी गई कार्रवाई करता है. साथ ही, इसका क्रमवार इंडेक्स भी दिखाता है.
operator MenuItem	`Menu.get(index: Int)` यह index पर मौजूद मेन्यू दिखाता है.
बूलियन	`Menu.isEmpty()` अगर इस मेन्यू में कोई आइटम नहीं है, तो यह फ़ंक्शन 'सही' दिखाता है.
बूलियन	`Menu.isNotEmpty()` अगर इस मेन्यू में एक या उससे ज़्यादा आइटम मौजूद हैं, तो यह फ़ंक्शन 'सही' दिखाता है.
operator MutableIterator<MenuItem>	`Menu.iterator()` यह इस मेन्यू में मौजूद आइटम पर MutableIterator दिखाता है.
operator Unit	`Menu.minusAssign(item: MenuItem)` इस मेन्यू से आइटम हटाता है.

android.view.View के लिए

यूनिट	`View.doOnAttach(crossinline action: (view: View) -> Unit)` जब इस व्यू को किसी विंडो से अटैच किया जाता है, तब यह दिए गए ऐक्शन को पूरा करता है.
यूनिट	`View.doOnDetach(crossinline action: (view: View) -> Unit)` जब इस व्यू को किसी विंडो से अलग किया जाता है, तब यह फ़ंक्शन दी गई कार्रवाई करता है.
यूनिट	`View.doOnLayout(crossinline action: (view: View) -> Unit)` इस व्यू को लेआउट करते समय, दी गई कार्रवाई करता है.
यूनिट	`View.doOnNextLayout(crossinline action: (view: View) -> Unit)` जब इस व्यू को अगली बार लेआउट किया जाता है, तब दी गई कार्रवाई करता है.
OneShotPreDrawListener	`View.doOnPreDraw(crossinline action: (view: View) -> Unit)` व्यू ट्री को ड्रॉ करने से पहले, दी गई कार्रवाई करता है.
बिटमैप	`View.drawToBitmap(config: Config = Bitmap.Config.ARGB_8888)` इस View का Bitmap वर्शन दिखाता है.
Runnable	`View.postDelayed(delayInMillis: Long, crossinline action: () -> Unit)` View.postDelayed का यह वर्शन, पैरामीटर को फिर से क्रम में लगाता है. इससे कार्रवाई को कोष्ठक से बाहर रखा जा सकता है.
Runnable	`View.postOnAnimationDelayed(delayInMillis: Long, crossinline action: () -> Unit)` View.postOnAnimationDelayed का यह वर्शन, पैरामीटर को फिर से क्रम में लगाता है. इससे कार्रवाई को कोष्ठक से बाहर रखा जा सकता है.
यूनिट	`View.setPadding(@Px size: Int)` इससे व्यू की पैडिंग सेट की जाती है.
यूनिट	`View.updateLayoutParams(block: LayoutParams.() -> Unit)` यह View के layoutParams के साथ block को एक्ज़ीक्यूट करता है और layoutParams को अपडेट किए गए वर्शन के साथ फिर से असाइन करता है.
यूनिट	`View.updateLayoutParams(block: T.() -> Unit)` यह View के layoutParams के टाइप किए गए वर्शन के साथ block को लागू करता है और layoutParams को अपडेट किए गए वर्शन के साथ फिर से असाइन करता है.
यूनिट	`View.updatePadding(@Px left: Int = paddingLeft, @Px top: Int = paddingTop, @Px right: Int = paddingRight, @Px bottom: Int = paddingBottom)` इस व्यू की पैडिंग को अपडेट करता है.
यूनिट	`View.updatePaddingRelative(@Px start: Int = paddingStart, @Px top: Int = paddingTop, @Px end: Int = paddingEnd, @Px bottom: Int = paddingBottom)` इस व्यू के रिलेटिव पैडिंग को अपडेट करता है.

android.view.ViewGroup के लिए

operator Boolean	`ViewGroup.contains(view: View)` अगर इस व्यू ग्रुप में view मौजूद है, तो `true` दिखाता है.
यूनिट	`ViewGroup.forEach(action: (view: View) -> Unit)` यह फ़ंक्शन, इस व्यू ग्रुप में मौजूद हर व्यू पर दी गई कार्रवाई करता है.
यूनिट	`ViewGroup.forEachIndexed(action: (index: Int, view: View) -> Unit)` यह फ़ंक्शन, इस व्यू ग्रुप के हर व्यू पर दी गई कार्रवाई करता है. साथ ही, इसका क्रमवार इंडेक्स देता है.
operator View	`ViewGroup.get(index: Int)` index पर मौजूद व्यू दिखाता है.
बूलियन	`ViewGroup.isEmpty()` अगर इस व्यू ग्रुप में कोई व्यू नहीं है, तो यह फ़ंक्शन 'सही' दिखाता है.
बूलियन	`ViewGroup.isNotEmpty()` अगर इस व्यू ग्रुप में एक या उससे ज़्यादा व्यू शामिल हैं, तो यह फ़ंक्शन 'सही' दिखाता है.
operator MutableIterator<View>	`ViewGroup.iterator()` यह व्यू ग्रुप में मौजूद व्यू पर MutableIterator दिखाता है.
operator Unit	`ViewGroup.minusAssign(view: View)` इस व्यू ग्रुप से व्यू को हटाता है.
operator Unit	`ViewGroup.plusAssign(view: View)` इस व्यू ग्रुप में view जोड़ता है.

android.view.ViewGroup.MarginLayoutParams के लिए

यूनिट	`MarginLayoutParams.setMargins(@Px size: Int)` यह ViewGroup के MarginLayoutParams में मार्जिन सेट करता है.
यूनिट	`MarginLayoutParams.updateMargins(@Px left: Int = leftMargin, @Px top: Int = topMargin, @Px right: Int = rightMargin, @Px bottom: Int = bottomMargin)` यह ViewGroup के ViewGroup.MarginLayoutParams में मार्जिन अपडेट करता है.
यूनिट	`MarginLayoutParams.updateMarginsRelative(@Px start: Int = marginStart, @Px top: Int = topMargin, @Px end: Int = marginEnd, @Px bottom: Int = bottomMargin)` यह ViewGroup के MarginLayoutParams में मौजूद मार्जिन को अपडेट करता है.

एक्सटेंशन प्रॉपर्टी

android.view.Menu के लिए

Sequence<MenuItem>	`Menu.children()` यह मेन्यू में मौजूद आइटम के लिए, Sequence दिखाता है.
Int	`Menu.size()` इस मेन्यू में मौजूद आइटम की संख्या दिखाता है.

android.view.View के लिए

बूलियन	`View.isGone()` अगर इस व्यू की विज़िबिलिटी View.GONE है, तो यह फ़ंक्शन true दिखाता है. ऐसा न होने पर, यह फ़ंक्शन false दिखाता है.
बूलियन	`View.isInvisible()` अगर इस व्यू की दृश्यता View.INVISIBLE पर सेट है, तो यह फ़ंक्शन true दिखाता है. ऐसा न होने पर, यह फ़ंक्शन false दिखाता है.
बूलियन	`View.isVisible()` अगर इस व्यू की विज़िबिलिटी View.VISIBLE है, तो यह फ़ंक्शन true दिखाता है. ऐसा न होने पर, यह फ़ंक्शन false दिखाता है.
Int	`View.marginBottom()` अगर इस व्यू का LayoutParams, ViewGroup.MarginLayoutParams है, तो यह बॉटम मार्जिन दिखाता है. ऐसा न होने पर, यह 0 दिखाता है.
Int	`View.marginEnd()` अगर इस व्यू का LayoutParams, ViewGroup.MarginLayoutParams है, तो यह फ़ंक्शन आखिर का मार्जिन दिखाता है. ऐसा न होने पर, यह 0 दिखाता है.
Int	`View.marginLeft()` अगर इस व्यू का LayoutParams, ViewGroup.MarginLayoutParams है, तो यह फ़ंक्शन बाईं ओर का मार्जिन दिखाता है. ऐसा न होने पर, यह 0 दिखाता है.
Int	`View.marginRight()` अगर इस व्यू का LayoutParams, ViewGroup.MarginLayoutParams है, तो यह फ़ंक्शन दाईं ओर का मार्जिन दिखाता है. अगर ऐसा नहीं है, तो यह 0 दिखाता है.
Int	`View.marginStart()` अगर इस व्यू का LayoutParams, ViewGroup.MarginLayoutParams है, तो यह फ़ंक्शन स्टार्ट मार्जिन दिखाता है. ऐसा न होने पर, यह 0 दिखाता है.
Int	`View.marginTop()` अगर इस व्यू का LayoutParams, ViewGroup.MarginLayoutParams है, तो यह टॉप मार्जिन दिखाता है. ऐसा न होने पर, यह 0 दिखाता है.

android.view.ViewGroup के लिए

Sequence<View>	`ViewGroup.children()` यह व्यू ग्रुप में मौजूद चाइल्ड व्यू पर Sequence दिखाता है.
Int	`ViewGroup.size()` यह व्यू ग्रुप में व्यू की संख्या दिखाता है.

androidx.core.widget

डिपेंडेंसी

Groovy

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

Kotlin

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

एक्सटेंशन फ़ंक्शन

android.widget.TextView के लिए

TextWatcher	`TextView.addTextChangedListener(crossinline beforeTextChanged: (text: CharSequence?, start: Int, count: Int, after: Int) -> Unit = { _, _, _, _ -> }, crossinline onTextChanged: (text: CharSequence?, start: Int, count: Int, after: Int) -> Unit = { _, _, _, _ -> }, crossinline afterTextChanged: (text: Editable?) -> Unit = {})` दी गई कार्रवाइयों का इस्तेमाल करके, इस TextView में टेक्स्ट बदलने वाला लिसनर जोड़ें
TextWatcher	`TextView.doAfterTextChanged(crossinline action: (text: Editable?) -> Unit)` ऐसा ऐक्शन जोड़ें जिसे टेक्स्ट में बदलाव होने के बाद शुरू किया जाएगा.
TextWatcher	`TextView.doBeforeTextChanged(crossinline action: (text: CharSequence?, start: Int, count: Int, after: Int) -> Unit)` ऐसा ऐक्शन जोड़ें जिसे टेक्स्ट बदलने से पहले शुरू किया जाएगा.
TextWatcher	`TextView.doOnTextChanged(crossinline action: (text: CharSequence?, start: Int, count: Int, after: Int) -> Unit)` ऐसा ऐक्शन जोड़ें जिसे टेक्स्ट बदलने पर शुरू किया जाएगा.

androidx.dynamicanimation.animation

डिपेंडेंसी

Groovy

dependencies {
    implementation "androidx.dynamicanimation:dynamicanimation-ktx:"
}

Kotlin

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

एक्सटेंशन फ़ंक्शन

SpringAnimation के लिए

SpringAnimation

SpringAnimation.withSpringForceProperties(func: SpringForce.() -> Unit)

यह स्प्रिंग फ़ोर्स की प्रॉपर्टी को अपडेट करता है या लागू करता है. जैसे, SpringForce.mDampingRatio, SpringForce.mFinalPosition, और SpringAnimation पर स्टिफ़नेस.

टॉप-लेवल फ़ंक्शन

FlingAnimation	`flingAnimationOf(setter: (Float) -> Unit, getter: () -> Float)` यह किसी ऐसी प्रॉपर्टी के लिए FlingAnimation बनाता है जिसे दिए गए सेटर और गैटर के ज़रिए ऐक्सेस किया जा सकता है.
SpringAnimation	`springAnimationOf(setter: (Float) -> Unit, getter: () -> Float, finalPosition: Float = Float.NaN)` यह किसी ऐसी प्रॉपर्टी के लिए SpringAnimation बनाता है जिसे दिए गए सेटर और गैटर के ज़रिए ऐक्सेस किया जा सकता है.

androidx.fragment.app

डिपेंडेंसी

ग्रूवी

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

Kotlin

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

एक्सटेंशन फ़ंक्शन

android.view.View के लिए

F	`View.findFragment()` किसी View से जुड़े Fragment को ढूंढता है.

फ़्रैगमेंट के लिए

Lazy<VM>	`Fragment.activityViewModels(noinline factoryProducer: () -> ViewModelProvider.Factory = null)` यह पैरंट ऐक्टिविटी के ViewModel को ऐक्सेस करने के लिए, प्रॉपर्टी डेलिगेट दिखाता है. अगर factoryProducer तय किया गया है, तो इससे मिले ViewModelProvider.Factory का इस्तेमाल, पहली बार ViewModel बनाने के लिए किया जाएगा.
Lazy<VM>	`Fragment.createViewModelLazy(viewModelClass: KClass<VM>, storeProducer: () -> ViewModelStore, factoryProducer: () -> ViewModelProvider.Factory = null)` ViewModelLazy बनाने के लिए हेल्पर मेथड. यह `null` को डिफ़ॉल्ट फ़ैक्ट्री में factoryProducer के तौर पर पास करता है.
Lazy<VM>	`Fragment.viewModels(noinline ownerProducer: () -> ViewModelStoreOwner = { this }, noinline factoryProducer: () -> ViewModelProvider.Factory = null)` यह प्रॉपर्टी डेलिगेट दिखाता है, ताकि इस Fragment के लिए डिफ़ॉल्ट स्कोप किए गए ViewModel को ऐक्सेस किया जा सके:

FragmentTransaction के लिए

FragmentTransaction	`FragmentTransaction.add(@IdRes containerViewId: Int, tag: String? = null, args: Bundle? = null)` इस फ़ंक्शन का इस्तेमाल करके, फ़्रैगमेंट को उससे जुड़े FragmentManager में जोड़ा जाता है. साथ ही, फ़्रैगमेंट के व्यू को containerViewId में तय की गई कंटेनर व्यू में बड़ा किया जाता है. बाद में, इसे FragmentManager.findFragmentById की मदद से वापस पाया जा सकता है.
FragmentTransaction	`FragmentTransaction.add(tag: String, args: Bundle? = null)` किसी कंटेनर व्यू में Fragment को जोड़े बिना, उससे जुड़े FragmentManager में कोई फ़्रैगमेंट जोड़ें.
FragmentTransaction	`FragmentTransaction.replace(@IdRes containerViewId: Int, tag: String? = null, args: Bundle? = null)` किसी कंटेनर में जोड़े गए मौजूदा फ़्रैगमेंट को बदलें.

FragmentManager के लिए

यूनिट	`FragmentManager.commit(allowStateLoss: Boolean = false, body: FragmentTransaction.() -> Unit)` body को FragmentTransaction में चलाएं. अगर यह बिना किसी अपवाद के पूरा हो जाता है, तो यह अपने-आप कमिट हो जाता है.
यूनिट	`FragmentManager.commitNow(allowStateLoss: Boolean = false, body: FragmentTransaction.() -> Unit)` body को FragmentTransaction में चलाएं. अगर यह बिना किसी अपवाद के पूरा हो जाता है, तो यह अपने-आप कमिट हो जाता है.
यूनिट	`FragmentManager.transaction(now: Boolean = false, allowStateLoss: Boolean = false, body: FragmentTransaction.() -> Unit)` body को FragmentTransaction में चलाएं. अगर यह बिना किसी अपवाद के पूरा हो जाता है, तो यह अपने-आप कमिट हो जाता है.

androidx.fragment.app.testing

डिपेंडेंसी

ग्रूवी

dependencies {
    implementation "androidx.fragment:fragment-testing:1.8.8"
}

Kotlin

dependencies {
    implementation("androidx.fragment:fragment-testing:1.8.8")
}

टॉप-लेवल फ़ंक्शन

FragmentScenario<F!>	`launchFragment(fragmentArgs: Bundle? = null, @StyleRes themeResId: Int = R.style.FragmentScenarioEmptyFragmentActivityTheme, factory: FragmentFactory? = null)` यह दिए गए आर्ग्युमेंट के साथ एक फ़्रैगमेंट लॉन्च करता है. इसे खाली FragmentActivity होस्ट करता है. इसके लिए, दिए गए FragmentFactory का इस्तेमाल किया जाता है. साथ ही, यह फ़्रैगमेंट के 'फिर शुरू करें' वाली स्थिति में पहुंचने का इंतज़ार करता है.
FragmentScenario<F!>	`launchFragment(fragmentArgs: Bundle? = null, @StyleRes themeResId: Int = R.style.FragmentScenarioEmptyFragmentActivityTheme, crossinline instantiate: () -> F)` यह दिए गए आर्ग्युमेंट के साथ एक फ़्रैगमेंट लॉन्च करता है. इसे खाली FragmentActivity होस्ट करता है. इसके लिए, instantiate का इस्तेमाल करके फ़्रैगमेंट बनाया जाता है. साथ ही, इसके 'फिर शुरू करें' वाली स्थिति में पहुंचने का इंतज़ार किया जाता है.
FragmentScenario<F!>	`launchFragmentInContainer(fragmentArgs: Bundle? = null, @StyleRes themeResId: Int = R.style.FragmentScenarioEmptyFragmentActivityTheme, factory: FragmentFactory? = null)` यह फ़ंक्शन, गतिविधि के रूट व्यू कंटेनर `android.R.id.content` में एक फ़्रैगमेंट लॉन्च करता है. इसमें दिए गए आर्ग्युमेंट, खाली FragmentActivity से होस्ट किए जाते हैं. साथ ही, यह फ़्रैगमेंट के फिर से शुरू होने का इंतज़ार करता है.
FragmentScenario<F!>	`launchFragmentInContainer(fragmentArgs: Bundle? = null, @StyleRes themeResId: Int = R.style.FragmentScenarioEmptyFragmentActivityTheme, crossinline instantiate: () -> F)` यह फ़ंक्शन, गतिविधि के रूट व्यू कंटेनर `android.R.id.content` में एक फ़्रैगमेंट लॉन्च करता है. इसमें दिए गए आर्ग्युमेंट, खाली FragmentActivity होस्ट करता है. यह फ़्रैगमेंट बनाने के लिए, instantiate का इस्तेमाल करता है. साथ ही, इसके फिर से शुरू होने का इंतज़ार करता है.

androidx.lifecycle

डिपेंडेंसी

ग्रूवी

dependencies {
    implementation "androidx.lifecycle:lifecycle-livedata-core-ktx:2.9.2"
    implementation "androidx.lifecycle:lifecycle-livedata-ktx:2.9.2"
    implementation "androidx.lifecycle:lifecycle-reactivestreams-ktx:2.9.2"
    implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.9.2"
    implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:2.9.2"
}

Kotlin

dependencies {
    implementation("androidx.lifecycle:lifecycle-livedata-core-ktx:2.9.2")
    implementation("androidx.lifecycle:lifecycle-livedata-ktx:2.9.2")
    implementation("androidx.lifecycle:lifecycle-reactivestreams-ktx:2.9.2")
    implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.9.2")
    implementation("androidx.lifecycle:lifecycle-viewmodel-ktx:2.9.2")
}

एक्सटेंशन फ़ंक्शन

kotlinx.coroutines.flow.Flow के लिए

LiveData<T>	`Flow<T>.asLiveData(context: CoroutineContext = EmptyCoroutineContext, timeoutInMs: Long = DEFAULT_TIMEOUT)` यह एक ऐसा LiveData बनाता है जिसमें ओरिजन Flow से इकट्ठा की गई वैल्यू होती हैं.
LiveData<T>	`Flow<T>.asLiveData(context: CoroutineContext = EmptyCoroutineContext, timeout: Duration)` यह एक ऐसा LiveData बनाता है जिसमें ओरिजन Flow से इकट्ठा की गई वैल्यू होती हैं.

org.reactivestreams.Publisher के लिए

LiveData<T>

Publisher<T>.toLiveData()

यह ReactiveStreams Publisher से, ऑब्ज़र्वेबल LiveData स्ट्रीम बनाता है.

LiveData के लिए

Flow<T>	`LiveData<T>.asFlow()` यह Flow बनाता है, जिसमें ओरिजनल LiveData से भेजी गई वैल्यू होती हैं: शुरुआत में, फ़्लो कलेक्टर को LiveData की सबसे नई वैल्यू मिलती है. इसके बाद, वह LiveData के अपडेट को मॉनिटर करता है.
LiveData<X>	`LiveData<X>.distinctUntilChanged()` यह एक नया LiveData ऑब्जेक्ट बनाता है. यह तब तक कोई वैल्यू नहीं भेजता, जब तक सोर्स `this` LiveData वैल्यू में बदलाव नहीं हो जाता.
LiveData<Y>	`LiveData<X>.map(crossinline transform: (X) -> Y)` यह फ़ंक्शन, `this` LiveData से मैप किया गया LiveData दिखाता है. इसके लिए, `this` LiveData पर सेट की गई हर वैल्यू पर transform फ़ंक्शन लागू किया जाता है.
Observer<T>	`LiveData<T>.observe(owner: LifecycleOwner, crossinline onChanged: (T) -> Unit)` यह फ़ंक्शन, दिए गए owner के लाइफ़स्पैन में, दिए गए onChanged लैम्डा को ऑब्ज़र्वर के तौर पर जोड़ता है. साथ ही, ऑब्ज़र्वर का रेफ़रंस दिखाता है.
LiveData<Y>	`LiveData<X>.switchMap(crossinline transform: (X) -> LiveData<Y>)` यह फ़ंक्शन, इनपुट `this` `LiveData` से मैप किया गया LiveData दिखाता है. इसके लिए, `this` पर सेट की गई हर वैल्यू पर transform लागू किया जाता है.
Publisher<T>	`LiveData<T>.toPublisher(lifecycle: LifecycleOwner)` यह दिए गए LiveData स्ट्रीम को ReactiveStreams Publisher के हिसाब से बदलता है.

ViewModelProvider के लिए

VM	`ViewModelProvider.get()` यह फ़ंक्शन, मौजूदा ViewModel ऑब्जेक्ट को दिखाता है या इस `ViewModelProvider` से जुड़े स्कोप (आम तौर पर, फ़्रैगमेंट या ऐक्टिविटी) में एक नया ViewModel ऑब्जेक्ट बनाता है.

LifecycleOwner के लिए

suspend T	`LifecycleOwner.whenCreated(block: suspend CoroutineScope.() -> T)` जब LifecycleOwner का Lifecycle कम से कम Lifecycle.State.CREATED स्थिति में होता है, तब यह दिए गए ब्लॉक को चलाता है.
suspend T	`LifecycleOwner.whenResumed(block: suspend CoroutineScope.() -> T)` LifecycleOwner का Lifecycle कम से कम Lifecycle.State.RESUMED स्थिति में होने पर, दिए गए ब्लॉक को चलाता है.
suspend T	`LifecycleOwner.whenStarted(block: suspend CoroutineScope.() -> T)` LifecycleOwner का Lifecycle कम से कम Lifecycle.State.STARTED स्थिति में होने पर, दिया गया ब्लॉक चलता है.

लाइफ़साइकल के लिए

suspend T	`Lifecycle.whenCreated(block: suspend CoroutineScope.() -> T)` जब लाइफ़साइकल कम से कम Lifecycle.State.CREATED स्थिति में हो, तब दिए गए ब्लॉक को चलाता है.
suspend T	`Lifecycle.whenResumed(block: suspend CoroutineScope.() -> T)` Lifecycle के Lifecycle.State.RESUMED स्टेट में होने पर, यह दिए गए ब्लॉक को चलाता है.
suspend T	`Lifecycle.whenStarted(block: suspend CoroutineScope.() -> T)` जब Lifecycle कम से कम Lifecycle.State.STARTED स्थिति में होता है, तब यह दिए गए ब्लॉक को चलाता है.
suspend T	`Lifecycle.whenStateAtLeast(minState: Lifecycle.State, block: suspend CoroutineScope.() -> T)` यह दिए गए ब्लॉक को CoroutineDispatcher पर चलाता है. यह ब्लॉक को मुख्य थ्रेड पर एक्ज़ीक्यूट करता है और तब तक एक्ज़ीक्यूशन को निलंबित करता है, जब तक Lifecycle की स्थिति कम से कम minState न हो.

एक्सटेंशन प्रॉपर्टी

लाइफ़साइकल के लिए

LifecycleCoroutineScope

Lifecycle.coroutineScope()

यह Lifecycle से जुड़ा CoroutineScope है.

LifecycleOwner के लिए

LifecycleCoroutineScope

LifecycleOwner.lifecycleScope()

यह CoroutineScope, इस LifecycleOwner के Lifecycle से जुड़ा होता है.

ViewModel के लिए

CoroutineScope

ViewModel.viewModelScope()

यह ViewModel से जुड़ा CoroutineScope है.

टॉप-लेवल फ़ंक्शन

LiveData<T>	`liveData(context: CoroutineContext = EmptyCoroutineContext, timeoutInMs: Long = DEFAULT_TIMEOUT, block: suspend LiveDataScope<T>.() -> Unit)` यह एक LiveData बनाता है, जिसमें दिए गए ब्लॉक से मिली वैल्यू होती हैं. यह LiveDataScope पर काम करता है.
LiveData<T>	`liveData(context: CoroutineContext = EmptyCoroutineContext, timeout: Duration, block: suspend LiveDataScope<T>.() -> Unit)` यह एक LiveData बनाता है, जिसमें दिए गए ब्लॉक से मिली वैल्यू होती हैं. यह LiveDataScope पर काम करता है.

androidx.navigation

डिपेंडेंसी

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

एक्सटेंशन फ़ंक्शन

android.app.Activity के लिए

NavController	`Activity.findNavController(@IdRes viewId: Int)` किसी व्यू और उसमें मौजूद Activity के आईडी के हिसाब से, NavController ढूंढता है.
NavArgsLazy<Args>	`Activity.navArgs()` यह फ़ंक्शन, ऐक्टिविटी के एक्स्ट्रा को Args इंस्टेंस के तौर पर ऐक्सेस करने के लिए, Lazy डेलिगेट दिखाता है.

android.view.View के लिए

NavController

View.findNavController()

किसी View से जुड़े NavController को ढूंढें.

NavGraphBuilder के लिए

यूनिट	`NavGraphBuilder.activity(@IdRes id: Int, builder: ActivityNavigatorDestinationBuilder.() -> Unit)` नया ActivityNavigator.Destination बनाएं
यूनिट	`NavGraphBuilder.navigation(@IdRes id: Int, @IdRes startDestination: Int, builder: NavGraphBuilder.() -> Unit)` नेस्ट किया गया NavGraph बनाना

NavGraph के लिए

operator Boolean	`NavGraph.contains(@IdRes id: Int)` अगर इस नेविगेशन ग्राफ़ में `id` वाला डेस्टिनेशन मिलता है, तो `true` दिखाता है.
operator NavDestination	`NavGraph.get(@IdRes id: Int)` यह फ़ंक्शन, `id` के साथ डेस्टिनेशन दिखाता है.
operator Unit	`NavGraph.minusAssign(node: NavDestination)` इस नेविगेशन ग्राफ़ से `node` को हटाता है.
operator Unit	`NavGraph.plusAssign(node: NavDestination)` इस NavGraph में डेस्टिनेशन जोड़ता है.
operator Unit	`NavGraph.plusAssign(other: NavGraph)` किसी दूसरे कलेक्शन के सभी डेस्टिनेशन, इस कलेक्शन में जोड़ें.

NavController के लिए

NavGraph

NavController.createGraph(@IdRes id: Int = 0, @IdRes startDestination: Int, builder: NavGraphBuilder.() -> Unit)

नया NavGraph बनाना

NavHost के लिए

NavGraph

NavHost.createGraph(@IdRes id: Int = 0, @IdRes startDestination: Int, builder: NavGraphBuilder.() -> Unit)

नया NavGraph बनाना

NavigatorProvider के लिए

operator T	`NavigatorProvider.get(name: String)` यह रजिस्टर किए गए Navigator को नाम के हिसाब से वापस लाता है.
operator T	`NavigatorProvider.get(clazz: KClass<T>)` यह फ़ंक्शन, Navigator.Name annotation से मिले नाम का इस्तेमाल करके, रजिस्टर किए गए Navigator को वापस लाता है.
NavGraph	`NavigatorProvider.navigation(@IdRes id: Int = 0, @IdRes startDestination: Int, builder: NavGraphBuilder.() -> Unit)` नया NavGraph बनाना
operator Unit	`NavigatorProvider.plusAssign(navigator: Navigator<out NavDestination>)` Navigator.Name annotation से मिले नाम का इस्तेमाल करके, नेविगेटर को रजिस्टर करें.
operator Navigator<out NavDestination!>?	`NavigatorProvider.set(name: String, navigator: Navigator<out NavDestination>)` नाम के हिसाब से Navigator को रजिस्टर करें.

फ़्रैगमेंट के लिए

Lazy<VM>

Fragment.navGraphViewModels(@IdRes navGraphId: Int, noinline factoryProducer: () -> ViewModelProvider.Factory = null)

यह फ़ंक्शन, प्रॉपर्टी डेलिगेट दिखाता है. इससे {@link NavController} के बैक स्टैक में मौजूद नेविगेशन ग्राफ़ के स्कोप वाले ViewModel को ऐक्सेस किया जा सकता है:

टॉप-लेवल फ़ंक्शन

ActivityNavigator.Extras	`ActivityNavigatorExtras(activityOptions: ActivityOptionsCompat? = null, flags: Int = 0)` किसी खास ActivityOptionsCompat इंस्टेंस और/या किसी भी `Intent.FLAG_ACTIVITY_` फ़्लैग के साथ, एक नया ActivityNavigator.Extras इंस्टेंस बनाएं.
NavOptions	`navOptions(optionsBuilder: NavOptionsBuilder.() -> Unit)` नया NavOptions बनाएं

androidx.navigation.fragment

डिपेंडेंसी

Groovy

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

Kotlin

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

एक्सटेंशन फ़ंक्शन

NavGraphBuilder के लिए

यूनिट	`NavGraphBuilder.dialog(@IdRes id: Int)` नया DialogFragmentNavigator.Destination बनाएं
यूनिट	`NavGraphBuilder.dialog(@IdRes id: Int, builder: DialogFragmentNavigatorDestinationBuilder.() -> Unit)` नया DialogFragmentNavigator.Destination बनाएं
यूनिट	`NavGraphBuilder.fragment(@IdRes id: Int)` नया FragmentNavigator.Destination बनाएं
यूनिट	`NavGraphBuilder.fragment(@IdRes id: Int, builder: FragmentNavigatorDestinationBuilder.() -> Unit)` नया FragmentNavigator.Destination बनाएं

फ़्रैगमेंट के लिए

NavController	`Fragment.findNavController()` किसी Fragment के लिए NavController ढूंढना
NavArgsLazy<Args>	`Fragment.navArgs()` Args इंस्टेंस के तौर पर फ़्रैगमेंट के आर्ग्युमेंट को ऐक्सेस करने के लिए, Lazy डेलिगेट दिखाता है.

टॉप-लेवल फ़ंक्शन

FragmentNavigator.Extras

FragmentNavigatorExtras(vararg sharedElements: Pair<View, String>)

शेयर किए गए दिए गए एलिमेंट के साथ, FragmentNavigator.Extras का नया इंस्टेंस बनाएं

androidx.navigation.ui

डिपेंडेंसी

Groovy

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

Kotlin

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

एक्सटेंशन फ़ंक्शन

android.view.MenuItem के लिए

बूलियन

MenuItem.onNavDestinationSelected(navController: NavController)

इस MenuItem से जुड़े NavDestination पर जाने की कोशिश करता है.

androidx.appcompat.app.AppCompatActivity के लिए

यूनिट	`AppCompatActivity.setupActionBarWithNavController(navController: NavController, drawerLayout: DrawerLayout?)` यह AppCompatActivity.getSupportActionBar से मिले ActionBar को NavController के साथ इस्तेमाल करने के लिए सेट अप करता है.
यूनिट	`AppCompatActivity.setupActionBarWithNavController(navController: NavController, configuration: AppBarConfiguration = AppBarConfiguration(navController.graph))` यह AppCompatActivity.getSupportActionBar से मिले ActionBar को NavController के साथ इस्तेमाल करने के लिए सेट अप करता है.

androidx.appcompat.widget.Toolbar के लिए

यूनिट	`Toolbar.setupWithNavController(navController: NavController, drawerLayout: DrawerLayout?)` यह NavController के साथ इस्तेमाल करने के लिए, Toolbar सेट अप करता है.
यूनिट	`Toolbar.setupWithNavController(navController: NavController, configuration: AppBarConfiguration = AppBarConfiguration(navController.graph))` यह NavController के साथ इस्तेमाल करने के लिए, Toolbar सेट अप करता है.

com.google.android.material.appbar.CollapsingToolbarLayout के लिए

यूनिट	`CollapsingToolbarLayout.setupWithNavController(toolbar: Toolbar, navController: NavController, drawerLayout: DrawerLayout?)` यह NavController के साथ इस्तेमाल करने के लिए, CollapsingToolbarLayout और Toolbar सेट अप करता है.
यूनिट	`CollapsingToolbarLayout.setupWithNavController(toolbar: Toolbar, navController: NavController, configuration: AppBarConfiguration = AppBarConfiguration(navController.graph))` यह NavController के साथ इस्तेमाल करने के लिए, CollapsingToolbarLayout और Toolbar सेट अप करता है.

com.google.android.material.bottomnavigation.BottomNavigationView के लिए

यूनिट

BottomNavigationView.setupWithNavController(navController: NavController)

यह NavController के साथ इस्तेमाल करने के लिए, BottomNavigationView सेट अप करता है.

com.google.android.material.navigation.NavigationView के लिए

यूनिट

NavigationView.setupWithNavController(navController: NavController)

यह NavController के साथ इस्तेमाल करने के लिए, NavigationView सेट अप करता है.

NavController के लिए

बूलियन	`NavController.navigateUp(drawerLayout: DrawerLayout?)` यह दिए गए NavController को अप बटन का व्यवहार सौंपकर, उसे हैंडल करता है.
बूलियन	`NavController.navigateUp(appBarConfiguration: AppBarConfiguration)` यह दिए गए NavController को अप बटन का व्यवहार सौंपकर, उसे हैंडल करता है.

टॉप-लेवल फ़ंक्शन

AppBarConfiguration	`AppBarConfiguration(navGraph: NavGraph, drawerLayout: DrawerLayout? = null, noinline fallbackOnNavigateUpListener: () -> Boolean = { false })` NavigationUI के उन तरीकों के लिए कॉन्फ़िगरेशन के विकल्प जो ऐप्लिकेशन बार पैटर्न के साथ इंटरैक्ट करते हैं. जैसे, android.support.v7.widget.Toolbar, android.support.design.widget.CollapsingToolbarLayout, और android.support.v7.app.ActionBar.
AppBarConfiguration	`AppBarConfiguration(topLevelMenu: Menu, drawerLayout: DrawerLayout? = null, noinline fallbackOnNavigateUpListener: () -> Boolean = { false })` NavigationUI के उन तरीकों के लिए कॉन्फ़िगरेशन के विकल्प जो ऐप्लिकेशन बार पैटर्न के साथ इंटरैक्ट करते हैं. जैसे, android.support.v7.widget.Toolbar, android.support.design.widget.CollapsingToolbarLayout, और android.support.v7.app.ActionBar.
AppBarConfiguration	`AppBarConfiguration(topLevelDestinationIds: Set<Int>, drawerLayout: DrawerLayout? = null, noinline fallbackOnNavigateUpListener: () -> Boolean = { false })` NavigationUI के उन तरीकों के लिए कॉन्फ़िगरेशन के विकल्प जो ऐप्लिकेशन बार पैटर्न के साथ इंटरैक्ट करते हैं. जैसे, android.support.v7.widget.Toolbar, android.support.design.widget.CollapsingToolbarLayout, और android.support.v7.app.ActionBar.

androidx.paging

डिपेंडेंसी

Groovy

dependencies {
    implementation "androidx.paging:paging-common-ktx:2.1.2"
    implementation "androidx.paging:paging-runtime-ktx:2.1.2"
    implementation "androidx.paging:paging-rxjava2-ktx:2.1.2"
}

Kotlin

dependencies {
    implementation("androidx.paging:paging-common-ktx:2.1.2")
    implementation("androidx.paging:paging-runtime-ktx:2.1.2")
    implementation("androidx.paging:paging-rxjava2-ktx:2.1.2")
}

एक्सटेंशन फ़ंक्शन

Factory के लिए

Flowable<PagedList<Value>>	`DataSource.Factory<Key, Value>.toFlowable(config: PagedList.Config, initialLoadKey: Key? = null, boundaryCallback: PagedList.BoundaryCallback<Value>? = null, fetchScheduler: Scheduler? = null, notifyScheduler: Scheduler? = null, backpressureStrategy: BackpressureStrategy = BackpressureStrategy.LATEST)` यह `DataSource.Factory` से `Flowable<PagedList>` बनाता है. इससे RxPagedListBuilder को आसानी होती है.
Flowable<PagedList<Value>>	`DataSource.Factory<Key, Value>.toFlowable(pageSize: Int, initialLoadKey: Key? = null, boundaryCallback: PagedList.BoundaryCallback<Value>? = null, fetchScheduler: Scheduler? = null, notifyScheduler: Scheduler? = null, backpressureStrategy: BackpressureStrategy = BackpressureStrategy.LATEST)` यह `DataSource.Factory` से `Flowable<PagedList>` बनाता है. इससे RxPagedListBuilder को आसानी होती है.
LiveData<PagedList<Value>>	`DataSource.Factory<Key, Value>.toLiveData(config: PagedList.Config, initialLoadKey: Key? = null, boundaryCallback: PagedList.BoundaryCallback<Value>? = null, fetchExecutor: Executor = ArchTaskExecutor.getIOThreadExecutor())` यह `LiveData<PagedList>` से `LiveData<PagedList>` बनाता है, ताकि LivePagedListBuilder को आसानी हो.`DataSource.Factory`
LiveData<PagedList<Value>>	`DataSource.Factory<Key, Value>.toLiveData(pageSize: Int, initialLoadKey: Key? = null, boundaryCallback: PagedList.BoundaryCallback<Value>? = null, fetchExecutor: Executor = ArchTaskExecutor.getIOThreadExecutor())` यह `LiveData<PagedList>` से `LiveData<PagedList>` बनाता है, ताकि LivePagedListBuilder को आसानी हो.`DataSource.Factory`
Observable<PagedList<Value>>	`DataSource.Factory<Key, Value>.toObservable(config: PagedList.Config, initialLoadKey: Key? = null, boundaryCallback: PagedList.BoundaryCallback<Value>? = null, fetchScheduler: Scheduler? = null, notifyScheduler: Scheduler? = null)` इस `DataSource.Factory` से `Observable<PagedList>` बनाता है. इससे RxPagedListBuilder को आसानी होती है.
Observable<PagedList<Value>>	`DataSource.Factory<Key, Value>.toObservable(pageSize: Int, initialLoadKey: Key? = null, boundaryCallback: PagedList.BoundaryCallback<Value>? = null, fetchScheduler: Scheduler? = null, notifyScheduler: Scheduler? = null)` इस `DataSource.Factory` से `Observable<PagedList>` बनाता है. इससे RxPagedListBuilder को आसानी होती है.

टॉप-लेवल फ़ंक्शन

PagedList.Config	`Config(pageSize: Int, prefetchDistance: Int = pageSize, enablePlaceholders: Boolean = true, initialLoadSizeHint: Int = pageSize * PagedList.Config.Builder.DEFAULT_INITIAL_PAGE_MULTIPLIER, maxSize: Int = PagedList.Config.MAX_SIZE_UNBOUNDED)` यह PagedList.Config बनाता है. यह PagedList.Config.Builder के लिए सुविधाजनक है.
PagedList<Value>	`PagedList(dataSource: DataSource<Key, Value>, config: PagedList.Config, notifyExecutor: Executor, fetchExecutor: Executor, boundaryCallback: PagedList.BoundaryCallback<Value>? = null, initialKey: Key? = null)` यह PagedList बनाता है, जो PagedList.Builder के लिए सुविधाजनक है.

androidx.palette.graphics

डिपेंडेंसी

ग्रूवी

dependencies {
    implementation "androidx.palette:palette-ktx:1.0.0"
}

Kotlin

dependencies {
    implementation("androidx.palette:palette-ktx:1.0.0")
}

एक्सटेंशन फ़ंक्शन

पैलेट के लिए

operator Palette.Swatch?

Palette.get(target: Target)

यह फ़ंक्शन, पैलेट से दिए गए टारगेट के लिए चुना गया स्वैच दिखाता है. अगर कोई स्वैच नहीं मिलता है, तो यह null दिखाता है.

androidx.preference

डिपेंडेंसी

ग्रूवी

dependencies {
    implementation "androidx.preference:preference-ktx:1.2.1"
}

Kotlin

dependencies {
    implementation("androidx.preference:preference-ktx:1.2.1")
}

एक्सटेंशन फ़ंक्शन

PreferenceGroup के लिए

operator Boolean	`PreferenceGroup.contains(preference: Preference)` अगर `preference` इस प्राथमिकता ग्रुप में मौजूद है, तो `true` दिखाता है.
यूनिट	`PreferenceGroup.forEach(action: (preference: Preference) -> Unit)` यह इस प्राथमिकता ग्रुप में मौजूद हर प्राथमिकता पर दी गई कार्रवाई करता है.
यूनिट	`PreferenceGroup.forEachIndexed(action: (index: Int, preference: Preference) -> Unit)` यह फ़ंक्शन, इस प्राथमिकता ग्रुप में मौजूद हर प्राथमिकता पर दी गई कार्रवाई करता है. साथ ही, इसका क्रमवार इंडेक्स देता है.
operator T?	`PreferenceGroup.get(key: CharSequence)` `key` के साथ प्राथमिकता दिखाता है. अगर `key` के साथ कोई प्राथमिकता नहीं मिलती है, तो `null` दिखाता है.
operator Preference	`PreferenceGroup.get(index: Int)` `index` पर मौजूद सेटिंग की वैल्यू दिखाता है.
बूलियन	`PreferenceGroup.isEmpty()` अगर इस प्राथमिकता वाले ग्रुप में कोई प्राथमिकता नहीं है, तो यह फ़ंक्शन 'सही' दिखाता है.
बूलियन	`PreferenceGroup.isNotEmpty()` अगर इस प्राथमिकता वाले ग्रुप में एक या उससे ज़्यादा प्राथमिकताएं शामिल हैं, तो यह फ़ंक्शन सही वैल्यू दिखाता है.
operator MutableIterator<Preference>	`PreferenceGroup.iterator()` यह फ़ंक्शन, इस प्राथमिकता ग्रुप में मौजूद प्राथमिकताओं पर MutableIterator दिखाता है.
operator Unit	`PreferenceGroup.minusAssign(preference: Preference)` इस कुकी का इस्तेमाल, `preference` को इस प्राथमिकता वाले ग्रुप से हटाने के लिए किया जाता है.
operator Unit	`PreferenceGroup.plusAssign(preference: Preference)` इस सेटिंग ग्रुप में `preference` को जोड़ता है.

एक्सटेंशन प्रॉपर्टी

PreferenceGroup के लिए

Sequence<Preference>	`PreferenceGroup.children()` यह फ़ंक्शन, इस प्राथमिकता ग्रुप में मौजूद प्राथमिकताओं के हिसाब से Sequence दिखाता है.
Int	`PreferenceGroup.size()` इस प्राथमिकता ग्रुप में मौजूद प्राथमिकताओं की संख्या दिखाता है.

androidx.room

डिपेंडेंसी

ग्रूवी

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

Kotlin

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

एक्सटेंशन फ़ंक्शन

RoomDatabase के लिए

suspend R

RoomDatabase.withTransaction(block: suspend () -> R)

डेटाबेस के लेन-देन में, निलंबित करने वाले ब्लॉक को कॉल करता है.

androidx.slice.builders

डिपेंडेंसी

ग्रूवी

dependencies {
    implementation "androidx.slice:slice-builders-ktx:1.0.0-alpha08"
}

Kotlin

dependencies {
    implementation("androidx.slice:slice-builders-ktx:1.0.0-alpha08")
}

एक्सटेंशन फ़ंक्शन

GridRowBuilderDsl के लिए

GridRowBuilder	`GridRowBuilderDsl.cell(buildCell: CellBuilderDsl.() -> Unit)`
GridRowBuilder	`GridRowBuilderDsl.seeMoreCell(buildCell: CellBuilderDsl.() -> Unit)`

ListBuilderDsl के लिए

ListBuilder	`ListBuilderDsl.gridRow(buildGrid: GridRowBuilderDsl.() -> Unit)`
ListBuilder	`ListBuilderDsl.header(buildHeader: HeaderBuilderDsl.() -> Unit)`
ListBuilder	`ListBuilderDsl.inputRange(buildInputRange: InputRangeBuilderDsl.() -> Unit)`
ListBuilder	`ListBuilderDsl.range(buildRange: RangeBuilderDsl.() -> Unit)`
ListBuilder	`ListBuilderDsl.row(buildRow: RowBuilderDsl.() -> Unit)`
ListBuilder	`ListBuilderDsl.seeMoreRow(buildRow: RowBuilderDsl.() -> Unit)`

टॉप-लेवल फ़ंक्शन

स्लाइस करें	`list(context: Context, uri: Uri, ttl: Long, addRows: ListBuilderDsl.() -> Unit)` इससे Kotlin में स्लाइस बनाने के लिए, ज़्यादा शब्दों का इस्तेमाल करने की ज़रूरत नहीं पड़ती.
SliceAction	`tapSliceAction(pendingIntent: PendingIntent, icon: IconCompat, imageMode: Int = ICON_IMAGE, title: CharSequence)` टैप की जा सकने वाली SliceAction बनाने के लिए फ़ैक्ट्री मेथड.
SliceAction	`toggleSliceAction(pendingIntent: PendingIntent, icon: IconCompat? = null, title: CharSequence, isChecked: Boolean)` टॉगल की जा सकने वाली SliceAction बनाने के लिए फ़ैक्ट्री मेथड.

androidx.sqlite.db

डिपेंडेंसी

ग्रूवी

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

Kotlin

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

एक्सटेंशन फ़ंक्शन

SupportSQLiteDatabase के लिए

T	`SupportSQLiteDatabase.transaction(exclusive: Boolean = true, body: SupportSQLiteDatabase.() -> T)` अगर body बिना किसी गड़बड़ी के पूरा हो जाता है, तो उसे लेन-देन में शामिल करें और उसे 'सफल' के तौर पर मार्क करें.

androidx.work

डिपेंडेंसी

एक्सटेंशन फ़ंक्शन

com.google.common.util.concurrent.ListenableFuture के लिए

suspend R

ListenableFuture<R>.await()

यह किसी थ्रेड को ब्लॉक किए बिना, ListenableFuture के पूरा होने का इंतज़ार करता है.

ऑपरेशन के लिए

suspend Operation.State.SUCCESS!

Operation.await()

यह थ्रेड को ब्लॉक किए बिना, Operation का इंतज़ार करता है.

डेटा के लिए

बूलियन

Data.hasKeyWithValueOfType(key: String)

अगर Data के इंस्टेंस में, दिए गए key के हिसाब से T टाइप की वैल्यू मौजूद है, तो यह फ़ंक्शन true दिखाता है.

बिल्डर के लिए

OneTimeWorkRequest.Builder

OneTimeWorkRequest.Builder.setInputMerger(@NonNull inputMerger: KClass<out InputMerger>)

OneTimeWorkRequest.Builder पर InputMerger सेट करता है.

टॉप-लेवल फ़ंक्शन

OneTimeWorkRequest.Builder	`OneTimeWorkRequestBuilder()` यह दिए गए ListenableWorker के साथ एक OneTimeWorkRequest बनाता है.
PeriodicWorkRequest.Builder	`PeriodicWorkRequestBuilder(repeatInterval: Long, repeatIntervalTimeUnit: TimeUnit)` यह दिए गए ListenableWorker के साथ PeriodicWorkRequest.Builder बनाता है.
PeriodicWorkRequest.Builder	`PeriodicWorkRequestBuilder(repeatInterval: Duration)` यह दिए गए ListenableWorker के साथ PeriodicWorkRequest.Builder बनाता है.
PeriodicWorkRequest.Builder	`PeriodicWorkRequestBuilder(repeatInterval: Long, repeatIntervalTimeUnit: TimeUnit, flexTimeInterval: Long, flexTimeIntervalUnit: TimeUnit)` यह दिए गए ListenableWorker के साथ PeriodicWorkRequest.Builder बनाता है.
PeriodicWorkRequest.Builder	`PeriodicWorkRequestBuilder(repeatInterval: Duration, flexTimeInterval: Duration)` यह दिए गए ListenableWorker के साथ PeriodicWorkRequest.Builder बनाता है.
डेटा	`workDataOf(vararg pairs: Pair<String, Any?>)` जोड़ों की सूची को डेटा ऑब्जेक्ट में बदलता है.

androidx.work.testing

डिपेंडेंसी

ग्रूवी

dependencies {
    implementation "androidx.work:work-testing:2.10.3"
}

Kotlin

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

टॉप-लेवल फ़ंक्शन

TestListenableWorkerBuilder<W>	`TestListenableWorkerBuilder(context: Context, inputData: Data = Data.EMPTY, tags: List<String> = emptyList(), runAttemptCount: Int = 1, triggeredContentUris: List<Uri> = emptyList(), triggeredContentAuthorities: List<String> = emptyList())` यह TestListenableWorkerBuilder का इंस्टेंस बनाता है.
TestWorkerBuilder<W>	`TestWorkerBuilder(context: Context, executor: Executor, inputData: Data = Data.EMPTY, tags: List<String> = emptyList(), runAttemptCount: Int = 1, triggeredContentUris: List<Uri> = emptyList(), triggeredContentAuthorities: List<String> = emptyList())` यह TestWorkerBuilder का इंस्टेंस बनाता है.

com.google.android.play.core.ktx

डिपेंडेंसी

Groovy

dependencies {
    implementation "com.google.android.play:core-ktx:1.8.1"
}

Kotlin

dependencies {
    implementation("com.google.android.play:core-ktx:1.8.1")
}

एक्सटेंशन फ़ंक्शन

com.google.android.play.core.appupdate.AppUpdateManager के लिए

suspend AppUpdateInfo	`AppUpdateManager.requestAppUpdateInfo()` यह मौजूदा ऐप्लिकेशन के लिए अपडेट की उपलब्धता का अनुरोध करता है
suspend Unit	`AppUpdateManager.requestCompleteUpdate()` अपडेट के फ़्लो को बेहतर बनाने के लिए, अपडेट पूरा होने की प्रोसेस को ट्रिगर करता है.
Flow<AppUpdateResult>	`AppUpdateManager.requestUpdateFlow()` अपडेट की उपलब्धता और प्रोग्रेस को मॉनिटर करने के लिए एंट्री पॉइंट.
बूलियन	`AppUpdateManager.startUpdateFlowForResult(appUpdateInfo: AppUpdateInfo, appUpdateType: Int, fragment: Fragment, requestCode: Int)` AppUpdateManager.startUpdateFlowForResult का ऐसा वर्शन जो नतीजे दिखाने के लिए, AndroidX फ़्रैगमेंट स्वीकार करता है.

com.google.android.play.core.splitinstall.SplitInstallManager के लिए

suspend Unit	`SplitInstallManager.requestCancelInstall(sessionId: Int)` SplitInstallManager.cancelInstall का निलंबित वर्शन
suspend Unit	`SplitInstallManager.requestDeferredInstall(moduleNames: List<String>)` SplitInstallManager.deferredInstall का निलंबित किया गया वर्शन
suspend Unit	`SplitInstallManager.requestDeferredLanguageInstall(languages: List<Locale>)` SplitInstallManager.deferredLanguageInstall के वर्शन को निलंबित करें
suspend Unit	`SplitInstallManager.requestDeferredLanguageUninstall(languages: List<Locale>)` SplitInstallManager.deferredLanguageUninstall का निलंबित किया गया वर्शन
suspend Unit	`SplitInstallManager.requestDeferredUninstall(moduleNames: List<String>)` SplitInstallManager.deferredUninstall का निलंबित किया गया वर्शन
suspend Int	`SplitInstallManager.requestInstall(modules: List<String> = listOf(), languages: List<String> = listOf())` इससे अनुरोध किए गए मॉड्यूल/भाषाओं को इंस्टॉल करने की प्रोसेस शुरू होती है.
Flow<SplitInstallSessionState>	`SplitInstallManager.requestProgressFlow()` यह फ़ंक्शन, बफ़र किया गया Flow बनाता है और उसे दिखाता है. यह फ़ंक्शन, स्प्लिट इंस्टॉलेशन की प्रोसेस के दौरान होने वाले सभी प्रोग्रेस इवेंट को डिलीवर करेगा.
suspend SplitInstallSessionState	`SplitInstallManager.requestSessionState(sessionId: Int)` SplitInstallManager.getSessionState का निलंबित वर्शन
suspend List<SplitInstallSessionState>	`SplitInstallManager.requestSessionStates()` SplitInstallManager.getSessionStates का निलंबित वर्शन
बूलियन	`SplitInstallManager.startConfirmationDialogForResult(sessionState: SplitInstallSessionState, fragment: Fragment, requestCode: Int)` SplitInstallManager.startConfirmationDialogForResult का ऐसा वर्शन जो नतीजे दिखाने के लिए, AndroidX फ़्रैगमेंट को स्वीकार करता है.

एक्सटेंशन प्रॉपर्टी

com.google.android.play.core.appupdate.AppUpdateInfo के लिए

Int	`AppUpdateInfo.installStatus()` अपडेट की प्रोग्रेस का स्टेटस दिखाता है.
बूलियन	`AppUpdateInfo.isFlexibleUpdateAllowed()` अगर फ़्लेक्सिबल अपडेट की अनुमति है, तो `true` दिखाता है.
बूलियन	`AppUpdateInfo.isImmediateUpdateAllowed()` अगर तुरंत अपडेट करने की अनुमति है, तो `true` दिखाता है.

com.google.android.play.core.install.InstallState के लिए

बूलियन	`InstallState.hasTerminalStatus()` इसका मतलब है कि यह आखिरी स्टेटस है (अब कोई और अपडेट नहीं मिलेगा). इसलिए, इसे उसी हिसाब से हैंडल किया जाना चाहिए (सफल, रद्द या विफल).
Int	`InstallState.installErrorCode()` यह फ़ंक्शन, इंस्टॉल करने से जुड़ी गड़बड़ी का कोड या {@link InstallErrorCode#NO_ERROR} दिखाता है.
Int	`InstallState.installStatus()` यह फ़ंक्शन, इंस्टॉल करने की प्रोसेस का स्टेटस दिखाता है.
String!	`InstallState.packageName()` यह फ़ंक्शन, इंस्टॉल किए जा रहे ऐप्लिकेशन के पैकेज का नाम दिखाता है.

com.google.android.play.core.splitinstall.SplitInstallSessionState के लिए

Long	`SplitInstallSessionState.bytesDownloaded()` इस अपडेट से डाउनलोड किए गए बाइट.
Int	`SplitInstallSessionState.errorCode()` इस अपडेट का गड़बड़ी कोड.
बूलियन	`SplitInstallSessionState.hasTerminalStatus()` इससे पता चलता है कि यह अपडेट आखिरी है. इसका मतलब है कि इस सेशन के लिए कोई और अपडेट नहीं होगा.
List<String>	`SplitInstallSessionState.languages()` इस अपडेट में शामिल भाषाएं.
List<String>	`SplitInstallSessionState.moduleNames()` इस अपडेट में शामिल किए गए मॉड्यूल.
Int	`SplitInstallSessionState.sessionId()` इस अपडेट का सेशन आईडी.
Int	`SplitInstallSessionState.status()` इस अपडेट का स्टेटस कोड.
Long	`SplitInstallSessionState.totalBytesToDownload()` इस अपडेट को डाउनलोड करने के लिए कुल बाइट.

टॉप-लेवल फ़ंक्शन

SplitInstallStateUpdatedListener

SplitInstallStateUpdatedListener(onRequiresConfirmation: (SplitInstallSessionState) -> Unit, onInstalled: (SplitInstallSessionState) -> Unit, onFailed: (SplitInstallSessionState) -> Unit = {}, onPending: (SplitInstallSessionState) -> Unit = {}, onDownloaded: (SplitInstallSessionState) -> Unit = {}, onDownloading: (SplitInstallSessionState) -> Unit = {}, onInstalling: (SplitInstallSessionState) -> Unit = {}, onCanceling: (SplitInstallSessionState) -> Unit = {}, onCanceled: (SplitInstallSessionState) -> Unit = {}, onNonTerminalStatus: (SplitInstallSessionState) -> Unit = {}, onTerminalStatus: (SplitInstallSessionState) -> Unit = {})

यह SplitInstallStateUpdatedListener बनाने के लिए एक आसान फ़ंक्शन है.