फ़ेज़ के हिसाब से मॉडिफ़ायर का ब्रेकडाउन

Jetpack Compose, मॉडिफ़ायर को अलग-अलग फ़ेज़ में लागू करता है. यहां दिए गए ब्रेकडाउन से पता चलता है कि सामान्य मॉडिफ़ायर किस फ़ेज़ से जुड़े हैं और उनके आर्ग्युमेंट या लैम्ब्डा का आकलन कब किया जाता है.

पहला चरण: कंपोज़िशन फ़ेज़

ये मॉडिफ़ायर, @Composable के अंदर आर्ग्युमेंट का आकलन सिंक्रोनस तरीके से करते हैं. बॉडी. यहां रीड की गई कोई भी स्टेट, कंपोज़ेबल रीस्टार्ट स्कोप के साथ डिपेंडेंसी रजिस्टर करती है. साथ ही, बदलाव होने पर पूरी तरह से रीकंपोज़िशन को ट्रिगर करती है.

  • स्टैटिक डाइमेंशन और साइज़ बदलने वाले मॉडिफ़ायर:
    • Modifier.size(dp), Modifier.width(dp), Modifier.height(dp)
    • Modifier.fillMaxSize(), Modifier.fillMaxWidth(), Modifier.fillMaxHeight()
    • Modifier.wrapContentSize(), Modifier.wrapContentWidth(), Modifier.wrapContentHeight()
    • Modifier.requiredSize(), Modifier.defaultMinSize()
    • Modifier.aspectRatio(ratio)
    • Modifier.weight(weight)(RowScope या ColumnScopeमें)
    • Modifier.width(IntrinsicSize.Min / Max)
    • Modifier.height(IntrinsicSize.Min / Max)
  • स्टैटिक स्पेसिंग और इनसेट:
    • Modifier.padding(all = dp), Modifier.padding(start, top, end, bottom)
    • Modifier.windowInsetsPadding(insets), Modifier.statusBarsPadding()
  • वैल्यू को सीधे तौर पर दिखाने वाले विज़ुअल मॉडिफ़ायर:
    • Modifier.alpha(float) (कंपोज़िशन के दौरान स्थिति को रीड करता है)
    • Modifier.rotate(degrees) (कंपोज़िशन के दौरान स्थिति को रीड करता है)
    • Modifier.scale(scaleX, scaleY) (कंपोज़िशन के दौरान स्थिति को पढ़ता है)
    • Modifier.background(color = Color, shape = Shape)
    • Modifier.border(width, color, shape)
    • Modifier.shadow(elevation, shape)
    • Modifier.clip(shape)
    • Modifier.blur(radius)
  • स्टैटिक पोज़िशन मॉडिफ़ायर:
    • Modifier.offset(x = dp, y = dp) (direct value overload)
    • Modifier.absoluteOffset(x = dp, y = dp)
  • डाइनैमिक कंपोज़ेबल मॉडिफ़ायर:
    • Modifier.composed { ... } (कंपोज़िशन के दौरान फ़ैक्ट्री बॉडी को चलाता है; परफ़ॉर्मेंस के लिए इसका सुझाव नहीं दिया जाता—इसके बजाय, कस्टम मॉडिफ़ायर के लिए Modifier.Node का इस्तेमाल करें)

दूसरा चरण: लेआउट फ़ेज़

लेआउट फ़ेज़ को दो अलग-अलग सब-स्टेप में बांटा गया है. इनमें अमान्य करने के अलग-अलग स्कोप होते हैं:

चरण 2A: मेज़रमेंट

इससे साइज़ (width, height) और पाबंदियों का पता चलता है. यहां स्टेट रीड करने से, फिर से मेज़रमेंट और फिर से प्लेसमेंट ट्रिगर होता है:

  • Modifier.layout { measurable, constraints -> ... }: layout(w, h) से पहले का कोड, मेज़रमेंट के दौरान चलता है.

दूसरा चरण: प्लेसमेंट और लेआउट कॉलबैक

इससे (x, y) निर्देशांक की पोज़िशन तय होती है. प्लेसमेंट ब्लॉक के अंदर स्टेट रीड करने से, सिर्फ़ री-प्लेसमेंट ट्रिगर होता है. इसमें मेज़रमेंट और कंपोज़िशन को स्किप कर दिया जाता है:

  • Modifier.offset { IntOffset(x, y) } (lambda overload)
  • Modifier.absoluteOffset { IntOffset(x, y) } (lambda overload)
  • Modifier.layout { ... layout(w, h) { placeable.place(x, y) } }: layout(w, h) { ... } ब्लॉक में मौजूद कोड.

लेआउट ऑब्ज़र्वेशन कॉलबैक, लेआउट पास के दौरान या उसके बाद भी चलते हैं. इन कॉलबैक में कंपोज़िशन में पढ़े गए स्टेटस में लिखने से बचें, क्योंकि ऐसा करने से बैकवर्ड राइट होते हैं:

  • Modifier.onSizeChanged { intSize -> ... }: अगर नोड के डाइमेंशन में बदलाव हुआ है, तो लेआउट मेज़रमेंट पूरा होने के बाद इसे शुरू किया जाता है.
  • Modifier.onPlaced { layoutCoordinates -> ... } और Modifier.onLayoutRectChanged { ... }: प्लेसमेंट के बाद, ग्लोबल विंडो लेआउट पास की सदस्यता लिए बिना, लोकल कोऑर्डिनेट या सीमाओं की जानकारी देने के लिए कॉल किया जाता है.
  • Modifier.onGloballyPositioned { layoutCoordinates -> ... }: किसी नोड के मूव होने पर, विंडो लेआउट पास पूरा होने के बाद इसे शुरू किया जाता है. जब तक ज़रूरी न हो, onGloballyPositioned का इस्तेमाल न करें. व्यूपोर्ट ट्रैकिंग के लिए Modifier.onVisibilityChanged, लोकल बाउंड के लिए Modifier.onPlaced या Modifier.onLayoutRectChanged, और Modifier.Node में ज़रूरत के हिसाब से requireLayoutCoordinates() का इस्तेमाल करें.

तीसरा चरण: ड्रॉइंग फ़ेज़

ये मॉडिफ़ायर, कैनवस ड्रॉइंग के दौरान लागू होते हैं. इन ब्लॉक में रीड की गई स्टेट, कंपोज़िशन और लेआउट, दोनों को स्किप कर देती है. साथ ही, सिर्फ़ ड्रॉ पास को चलाती है:

  • Modifier.graphicsLayer { ... }:
    • लैम्ब्डा में अपडेट की गई प्रॉपर्टी: alpha, translationX, translationY, scaleX, scaleY, rotationX, rotationY, rotationZ, shadowElevation, shape, clip, renderEffect, transformOrigin.
  • Modifier.drawBehind { ... }:
    • यह कंपोज़ेबल कॉन्टेंट के पीछे कैनवस कमांड ड्रॉ करता है.
  • Modifier.drawWithContent { ... }:
    • drawContent() की मदद से, ड्रॉइंग के क्रम को कंट्रोल करता है.
  • Modifier.drawWithCache { ... }:
    • बाहरी ब्लॉक, साइज़ या लेआउट में बदलाव होने पर चलता है, ताकि Path, Paint या Brush ऑब्जेक्ट को कैश मेमोरी में सेव किया जा सके; onDrawBehind या onDrawWithContent हर फ़्रेम ड्रॉ पर चलता है.

रीकंपोज़िशन लूप के बाहर - ऑब्ज़र्वेशन मॉडिफ़ायर

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

सिमैंटिक और सुलभता

सुलभता सेवाओं (TalkBack) और टेस्टिंग के लिए, सिमैंटिक प्रॉपर्टी को प्रोसेस करता है:

  • Modifier.semantics { ... }
  • Modifier.clearAndSetSemantics { ... }

इनपुट, जेस्चर, और इवेंट

यह तीन चरणों वाली फ़्रेम रेंडरिंग पाइपलाइन के बाहर काम करता है. साथ ही, ओएस मोशन इवेंट और उपयोगकर्ता के इंटरैक्शन को कैप्चर करता है:

  • Modifier.pointerInput(key) { detectTapGestures { ... } } / detectDragGestures / awaitPointerEventScope
  • Modifier.clickable(enabled, onClickLabel) { ... }
  • Modifier.combinedClickable { ... }
  • Modifier.toggleable { ... }
  • Modifier.selectable { ... }
  • Modifier.draggable(...) / Modifier.scrollable(...) / Modifier.draggable2D(...)
  • Modifier.onFocusChanged { focusState -> ... }
  • Modifier.onKeyEvent { keyEvent -> ... }
  • Modifier.onVisibilityChanged { isVisible -> ... }: कॉलबैक को तब शुरू किया जाता है, जब कॉन्फ़िगर की गई देरी के बाद, किसी कंपोज़ेबल की विज़िबिलिटी में बदलाव होता है. यह बदलाव, कोरूटीन में होता है.

क्विक रेफ़रंस: वैल्यू बनाम Lambda फ़ेज़

लैम्ब्डा में स्टेट वैल्यू को पढ़ने से, उसे बाद के फ़ेज़ में पढ़ा जाता है. इससे, स्टेट बदलने पर शुरुआती फ़ेज़ को स्किप कर दिया जाता है:

मॉडिफ़ायर / पैटर्न डायरेक्ट वैल्यू (कंपोज़िशन) Lambda वैरिएंट (डिफ़र्ड फ़ेज़) स्थिति में बदलाव होने पर
Offset Modifier.offset(x, y) Modifier.offset { IntOffset(x, y) } लेआउट (प्लेसमेंट) (कंपोज़िशन को स्किप करता है)
ऐल्फ़ा / ओपैसिटी Modifier.alpha(alpha) Modifier.graphicsLayer { this.alpha = alpha } ड्रॉइंग (इसमें कंपोज़िशन और लेआउट शामिल नहीं है)
रोटेशन Modifier.rotate(degrees) Modifier.graphicsLayer { rotationZ = degrees } ड्रॉइंग (इसमें कंपोज़िशन और लेआउट शामिल नहीं है)
स्केल Modifier.scale(scale) Modifier.graphicsLayer { scaleX = s; scaleY = s } ड्रॉइंग (इसमें कंपोज़िशन और लेआउट शामिल नहीं है)
अनुवाद Modifier.padding(...) Modifier.graphicsLayer { translationX = ... } ड्रॉइंग (इसमें कंपोज़िशन और लेआउट शामिल नहीं है)
बैकग्राउंड का रंग Modifier.background(color) Modifier.drawBehind { drawRect(color) } ड्रॉइंग (इसमें कंपोज़िशन और लेआउट शामिल नहीं है)
स्क्रोल / पैरालैक्स Modifier.offset(scroll.dp) Modifier.offset { IntOffset(0, scroll) } लेआउट (प्लेसमेंट) (कंपोज़िशन को स्किप करता है)

Modifier.Node इंटरफ़ेस मैपिंग

हाई-परफ़ॉर्मेंस वाले Modifier.Node एपीआई का इस्तेमाल करने वाले कस्टम मॉडिफ़ायर के लिए, फ़ेज़ सीधे तौर पर नोड की क्षमता वाले इंटरफ़ेस से मैप होते हैं:

फ़ेज़ Modifier.Node इंटरफ़ेस मुख्य तरीके
लेआउट (मेज़र और प्लेस) LayoutModifierNode measure(measurable, constraints)
लेआउट (ग्लोबल कोऑर्डिनेट) GlobalPositionAwareModifierNode (requireLayoutCoordinates() को मांग के हिसाब से उपलब्ध कराना बेहतर है) onGloballyPositioned(coordinates)
लेआउट (प्लेसमेंट) LayoutAwareModifierNode onRemeasured(size), onPlaced(coordinates)
ड्रॉइंग DrawModifierNode draw(ContentDrawScope)
इनपुट / पॉइंटर PointerInputModifierNode onPointerEvent(...), onCancelPointerInput()
सिमैंटिक्स SemanticsModifierNode applySemantics(SemanticsPropertyReceiver)
फ़ोकस FocusEventModifierNode onFocusEvent(focusState)