androidx.activity
निर्भर है
Groovy
dependencies { implementation "androidx.activity:activity-ktx:1.13.0" }
Kotlin
dependencies { implementation("androidx.activity:activity-ktx:1.13.0") }
एक्सटेंशन फ़ंक्शन
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 तय किया गया है, तो पहली बार ViewModel बनाने के लिए, इससे मिलने वाले ViewModelProvider.Factory का इस्तेमाल किया जाएगा. |
androidx.benchmark
निर्भर है
Groovy
dependencies { implementation "androidx.benchmark:benchmark-junit4:1.5.0" }
Kotlin
dependencies { implementation("androidx.benchmark:benchmark-junit4:1.5.0") }
टॉप-लेवल फ़ंक्शन
| यूनिट |
beginTraceSection(sectionName: String)
|
| यूनिट |
endTraceSection()
|
androidx.benchmark.junit4
निर्भर है
Groovy
dependencies { implementation "androidx.benchmark:benchmark-junit4:1.5.0" }
Kotlin
dependencies { implementation("androidx.benchmark:benchmark-junit4:1.5.0") }
एक्सटेंशन फ़ंक्शन
BenchmarkRule के लिए
| यूनिट |
BenchmarkRule.measureRepeated(crossinline block: BenchmarkRule.Scope.() -> Unit)
कोड के किसी ब्लॉक को बेंचमार्क करना. |
androidx.collection
निर्भर है
Groovy
dependencies { implementation "androidx.collection:collection-ktx:1.6.0" }
Kotlin
dependencies { implementation("androidx.collection:collection-ktx:1.6.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 से जुड़ी वैल्यू दिखाता है. अगर वैल्यू मौजूद नहीं है, तो defaultValue दिखाता है. |
| T |
LongSparseArray<T>.getOrElse(key: Long, defaultValue: () -> T)
key से जुड़ी वैल्यू दिखाता है. अगर वैल्यू मौजूद नहीं है, तो defaultValue से वैल्यू दिखाता है. |
| बूलियन |
LongSparseArray<T>.isNotEmpty()
कलेक्शन में एलिमेंट होने पर, True वैल्यू दिखाएं. |
| LongIterator |
LongSparseArray<T>.keyIterator()
कलेक्शन की कुंजियों पर एक इटरेटर दिखाता है. |
| operator LongSparseArray<T> |
LongSparseArray<T>.plus(other: LongSparseArray<T>)
अन्य से एंट्री जोड़कर या बदलकर, नया कलेक्शन बनाता है. |
| बूलियन |
LongSparseArray<T>.remove(key: Long, value: T)
कुंजी की एंट्री को सिर्फ़ तब हटाता है, जब उसे वैल्यू से मैप किया गया हो. |
| 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 से जुड़ी वैल्यू दिखाता है. अगर वैल्यू मौजूद नहीं है, तो defaultValue दिखाता है. |
| T |
SparseArrayCompat<T>.getOrElse(key: Int, defaultValue: () -> T)
key से जुड़ी वैल्यू दिखाता है. अगर वैल्यू मौजूद नहीं है, तो defaultValue से वैल्यू दिखाता है. |
| बूलियन |
SparseArrayCompat<T>.isNotEmpty()
कलेक्शन में एलिमेंट होने पर, True वैल्यू दिखाएं. |
| IntIterator |
SparseArrayCompat<T>.keyIterator()
कलेक्शन की कुंजियों पर एक इटरेटर दिखाता है. |
| operator SparseArrayCompat<T> |
SparseArrayCompat<T>.plus(other: SparseArrayCompat<T>)
अन्य से एंट्री जोड़कर या बदलकर, नया कलेक्शन बनाता है. |
| बूलियन |
SparseArrayCompat<T>.remove(key: Int, value: T)
कुंजी की एंट्री को सिर्फ़ तब हटाता है, जब उसे वैल्यू से मैप किया गया हो. |
| 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<K, V> |
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.19.1" }
Kotlin
dependencies { implementation("androidx.core:core-ktx:1.19.1") }
एक्सटेंशन फ़ंक्शन
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.19.1" }
Kotlin
dependencies { implementation("androidx.core:core-ktx:1.19.1") }
एक्सटेंशन फ़ंक्शन
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 रिसीवर पर ब्लॉक को लागू करता है. |
| यूनिट |
Context.withStyledAttributes(@StyleRes resourceId: Int, attrs: IntArray, block: TypedArray.() -> Unit)
TypedArray रिसीवर पर ब्लॉक को लागू करता है. |
android.content.SharedPreferences के लिए
| यूनिट |
SharedPreferences.edit(: Boolean = false, : Editor.() -> Unit)
लागू करें या कमिट करें को कॉल करके, इस प्राथमिकता इंस्टेंस में बदलाव करने की अनुमति देता है, ताकि बदलावों को सेव किया जा सके. |
टॉप-लेवल फ़ंक्शन
| ContentValues |
contentValuesOf(vararg pairs: Pair<String, Any?>)
यह एलिमेंट के तौर पर, दिए गए मुख्य/वैल्यू पेयर के साथ एक नया ContentValues दिखाता है. |
androidx.core.content.res
निर्भर है
Groovy
dependencies { implementation "androidx.core:core-ktx:1.19.1" }
Kotlin
dependencies { implementation("androidx.core:core-ktx:1.19.1") }
एक्सटेंशन फ़ंक्शन
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 पर दिए गए ब्लॉक फ़ंक्शन को लागू करता है और फिर उसे रीसाइकल करता है. |
androidx.core.database
निर्भर है
Groovy
dependencies { implementation "androidx.core:core-ktx:1.19.1" }
Kotlin
dependencies { implementation("androidx.core:core-ktx:1.19.1") }
एक्सटेंशन फ़ंक्शन
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.19.1" }
Kotlin
dependencies { implementation("androidx.core:core-ktx:1.19.1") }
एक्सटेंशन फ़ंक्शन
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.19.1" }
Kotlin
dependencies { implementation("androidx.core:core-ktx:1.19.1") }
एक्सटेंशन फ़ंक्शन
android.graphics.Bitmap के लिए
| बिट मैप |
Bitmap.applyCanvas(block: Canvas.() -> Unit)
इस बिटमैप पर ड्रॉ करने के लिए, एक नया कैनवस बनाता है और नए बनाए गए कैनवस पर, तय किया गया ब्लॉक लागू करता है. |
| operator Boolean |
Bitmap.contains(p: Point)
अगर तय किया गया पॉइंट बिटमैप के अंदर है, तो यह true दिखाता है. |
| 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)
तय किए गए |
android.graphics.Canvas के लिए
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)
किसी सोर्स से ड्रॉएबल बनाना |
android.graphics.Matrix के लिए
| ऑपरेटर मैट्रिक्स |
Matrix.times(m: 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)
इस इमेज में कमांड रिकॉर्ड करने के लिए, एक नया कैनवस बनाता है. साथ ही, नए बनाए गए कैनवस पर, तय किए गए ब्लॉक को लागू करता है और इस इमेज को दिखाता है. |
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()
इस पॉइंट को पॉइंट के तौर पर दिखाता है. |
| operator PointF |
PointF.unaryMinus()
यह एक नया पॉइंट दिखाता है, जो इस पॉइंट के निगेशन को दिखाता है. |
android.graphics.PorterDuff.Mode के लिए
| PorterDuffColorFilter |
Mode.toColorFilter(color: Int)
यह एक नया PorterDuffColorFilter बनाता है, जो इस PorterDuff.Mode को ऐल्फ़ा कंपोज़िटिंग या ब्लेंडिंग मोड और तय किए गए रंग के तौर पर इस्तेमाल करता है. |
| 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)
अगर तय किया गया पॉइंट रेक्टैंगल के अंदर है, तो यह true दिखाता है. |
| ऑपरेटर क्षेत्र |
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)
यह फ़ंक्शन, एक नया रेक्टैंगल दिखाता है. इसमें इस रेक्टैंगल के कॉम्पोनेंट को फ़ैक्टर के हिसाब से स्केल किया जाता है. |
| RectF |
Rect.toRectF()
यह इस रेक्टैंगल का RectF रिप्रज़ेंटेशन दिखाता है. |
| क्षेत्र |
Rect.toRegion()
इस रेक्टैंगल का इलाका दिखाता है. |
| 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)
अगर तय किया गया पॉइंट रेक्टैंगल के अंदर है, तो यह true दिखाता है. |
| ऑपरेटर क्षेत्र |
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)
यह फ़ंक्शन, एक नया रेक्टैंगल दिखाता है. इसमें इस रेक्टैंगल के कॉम्पोनेंट को फ़ैक्टर के हिसाब से स्केल किया जाता है. |
| operator RectF |
RectF.times(factor: Float)
यह फ़ंक्शन, एक नया रेक्टैंगल दिखाता है. इसमें इस रेक्टैंगल के कॉम्पोनेंट को फ़ैक्टर के हिसाब से स्केल किया जाता है. |
| Rect |
RectF.toRect()
यह इस रेक्टैंगल का Rect दिखाता है. |
| क्षेत्र |
RectF.toRegion()
इस रेक्टैंगल का इलाका दिखाता है. |
| RectF |
RectF.transform(m: Matrix)
दिए गए मैट्रिक्स का इस्तेमाल करके, इस रेक्टैंगल को अपनी जगह पर ट्रांसफ़ॉर्म करता है और इस रेक्टैंगल को दिखाता है. |
| infix Region |
RectF.xor(r: RectF)
यह फ़ंक्शन, दो रेक्टैंगल के यूनियन में से इंटरसेक्शन को घटाकर, एक नया रेक्टैंगल बनाता है. |
android.graphics.Region के लिए
| infix Region |
Region.and(r: Rect)
इस क्षेत्र और तय किए गए रेक्टैंगल के इंटरसेक्शन को नए क्षेत्र के तौर पर दिखाता है. |
| infix Region |
Region.and(r: Region)
इस क्षेत्र और तय किए गए क्षेत्र के इंटरसेक्शन को नए क्षेत्र के तौर पर दिखाता है. |
| operator Boolean |
Region.contains(p: Point)
अगर क्षेत्र में बताया गया पॉइंट शामिल है, तो 'सही' दिखाता है. |
| यूनिट |
Region.forEach(action: (rect: Rect) -> Unit)
इस क्षेत्र में मौजूद हर रेक्टैंगल पर, दी गई कार्रवाई करता है. |
| operator Iterator<Rect> |
Region.iterator()
इस क्षेत्र में मौजूद रेक्टैंगल के लिए, Iterator दिखाता है. |
| ऑपरेटर क्षेत्र |
Region.minus(r: Rect)
इस क्षेत्र और दिए गए रेक्टैंगल के बीच के अंतर को नए क्षेत्र के तौर पर दिखाएं. |
| ऑपरेटर क्षेत्र |
Region.minus(r: Region)
इस क्षेत्र और बताए गए क्षेत्र के बीच के अंतर को एक नए क्षेत्र के तौर पर दिखाएं. |
| ऑपरेटर क्षेत्र |
Region.not()
इस क्षेत्र के निगेशन को नए क्षेत्र के तौर पर दिखाता है. |
| infix Region |
Region.or(r: Rect)
इस क्षेत्र और दिए गए Rect के यूनियन को नए क्षेत्र के तौर पर दिखाता है. |
| infix Region |
Region.or(r: Region)
इस क्षेत्र और बताए गए क्षेत्र के यूनियन को नए क्षेत्र के तौर पर दिखाता है. |
| ऑपरेटर क्षेत्र |
Region.plus(r: Rect)
इस क्षेत्र और दिए गए Rect के यूनियन को नए क्षेत्र के तौर पर दिखाता है. |
| ऑपरेटर क्षेत्र |
Region.plus(r: 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()
यह कलर इंट से नया कलर इंस्टेंस बनाता है. |
| लंबा |
Int.toColorLong()
यह sRGB कलर स्पेस में, दिए गए ARGB कलर इंट को RGBA कलर लॉन्ग में बदलता है. |
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()
|
| Int |
Long.toColorInt()
यह फ़ंक्शन, दिए गए color long को ARGB color int में बदलता है. |
kotlin.String के लिए
| Int |
String.toColorInt()
|
एक्सटेंशन प्रॉपर्टी
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)
यह |
| मैट्रिक्स |
translationMatrix(tx: Float = 0.0f, ty: Float = 0.0f)
यह |
androidx.core.graphics.drawable
निर्भर है
Groovy
dependencies { implementation "androidx.core:core-ktx:1.19.1" }
Kotlin
dependencies { implementation("androidx.core:core-ktx:1.19.1") }
एक्सटेंशन फ़ंक्शन
android.graphics.Bitmap के लिए
| आइकॉन |
Bitmap.toAdaptiveIcon()
|
| BitmapDrawable |
Bitmap.toDrawable(resources: Resources)
इस बिटमैप से 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.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()
|
kotlin.ByteArray के लिए
| आइकॉन |
ByteArray.toIcon()
|
kotlin.Int के लिए
| ColorDrawable |
Int.toDrawable()
इस कलर वैल्यू से ColorDrawable बनाएं. |
androidx.core.location
निर्भर है
Groovy
dependencies { implementation "androidx.core:core-ktx:1.19.1" }
Kotlin
dependencies { implementation("androidx.core:core-ktx:1.19.1") }
एक्सटेंशन फ़ंक्शन
android.location.Location के लिए
| operator Double |
Location.component1()
इस जगह का अक्षांश दिखाता है. |
| operator Double |
Location.component2()
इस जगह का देशांतर दिखाता है. |
androidx.core.net
निर्भर है
Groovy
dependencies { implementation "androidx.core:core-ktx:1.19.1" }
Kotlin
dependencies { implementation("androidx.core:core-ktx:1.19.1") }
एक्सटेंशन फ़ंक्शन
android.net.Uri के लिए
| फ़ाइल |
Uri.toFile()
|
java.io.File के लिए
| उरी |
File.toUri()
दी गई फ़ाइल से यूआरआई बनाता है. |
kotlin.String के लिए
| उरी |
String.toUri()
यह कोड में बदली गई यूआरआई स्ट्रिंग से यूआरआई बनाता है. |
androidx.core.os
निर्भर है
Groovy
dependencies { implementation "androidx.core:core-ktx:1.19.1" }
Kotlin
dependencies { implementation("androidx.core:core-ktx:1.19.1") }
एक्सटेंशन फ़ंक्शन
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 का वर्शन, जो पैरामीटर को फिर से क्रम में लगाता है. इससे कार्रवाई को ब्रैकेट के बाहर रखा जा सकता है. |
टॉप-लेवल फ़ंक्शन
| Bundle |
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.19.1" }
Kotlin
dependencies { implementation("androidx.core:core-ktx:1.19.1") }
एक्सटेंशन फ़ंक्शन
android.text.Spannable के लिए
| यूनिट |
Spannable.clearSpans()
इस टेक्स्ट से सभी स्पैन हटाएं. |
| operator Unit |
Spannable.set(start: Int, end: Int, span: Any)
|
| operator Unit |
Spannable.set(range: IntRange, span: Any)
|
android.text.SpannableStringBuilder के लिए
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.19.1" }
Kotlin
dependencies { implementation("androidx.core:core-ktx:1.19.1") }
एक्सटेंशन फ़ंक्शन
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.19.1" }
Kotlin
dependencies { implementation("androidx.core:core-ktx:1.19.1") }
एक्सटेंशन फ़ंक्शन
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)
इस फ़ाइल के कॉन्टेंट को 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 से जुड़ी वैल्यू दिखाता है. अगर वैल्यू मौजूद नहीं है, तो defaultValue दिखाता है. |
| T |
LongSparseArray<T>.getOrElse(key: Long, defaultValue: () -> T)
key से जुड़ी वैल्यू दिखाता है. अगर वैल्यू मौजूद नहीं है, तो defaultValue से वैल्यू दिखाता है. |
| बूलियन |
LongSparseArray<T>.isEmpty()
कलेक्शन में कोई एलिमेंट न होने पर, 'सही है' दिखाता है. |
| बूलियन |
LongSparseArray<T>.isNotEmpty()
कलेक्शन में एलिमेंट होने पर, True वैल्यू दिखाएं. |
| LongIterator |
LongSparseArray<T>.keyIterator()
कलेक्शन की कुंजियों पर एक इटरेटर दिखाता है. |
| operator LongSparseArray<T> |
LongSparseArray<T>.plus(other: LongSparseArray<T>)
अन्य से एंट्री जोड़कर या बदलकर, नया कलेक्शन बनाता है. |
| यूनिट |
LongSparseArray<T>.putAll(other: LongSparseArray<T>)
अन्य से एंट्री जोड़कर या बदलकर, इस कलेक्शन को अपडेट करें. |
| बूलियन |
LongSparseArray<T>.remove(key: Long, value: T)
कुंजी की एंट्री को सिर्फ़ तब हटाता है, जब उसे वैल्यू से मैप किया गया हो. |
| operator Unit |
LongSparseArray<T>.set(key: Long, value: T)
कलेक्शन में वैल्यू सेव करने के लिए, इंडेक्स ऑपरेटर का इस्तेमाल करने की अनुमति देता है. |
| Iterator<T> |
LongSparseArray<T>.valueIterator()
कलेक्शन की वैल्यू पर एक इटरेटर दिखाता है. |
android.util.Pair के लिए
| ऑपरेटर F |
Pair<F, S>.component1()
यह फ़ंक्शन, पेयर का पहला कॉम्पोनेंट दिखाता है. |
| operator S |
Pair<F, S>.component2()
यह पेयर का दूसरा कॉम्पोनेंट दिखाता है. |
| जोड़ा<F, S> |
Pair<F, S>.toKotlinPair()
इस Pair को kotlin.Pair के तौर पर दिखाता है. |
android.util.Range के लिए
| infix Range<T> |
Range<T>.and(other: Range<T>)
इस रेंज और अन्य का इंटरसेक्शन दिखाता है. |
| 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()
इस साइज़ का पहला कॉम्पोनेंट, "चौड़ाई" दिखाता है. |
| operator Int |
Size.component2()
यह इस साइज़ का दूसरा कॉम्पोनेंट, "ऊंचाई" दिखाता है. |
android.util.SizeF के लिए
| operator Float |
SizeF.component1()
"width" दिखाता है, जो इस SizeF का पहला कॉम्पोनेंट है. |
| operator Float |
SizeF.component2()
यह "height" दिखाता है, जो इस SizeF का दूसरा कॉम्पोनेंट है. |
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 से जुड़ी वैल्यू दिखाता है. अगर वैल्यू मौजूद नहीं है, तो defaultValue दिखाता है. |
| T |
SparseArray<T>.getOrElse(key: Int, defaultValue: () -> T)
key से जुड़ी वैल्यू दिखाता है. अगर वैल्यू मौजूद नहीं है, तो defaultValue से वैल्यू दिखाता है. |
| बूलियन |
SparseArray<T>.isEmpty()
कलेक्शन में कोई एलिमेंट न होने पर, 'सही है' दिखाता है. |
| बूलियन |
SparseArray<T>.isNotEmpty()
कलेक्शन में एलिमेंट होने पर, True वैल्यू दिखाएं. |
| IntIterator |
SparseArray<T>.keyIterator()
कलेक्शन की कुंजियों पर एक इटरेटर दिखाता है. |
| operator SparseArray<T> |
SparseArray<T>.plus(other: SparseArray<T>)
अन्य से एंट्री जोड़कर या बदलकर, नया कलेक्शन बनाता है. |
| यूनिट |
SparseArray<T>.putAll(other: SparseArray<T>)
अन्य से एंट्री जोड़कर या बदलकर, इस कलेक्शन को अपडेट करें. |
| बूलियन |
SparseArray<T>.remove(key: Int, value: T)
कुंजी की एंट्री को सिर्फ़ तब हटाता है, जब उसे वैल्यू से मैप किया गया हो. |
| 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 से जुड़ी वैल्यू दिखाता है. अगर वैल्यू मौजूद नहीं है, तो defaultValue दिखाता है. |
| बूलियन |
SparseBooleanArray.getOrElse(key: Int, defaultValue: () -> Boolean)
key से जुड़ी वैल्यू दिखाता है. अगर वैल्यू मौजूद नहीं है, तो defaultValue से वैल्यू दिखाता है. |
| बूलियन |
SparseBooleanArray.isEmpty()
कलेक्शन में कोई एलिमेंट न होने पर, 'सही है' दिखाता है. |
| बूलियन |
SparseBooleanArray.isNotEmpty()
कलेक्शन में एलिमेंट होने पर, True वैल्यू दिखाएं. |
| IntIterator |
SparseBooleanArray.keyIterator()
कलेक्शन की कुंजियों पर एक इटरेटर दिखाता है. |
| operator SparseBooleanArray |
SparseBooleanArray.plus(other: SparseBooleanArray)
अन्य से एंट्री जोड़कर या बदलकर, नया कलेक्शन बनाता है. |
| यूनिट |
SparseBooleanArray.putAll(other: SparseBooleanArray)
अन्य से एंट्री जोड़कर या बदलकर, इस कलेक्शन को अपडेट करें. |
| बूलियन |
SparseBooleanArray.remove(key: Int, value: Boolean)
कुंजी की एंट्री को सिर्फ़ तब हटाता है, जब उसे वैल्यू से मैप किया गया हो. |
| 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 से जुड़ी वैल्यू दिखाता है. अगर वैल्यू मौजूद नहीं है, तो defaultValue दिखाता है. |
| Int |
SparseIntArray.getOrElse(key: Int, defaultValue: () -> Int)
key से जुड़ी वैल्यू दिखाता है. अगर वैल्यू मौजूद नहीं है, तो defaultValue से वैल्यू दिखाता है. |
| बूलियन |
SparseIntArray.isEmpty()
कलेक्शन में कोई एलिमेंट न होने पर, 'सही है' दिखाता है. |
| बूलियन |
SparseIntArray.isNotEmpty()
कलेक्शन में एलिमेंट होने पर, True वैल्यू दिखाएं. |
| IntIterator |
SparseIntArray.keyIterator()
कलेक्शन की कुंजियों पर एक इटरेटर दिखाता है. |
| operator SparseIntArray |
SparseIntArray.plus(other: SparseIntArray)
अन्य से एंट्री जोड़कर या बदलकर, नया कलेक्शन बनाता है. |
| यूनिट |
SparseIntArray.putAll(other: SparseIntArray)
अन्य से एंट्री जोड़कर या बदलकर, इस कलेक्शन को अपडेट करें. |
| बूलियन |
SparseIntArray.remove(key: Int, value: Int)
कुंजी की एंट्री को सिर्फ़ तब हटाता है, जब उसे वैल्यू से मैप किया गया हो. |
| 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)
हर कुंजी/वैल्यू एंट्री के लिए, दी गई कार्रवाई करता है. |
| लंबा |
SparseLongArray.getOrDefault(key: Int, defaultValue: Long)
key से जुड़ी वैल्यू दिखाता है. अगर वैल्यू मौजूद नहीं है, तो defaultValue दिखाता है. |
| लंबा |
SparseLongArray.getOrElse(key: Int, defaultValue: () -> Long)
key से जुड़ी वैल्यू दिखाता है. अगर वैल्यू मौजूद नहीं है, तो defaultValue से वैल्यू दिखाता है. |
| बूलियन |
SparseLongArray.isEmpty()
कलेक्शन में कोई एलिमेंट न होने पर, 'सही है' दिखाता है. |
| बूलियन |
SparseLongArray.isNotEmpty()
कलेक्शन में एलिमेंट होने पर, True वैल्यू दिखाएं. |
| IntIterator |
SparseLongArray.keyIterator()
कलेक्शन की कुंजियों पर एक इटरेटर दिखाता है. |
| operator SparseLongArray |
SparseLongArray.plus(other: SparseLongArray)
अन्य से एंट्री जोड़कर या बदलकर, नया कलेक्शन बनाता है. |
| यूनिट |
SparseLongArray.putAll(other: SparseLongArray)
अन्य से एंट्री जोड़कर या बदलकर, इस कलेक्शन को अपडेट करें. |
| बूलियन |
SparseLongArray.remove(key: Int, value: Long)
कुंजी के लिए एंट्री को सिर्फ़ तब हटाता है, जब इसे वैल्यू पर सेट किया गया हो. |
| operator Unit |
SparseLongArray.set(key: Int, value: Long)
कलेक्शन में वैल्यू सेव करने के लिए, इंडेक्स ऑपरेटर का इस्तेमाल करने की अनुमति देता है. |
| LongIterator |
SparseLongArray.valueIterator()
कलेक्शन की वैल्यू पर एक इटरेटर दिखाता है. |
kotlin.Double के लिए
| हाफ़ रिज़ॉल्यूशन |
Double.toHalf()
|
kotlin.Float के लिए
| हाफ़ रिज़ॉल्यूशन |
Float.toHalf()
|
kotlin.Pair के लिए
| जोड़ा<F, S> |
Pair<F, S>.toAndroidPair()
यह kotlin.Pair को Android Pair के तौर पर दिखाता है. |
kotlin.Short के लिए
| हाफ़ रिज़ॉल्यूशन |
Short.toHalf()
|
kotlin.String के लिए
| हाफ़ रिज़ॉल्यूशन |
String.toHalf()
|
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<K, V> |
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)
इस Comparable वैल्यू से उस वैल्यू तक की रेंज बनाता है. |
androidx.core.view
निर्भर है
Groovy
dependencies { implementation "androidx.core:core-ktx:1.19.1" }
Kotlin
dependencies { implementation("androidx.core:core-ktx:1.19.1") }
एक्सटेंशन फ़ंक्शन
android.view.Menu के लिए
| operator Boolean |
Menu.contains(item: MenuItem)
अगर इस मेन्यू में item मिलता है, तो |
| यूनिट |
Menu.forEach(action: (item: MenuItem) -> Unit)
यह इस मेन्यू में मौजूद हर आइटम पर, दी गई कार्रवाई करता है. |
| यूनिट |
Menu.forEachIndexed(action: (index: Int, item: MenuItem) -> Unit)
इस मेन्यू में मौजूद हर आइटम पर, दी गई कार्रवाई करता है. साथ ही, उसका क्रम से इंडेक्स उपलब्ध कराता है. |
| operator MenuItem |
Menu.get(index: Int)
index पर मौजूद मेन्यू दिखाता है. |
| बूलियन |
Menu.isEmpty()
अगर इस मेन्यू में कोई आइटम नहीं है, तो यह फ़ंक्शन true वैल्यू दिखाता है. |
| बूलियन |
Menu.isNotEmpty()
अगर इस मेन्यू में एक या उससे ज़्यादा आइटम हैं, तो यह फ़ंक्शन 'सही है' वैल्यू दिखाता है. |
| operator MutableIterator<MenuItem> |
Menu.iterator()
इस मेन्यू में मौजूद आइटम के लिए, MutableIterator दिखाता है. |
| operator Unit |
Menu.minusAssign(item: MenuItem)
इस मेन्यू से item को हटाता है. |
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)
|
| 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)
यह व्यू के layoutParams के साथ ब्लॉक को लागू करता है और अपडेट किए गए वर्शन के साथ layoutParams को फिर से असाइन करता है. |
| यूनिट |
View.updateLayoutParams(block: T.() -> Unit)
यह व्यू के layoutParams के टाइप किए गए वर्शन के साथ ब्लॉक को लागू करता है. साथ ही, अपडेट किए गए वर्शन के साथ 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 मिलता है, तो |
| यूनिट |
ViewGroup.forEach(action: (view: View) -> Unit)
इस व्यू ग्रुप के हर व्यू पर, दी गई कार्रवाई करता है. |
| यूनिट |
ViewGroup.forEachIndexed(action: (index: Int, view: View) -> Unit)
यह इस व्यू ग्रुप के हर व्यू पर, दी गई कार्रवाई करता है. साथ ही, उसका क्रम से इंडेक्स उपलब्ध कराता है. |
| ऑपरेटर देखें |
ViewGroup.get(index: Int)
इंडेक्स पर व्यू दिखाता है. |
| बूलियन |
ViewGroup.isEmpty()
अगर इस व्यू ग्रुप में कोई व्यू नहीं है, तो यह 'सही' वैल्यू दिखाता है. |
| बूलियन |
ViewGroup.isNotEmpty()
अगर इस व्यू ग्रुप में एक या उससे ज़्यादा व्यू शामिल हैं, तो यह 'सही' वैल्यू दिखाता है. |
| operator MutableIterator<View> |
ViewGroup.iterator()
इस व्यू ग्रुप में मौजूद व्यू पर, MutableIterator दिखाता है. |
| operator Unit |
ViewGroup.minusAssign(view: View)
इस व्यू ग्रुप से व्यू को हटाता है. |
| operator Unit |
ViewGroup.plusAssign(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()
इस मेन्यू में मौजूद आइटम का क्रम दिखाता है. |
| Int |
Menu.size()
यह फ़ंक्शन, इस मेन्यू में मौजूद आइटम की संख्या दिखाता है. |
android.view.View के लिए
| बूलियन |
View.isGone()
जब इस व्यू की विज़िबिलिटी View.GONE होती है, तब यह true दिखाता है. ऐसा न होने पर, यह false दिखाता है. |
| बूलियन |
View.isInvisible()
जब इस व्यू की विज़िबिलिटी View.INVISIBLE होती है, तब यह 'सही' दिखाता है. ऐसा न होने पर, यह 'गलत' दिखाता है. |
| बूलियन |
View.isVisible()
अगर इस व्यू की विज़िबिलिटी View.VISIBLE है, तो यह 'सही' दिखाता है. ऐसा न होने पर, 'गलत' दिखाता है. |
| 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 के लिए
| क्रम<व्यू> |
ViewGroup.children()
यह इस व्यू ग्रुप में चाइल्ड व्यू के लिए, Sequence दिखाता है. |
| Int |
ViewGroup.size()
यह फ़ंक्शन, इस व्यू ग्रुप में मौजूद व्यू की संख्या दिखाता है. |
androidx.core.widget
निर्भर है
Groovy
dependencies { implementation "androidx.core:core-ktx:1.19.1" }
Kotlin
dependencies { implementation("androidx.core:core-ktx:1.19.1") }
एक्सटेंशन फ़ंक्शन
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)
SpringAnimation पर SpringForce.mDampingRatio, SpringForce.mFinalPosition, और स्टिफ़नेस जैसी स्प्रिंग फ़ोर्स प्रॉपर्टी को अपडेट या लागू करता है. |
टॉप-लेवल फ़ंक्शन
| 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.9.1" }
Kotlin
dependencies { implementation("androidx.fragment:fragment-ktx:1.9.1") }
एक्सटेंशन फ़ंक्शन
android.view.View के लिए
| F |
View.findFragment()
|
फ़्रैगमेंट के लिए
| 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 बनाने के लिए हेल्पर मेथड, जो factoryProducer के तौर पर पास किए गए |
| Lazy<VM> |
Fragment.viewModels(noinline ownerProducer: () -> ViewModelStoreOwner = { this }, noinline factoryProducer: () -> ViewModelProvider.Factory = null)
यह 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)
फ़्रैगमेंट को किसी कंटेनर व्यू में जोड़े बिना, उससे जुड़े 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.9.1" }
Kotlin
dependencies { implementation("androidx.fragment:fragment-testing:1.9.1") }
टॉप-लेवल फ़ंक्शन
| FragmentScenario<F!> |
launchFragment(fragmentArgs: Bundle? = null, @StyleRes themeResId: Int = R.style.FragmentScenarioEmptyFragmentActivityTheme, factory: FragmentFactory? = null)
दिए गए FragmentFactory का इस्तेमाल करके, खाली FragmentActivity से होस्ट किए गए आर्ग्युमेंट के साथ फ़्रैगमेंट लॉन्च करता है. साथ ही, इसके फिर से शुरू होने की स्थिति में पहुंचने का इंतज़ार करता है. |
| 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)
यह ऐक्टिविटी के रूट व्यू कंटेनर |
| FragmentScenario<F!> |
launchFragmentInContainer(fragmentArgs: Bundle? = null, @StyleRes themeResId: Int = R.style.FragmentScenarioEmptyFragmentActivityTheme, crossinline instantiate: () -> F)
यह Activity के रूट व्यू कंटेनर |
androidx.lifecycle
निर्भर है
Groovy
dependencies { implementation "androidx.lifecycle:lifecycle-livedata-core-ktx:2.11.0" implementation "androidx.lifecycle:lifecycle-livedata-ktx:2.11.0" implementation "androidx.lifecycle:lifecycle-reactivestreams-ktx:2.11.0" implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.11.0" implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:2.11.0" }
Kotlin
dependencies { implementation("androidx.lifecycle:lifecycle-livedata-core-ktx:2.11.0") implementation("androidx.lifecycle:lifecycle-livedata-ktx:2.11.0") implementation("androidx.lifecycle:lifecycle-reactivestreams-ktx:2.11.0") implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.11.0") implementation("androidx.lifecycle:lifecycle-viewmodel-ktx:2.11.0") }
एक्सटेंशन फ़ंक्शन
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()
यह एक ऐसा फ़्लो बनाता है जिसमें ओरिजनल LiveData से भेजी गई वैल्यू शामिल होती हैं: शुरुआत में, फ़्लो कलेक्टर को LiveData में मौजूद सबसे नई वैल्यू मिलती है. इसके बाद, वह LiveData के अपडेट पर नज़र रखता है. |
| LiveData<X> |
LiveData<X>.distinctUntilChanged()
एक नया LiveData ऑब्जेक्ट बनाता है. यह तब तक कोई वैल्यू नहीं दिखाता, जब तक सोर्स |
| LiveData<Y> |
LiveData<X>.map(crossinline transform: (X) -> Y)
|
| Observer<T> |
LiveData<T>.observe(owner: LifecycleOwner, crossinline onChanged: (T) -> Unit)
दिए गए owner की लाइफ़स्पैन में, दिए गए onChanged लैम्डा को ऑब्ज़र्वर के तौर पर जोड़ता है और ऑब्ज़र्वर का रेफ़रंस दिखाता है. |
| LiveData<Y> |
LiveData<X>.switchMap(crossinline transform: (X) -> LiveData<Y>)
यह |
| Publisher<T> |
LiveData<T>.toPublisher(lifecycle: LifecycleOwner)
दी गई LiveData स्ट्रीम को ReactiveStreams Publisher के हिसाब से अडैप्ट करता है. |
ViewModelProvider के लिए
| VM |
ViewModelProvider.get()
यह मौजूदा ViewModel दिखाता है या इस |
LifecycleOwner के लिए
| suspend T |
LifecycleOwner.whenCreated(block: suspend CoroutineScope.() -> T)
जब LifecycleOwner की लाइफ़साइकल कम से कम Lifecycle.State.CREATED स्थिति में होती है, तब दिए गए ब्लॉक को चलाता है. |
| suspend T |
LifecycleOwner.whenResumed(block: suspend CoroutineScope.() -> T)
यह दिए गए ब्लॉक को तब चलाता है, जब LifecycleOwner की लाइफ़साइकल कम से कम Lifecycle.State.RESUMED स्थिति में हो. |
| suspend T |
LifecycleOwner.whenStarted(block: suspend CoroutineScope.() -> T)
जब LifecycleOwner की लाइफ़साइकल कम से कम Lifecycle.State.STARTED स्थिति में होती है, तब दिए गए ब्लॉक को चलाता है. |
लाइफ़साइकल के लिए
| suspend T |
Lifecycle.whenCreated(block: suspend CoroutineScope.() -> T)
यह दिए गए ब्लॉक को तब चलाता है, जब लाइफ़साइकल कम से कम Lifecycle.State.CREATED स्थिति में हो. |
| suspend T |
Lifecycle.whenResumed(block: suspend CoroutineScope.() -> T)
यह दिए गए ब्लॉक को तब चलाता है, जब लाइफ़साइकल कम से कम Lifecycle.State.RESUMED स्थिति में हो. |
| suspend T |
Lifecycle.whenStarted(block: suspend CoroutineScope.() -> T)
यह दिए गए ब्लॉक को तब चलाता है, जब लाइफ़साइकल कम से कम Lifecycle.State.STARTED स्थिति में हो. |
| suspend T |
Lifecycle.whenStateAtLeast(minState: Lifecycle.State, block: suspend CoroutineScope.() -> T)
यह दिए गए ब्लॉक को CoroutineDispatcher पर चलाता है. यह ब्लॉक को मुख्य थ्रेड पर एक्ज़ीक्यूट करता है और एक्ज़ीक्यूशन को तब तक निलंबित रखता है, जब तक लाइफ़साइकल की स्थिति कम से कम minState न हो. |
एक्सटेंशन प्रॉपर्टी
लाइफ़साइकल के लिए
| LifecycleCoroutineScope |
Lifecycle.coroutineScope()
इस लाइफ़साइकल से जुड़ा CoroutineScope. |
LifecycleOwner के लिए
| LifecycleCoroutineScope |
LifecycleOwner.lifecycleScope()
इस LifecycleOwner के Lifecycle से जुड़ा CoroutineScope. |
ViewModel के लिए
| CoroutineScope |
ViewModel.viewModelScope()
CoroutineScope, इस ViewModel से जुड़ा होता है. |
टॉप-लेवल फ़ंक्शन
| 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.7.5"
implementation "androidx.navigation:navigation-fragment-ktx:2.7.5"
implementation "androidx.navigation:navigation-ui-ktx:2.7.5"
}
Kotlin
dependencies {
implementation("androidx.navigation:navigation-runtime-ktx:2.7.5")
implementation("androidx.navigation:navigation-fragment-ktx:2.7.5")
implementation("androidx.navigation:navigation-ui-ktx:2.7.5")
}
एक्सटेंशन फ़ंक्शन
android.app.Activity के लिए
| NavController |
Activity.findNavController(@IdRes : Int)
किसी व्यू के आईडी और उसमें मौजूद Activity के आधार पर, NavController ढूंढें. |
| NavArgsLazy<Args> |
Activity.navArgs()
यह Args इंस्टेंस के तौर पर, गतिविधि के अतिरिक्त डेटा को ऐक्सेस करने के लिए, Lazy डेलिगेट दिखाता है. |
android.view.View के लिए
| NavController |
View.findNavController()
View से जुड़ा NavController ढूंढें. |
NavGraphBuilder के लिए
| यूनिट |
NavGraphBuilder.activity(@IdRes : Int, : ActivityNavigatorDestinationBuilder.() -> Unit)
एक नया ActivityNavigator.Destination बनाएं |
| यूनिट |
NavGraphBuilder.navigation(@IdRes : Int, @IdRes : Int, : NavGraphBuilder.() -> Unit)
नेस्ट किया गया NavGraph बनाना |
NavGraph के लिए
| operator Boolean |
NavGraph.contains(@IdRes : Int)
अगर इस नेविगेशन ग्राफ़ में |
| operator NavDestination |
NavGraph.get(@IdRes : Int)
|
| operator Unit |
NavGraph.minusAssign(: NavDestination)
इससे |
| operator Unit |
NavGraph.plusAssign(: NavDestination)
इस NavGraph में कोई डेस्टिनेशन जोड़ता है. |
| operator Unit |
NavGraph.plusAssign(: NavGraph)
किसी दूसरे कलेक्शन से सभी डेस्टिनेशन इस कलेक्शन में जोड़ें. |
NavController के लिए
| NavGraph |
NavController.createGraph(@IdRes : Int = 0, @IdRes : Int, : NavGraphBuilder.() -> Unit)
नया NavGraph बनाएं |
NavHost के लिए
| NavGraph |
NavHost.createGraph(@IdRes : Int = 0, @IdRes : Int, : NavGraphBuilder.() -> Unit)
नया NavGraph बनाएं |
NavigatorProvider के लिए
| operator T |
NavigatorProvider.get(: String)
रजिस्टर किए गए नेविगेटर को नाम से खोजता है. |
| operator T |
NavigatorProvider.get(: KClass<T>)
Navigator.Name annotation से मिले नाम का इस्तेमाल करके, रजिस्टर किए गए नेविगेटर को वापस लाता है. |
| NavGraph |
NavigatorProvider.navigation(@IdRes : Int = 0, @IdRes : Int, : NavGraphBuilder.() -> Unit)
नया NavGraph बनाएं |
| operator Unit |
NavigatorProvider.plusAssign(: Navigator<out NavDestination>)
Navigator.Name एनोटेशन से मिले नाम का इस्तेमाल करके, नेविगेटर को रजिस्टर करें. |
| operator Navigator<out NavDestination!>? |
NavigatorProvider.set(: String, : Navigator<out NavDestination>)
नाम के हिसाब से नेविगेटर रजिस्टर करें. |
फ़्रैगमेंट के लिए
| Lazy<VM> |
Fragment.navGraphViewModels(@IdRes : Int, noinline : () -> ViewModelProvider.Factory = null)
यह प्रॉपर्टी डेलिगेट को दिखाता है, ताकि {@link NavController} की पिछली गतिविधियों पर मौजूद नेविगेशन ग्राफ़ के दायरे में आने वाले ViewModel को ऐक्सेस किया जा सके: |
टॉप-लेवल फ़ंक्शन
| ActivityNavigator.Extras |
ActivityNavigatorExtras(: ActivityOptionsCompat? = null, : Int = 0)
किसी खास ActivityOptionsCompat इंस्टेंस और/या किसी |
| NavOptions |
navOptions(: NavOptionsBuilder.() -> Unit)
नया NavOptions बनाएं |
androidx.navigation.fragment
निर्भर है
Groovy
dependencies {
implementation "androidx.navigation:navigation-fragment-ktx:2.7.5"
}
Kotlin
dependencies {
implementation("androidx.navigation:navigation-fragment-ktx:2.7.5")
}
एक्सटेंशन फ़ंक्शन
NavGraphBuilder के लिए
| यूनिट |
NavGraphBuilder.dialog(@IdRes : Int)
DialogFragmentNavigator.Destination को नए सिरे से बनाएं |
| यूनिट |
NavGraphBuilder.dialog(@IdRes : Int, : DialogFragmentNavigatorDestinationBuilder.() -> Unit)
DialogFragmentNavigator.Destination को नए सिरे से बनाएं |
| यूनिट |
NavGraphBuilder.fragment(@IdRes : Int)
नया FragmentNavigator.Destination बनाएं |
| यूनिट |
NavGraphBuilder.fragment(@IdRes : Int, : FragmentNavigatorDestinationBuilder.() -> Unit)
नया FragmentNavigator.Destination बनाएं |
फ़्रैगमेंट के लिए
| NavController |
Fragment.findNavController()
फ़्रैगमेंट के लिए NavController ढूंढना |
| NavArgsLazy<Args> |
Fragment.navArgs()
यह फ़ंक्शन, फ़्रैगमेंट के आर्ग्युमेंट को Args इंस्टेंस के तौर पर ऐक्सेस करने के लिए, Lazy डेलिगेट दिखाता है. |
टॉप-लेवल फ़ंक्शन
| FragmentNavigator.Extras |
FragmentNavigatorExtras(vararg : Pair<View, String>)
शेयर किए गए एलिमेंट की मदद से, नया FragmentNavigator.Extras इंस्टेंस बनाएं |
androidx.navigation.ui
निर्भर है
Groovy
dependencies { implementation "androidx.navigation:navigation-ui-ktx:2.10.2" }
Kotlin
dependencies { implementation("androidx.navigation:navigation-ui-ktx:2.10.2") }
एक्सटेंशन फ़ंक्शन
android.view.MenuItem के लिए
| बूलियन |
MenuItem.onNavDestinationSelected(: NavController)
इस MenuItem से जुड़े NavDestination पर जाने की कोशिश करें. |
androidx.appcompat.app.AppCompatActivity के लिए
| यूनिट |
AppCompatActivity.setupActionBarWithNavController(: NavController, : DrawerLayout?)
NavController के साथ इस्तेमाल करने के लिए, AppCompatActivity.getSupportActionBar से मिले ActionBar को सेट अप करता है. |
| यूनिट |
AppCompatActivity.setupActionBarWithNavController(: NavController, : AppBarConfiguration = AppBarConfiguration(navController.graph))
NavController के साथ इस्तेमाल करने के लिए, AppCompatActivity.getSupportActionBar से मिले ActionBar को सेट अप करता है. |
androidx.appcompat.widget.Toolbar के लिए
| यूनिट |
Toolbar.setupWithNavController(: NavController, : DrawerLayout?)
NavController के साथ इस्तेमाल करने के लिए, टूलबार सेट अप करता है. |
| यूनिट |
Toolbar.setupWithNavController(: NavController, : AppBarConfiguration = AppBarConfiguration(navController.graph))
NavController के साथ इस्तेमाल करने के लिए, टूलबार सेट अप करता है. |
com.google.android.material.appbar.CollapsingToolbarLayout के लिए
| यूनिट |
CollapsingToolbarLayout.setupWithNavController(: Toolbar, : NavController, : DrawerLayout?)
NavController के साथ इस्तेमाल करने के लिए, CollapsingToolbarLayout और Toolbar सेट अप करता है. |
| यूनिट |
CollapsingToolbarLayout.setupWithNavController(: Toolbar, : NavController, : AppBarConfiguration = AppBarConfiguration(navController.graph))
NavController के साथ इस्तेमाल करने के लिए, CollapsingToolbarLayout और Toolbar सेट अप करता है. |
com.google.android.material.bottomnavigation.BottomNavigationView के लिए
| यूनिट |
BottomNavigationView.setupWithNavController(: NavController)
NavController के साथ इस्तेमाल करने के लिए, BottomNavigationView सेट अप करता है. |
com.google.android.material.navigation.NavigationView के लिए
| यूनिट |
NavigationView.setupWithNavController(: NavController)
NavController के साथ इस्तेमाल करने के लिए, NavigationView सेट अप करता है. |
NavController के लिए
| बूलियन |
NavController.navigateUp(: DrawerLayout?)
यह अप बटन को मैनेज करता है. इसके लिए, यह बटन के व्यवहार को दिए गए NavController को सौंपता है. |
| बूलियन |
NavController.navigateUp(: AppBarConfiguration)
यह अप बटन को मैनेज करता है. इसके लिए, यह बटन के व्यवहार को दिए गए NavController को सौंपता है. |
टॉप-लेवल फ़ंक्शन
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)
यह इस |
| 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)
यह इस |
| 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<Value>> |
DataSource.Factory<Key, Value>.toLiveData(pageSize: Int, initialLoadKey: Key? = null, boundaryCallback: PagedList.BoundaryCallback<Value>? = null, fetchExecutor: Executor = ArchTaskExecutor.getIOThreadExecutor())
यह |
| 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)
यह इस |
| Observable<PagedList<Value>> |
DataSource.Factory<Key, Value>.toObservable(pageSize: Int, initialLoadKey: Key? = null, boundaryCallback: PagedList.BoundaryCallback<Value>? = null, fetchScheduler: Scheduler? = null, notifyScheduler: Scheduler? = null)
यह इस |
टॉप-लेवल फ़ंक्शन
| 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.1.0" }
Kotlin
dependencies { implementation("androidx.palette:palette-ktx:1.1.0") }
एक्सटेंशन फ़ंक्शन
Palette के लिए
| operator Palette.Swatch? |
Palette.get(target: Target)
यह फ़ंक्शन, पैलेट से दिए गए टारगेट के लिए चुना गया स्वॉच दिखाता है. अगर कोई स्वॉच नहीं मिलता है, तो |
androidx.preference
निर्भर है
Groovy
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)
अगर इस प्राथमिकता ग्रुप में |
| यूनिट |
PreferenceGroup.forEach(action: (preference: Preference) -> Unit)
इस प्राथमिकता ग्रुप में मौजूद हर प्राथमिकता पर, दी गई कार्रवाई करता है. |
| यूनिट |
PreferenceGroup.forEachIndexed(action: (index: Int, preference: Preference) -> Unit)
इस प्राथमिकता ग्रुप में मौजूद हर प्राथमिकता पर, दी गई कार्रवाई करता है. साथ ही, इसका क्रम से इंडेक्स उपलब्ध कराता है. |
| operator T? |
PreferenceGroup.get(key: CharSequence)
|
| ऑपरेटर पसंद |
PreferenceGroup.get(index: Int)
|
| बूलियन |
PreferenceGroup.isEmpty()
अगर इस प्राथमिकता ग्रुप में कोई प्राथमिकता नहीं है, तो 'सही है' दिखाता है. |
| बूलियन |
PreferenceGroup.isNotEmpty()
अगर इस प्राथमिकता ग्रुप में एक या उससे ज़्यादा प्राथमिकताएं शामिल हैं, तो यह 'सही' वैल्यू दिखाता है. |
| operator MutableIterator<Preference> |
PreferenceGroup.iterator()
यह इस प्राथमिकता ग्रुप में मौजूद प्राथमिकताओं के लिए, MutableIterator दिखाता है. |
| operator Unit |
PreferenceGroup.minusAssign(preference: Preference)
|
| operator Unit |
PreferenceGroup.plusAssign(preference: Preference)
|
एक्सटेंशन प्रॉपर्टी
PreferenceGroup के लिए
| Sequence<Preference> |
PreferenceGroup.children()
यह इस प्राथमिकता ग्रुप में मौजूद प्राथमिकताओं का क्रम दिखाता है. |
| Int |
PreferenceGroup.size()
इस प्राथमिकता ग्रुप में मौजूद प्राथमिकताओं की संख्या दिखाता है. |
androidx.room
निर्भर है
ग्रूवी
dependencies { implementation "androidx.room:room-ktx:2.8.5" }
Kotlin
dependencies { implementation("androidx.room:room-ktx:2.8.5") }
एक्सटेंशन फ़ंक्शन
RoomDatabase के लिए
| suspend R |
RoomDatabase.withTransaction(block: suspend () -> R)
डेटाबेस ट्रांज़ैक्शन में, निलंबित किए गए ब्लॉक को कॉल करता है. |
androidx.sqlite.db
निर्भर है
Groovy
dependencies { implementation "androidx.sqlite:sqlite-ktx:2.7.1" }
Kotlin
dependencies { implementation("androidx.sqlite:sqlite-ktx:2.7.1") }
एक्सटेंशन फ़ंक्शन
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 के पूरा होने का इंतज़ार करता है. |
Operation के लिए
| suspend Operation.State.SUCCESS! |
Operation.await()
किसी थ्रेड को ब्लॉक किए बिना, कार्रवाई का इंतज़ार करता है. |
डेटा के लिए
| बूलियन |
Data.hasKeyWithValueOfType(key: String)
अगर डेटा के इंस्टेंस में, दी गई कुंजी के मुताबिक वैल्यू मौजूद है, तो यह फ़ंक्शन true दिखाता है. साथ ही, यह वैल्यू, अनुमानित टाइप T की होनी चाहिए. |
बिल्डर के लिए
| 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
निर्भर है
Groovy
dependencies { implementation "androidx.work:work-testing:2.12.0" }
Kotlin
dependencies { implementation("androidx.work:work-testing:2.12.0") }
टॉप-लेवल फ़ंक्शन
| 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 के लिए
एक्सटेंशन प्रॉपर्टी
com.google.android.play.core.appupdate.AppUpdateInfo के लिए
| Int |
AppUpdateInfo.installStatus()
यह अपडेट की प्रोग्रेस का स्टेटस दिखाता है. |
| बूलियन |
AppUpdateInfo.isFlexibleUpdateAllowed()
अगर फ़्लेक्सिबल अपडेट की अनुमति है, तो |
| बूलियन |
AppUpdateInfo.isImmediateUpdateAllowed()
अगर तुरंत अपडेट करने की अनुमति है, तो |
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 के लिए
| लंबा |
SplitInstallSessionState.bytesDownloaded()
इस अपडेट से डाउनलोड किए गए बाइट. |
| Int |
SplitInstallSessionState.errorCode()
इस अपडेट की गड़बड़ी का कोड. |
| बूलियन |
SplitInstallSessionState.hasTerminalStatus()
इससे पता चलता है कि यह अपडेट आखिरी है. इसका मतलब है कि इस सेशन के लिए अब कोई और अपडेट नहीं होगा. |
| List<String> |
SplitInstallSessionState.languages()
इस अपडेट में शामिल भाषाएं. |
| List<String> |
SplitInstallSessionState.moduleNames()
इस अपडेट में शामिल मॉड्यूल. |
| Int |
SplitInstallSessionState.sessionId()
इस अपडेट का सेशन आईडी. |
| Int |
SplitInstallSessionState.status()
इस अपडेट का स्टेटस कोड. |
| लंबा |
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 बनाने के लिए, एक आसान फ़ंक्शन. |