Compose के लेआउट में इंट्रिंसिक मेज़रमेंट

Compose का एक नियम यह है कि आपको अपने चाइल्ड एलिमेंट को सिर्फ़ एक बार मेज़र करना चाहिए. चाइल्ड एलिमेंट को दो बार मेज़र करने पर, रनटाइम एक्सेप्शन दिखता है. हालांकि, कभी-कभी आपको अपने बच्चों की लंबाई मापने से पहले, उनके बारे में कुछ जानकारी की ज़रूरत होती है.

इंट्रिन्सिक की मदद से, चाइल्ड एलिमेंट को मेज़र करने से पहले ही उनकी क्वेरी की जा सकती है.

किसी कंपोज़ेबल के लिए, IntrinsicSize.Min या IntrinsicSize.Max का अनुरोध किया जा सकता है:

  • Modifier.width(IntrinsicSize.Min) - अपने कॉन्टेंट को सही तरीके से दिखाने के लिए, आपको कम से कम कितनी चौड़ाई की ज़रूरत है?
  • Modifier.width(IntrinsicSize.Max) - अपने कॉन्टेंट को सही तरीके से दिखाने के लिए, आपको ज़्यादा से ज़्यादा कितनी चौड़ाई की ज़रूरत है?
  • Modifier.height(IntrinsicSize.Min) - अपने कॉन्टेंट को सही तरीके से दिखाने के लिए, आपको कम से कम कितनी ऊंचाई की ज़रूरत है?
  • Modifier.height(IntrinsicSize.Max) - अपने कॉन्टेंट को सही तरीके से दिखाने के लिए, आपको ज़्यादा से ज़्यादा कितनी ऊंचाई की ज़रूरत है?

उदाहरण के लिए, अगर किसी कस्टम लेआउट में, अनंत width कंस्ट्रेंट वाले Text की minIntrinsicHeight पूछी जाती है, तो यह एक लाइन में लिखे गए टेक्स्ट के साथ Text की height दिखाता है.

इंट्रिन्सिक का इस्तेमाल

ऐसा कंपोज़ेबल बनाया जा सकता है जो स्क्रीन पर दो टेक्स्ट दिखाता हो और उन्हें एक डिवाइडर से अलग करता हो:

एक-दूसरे के बगल में मौजूद दो टेक्स्ट एलिमेंट, जिनके बीच में एक वर्टिकल डिवाइडर है

इसके लिए, दो Text कंपोज़ेबल वाले Row का इस्तेमाल करें, जो उपलब्ध जगह को भरते हैं. साथ ही, बीच में Divider का इस्तेमाल करें. Divider की लंबाई, सबसे लंबे Text के बराबर होनी चाहिए. साथ ही, यह पतला (width = 1.dp) होना चाहिए.

@Composable
fun TwoTexts(modifier: Modifier = Modifier, text1: String, text2: String) {
    Row(modifier = modifier) {
        Text(
            modifier = Modifier
                .weight(1f)
                .padding(start = 4.dp)
                .wrapContentWidth(Alignment.Start),
            text = text1
        )
        VerticalDivider(
            color = Color.Black,
            modifier = Modifier.fillMaxHeight().width(1.dp)
        )
        Text(
            modifier = Modifier
                .weight(1f)
                .padding(end = 4.dp)
                .wrapContentWidth(Alignment.End),

            text = text2
        )
    }
}

Divider पूरी स्क्रीन पर बड़ा हो जाता है, जो कि सही नहीं है:

एक-दूसरे के बगल में मौजूद दो टेक्स्ट एलिमेंट, जिनके बीच में एक डिवाइडर है. हालांकि, डिवाइडर टेक्स्ट के नीचे तक फैला हुआ है

ऐसा इसलिए होता है, क्योंकि Row हर चाइल्ड को अलग-अलग मेज़र करता है. साथ ही, Text की ऊंचाई का इस्तेमाल, Divider को सीमित करने के लिए नहीं किया जा सकता.

अगर आपको Divider को दी गई ऊंचाई के हिसाब से उपलब्ध जगह को भरने के लिए इस्तेमाल करना है, तो height(IntrinsicSize.Min) मॉडिफ़ायर का इस्तेमाल करें.

height(IntrinsicSize.Min) अपने चाइल्ड एलिमेंट का साइज़, उनकी कम से कम इंट्रिन्सिक हाइट के बराबर रखता है. यह मॉडिफ़ायर रिकर्सिव है. इसलिए, यह Row और उसके चाइल्ड खातों के minIntrinsicHeight को क्वेरी करता है.

अपने कोड में इस मॉडिफ़ायर को लागू करने से, यह उम्मीद के मुताबिक काम करता है:

@Composable
fun TwoTexts(modifier: Modifier = Modifier, text1: String, text2: String) {
    Row(modifier = modifier.height(IntrinsicSize.Min)) {
        Text(
            modifier = Modifier
                .weight(1f)
                .padding(start = 4.dp)
                .wrapContentWidth(Alignment.Start),
            text = text1
        )
        VerticalDivider(
            color = Color.Black,
            modifier = Modifier.fillMaxHeight().width(1.dp)
        )
        Text(
            modifier = Modifier
                .weight(1f)
                .padding(end = 4.dp)
                .wrapContentWidth(Alignment.End),

            text = text2
        )
    }
}

// @Preview
@Composable
fun TwoTextsPreview() {
    MaterialTheme {
        Surface {
            TwoTexts(text1 = "Hi", text2 = "there")
        }
    }
}

झलक के साथ:

एक-दूसरे के बगल में मौजूद दो टेक्स्ट एलिमेंट, जिनके बीच में एक वर्टिकल डिवाइडर है

Row की ऊंचाई इस तरह तय की जाती है:

  • Row कंपोज़ेबल का minIntrinsicHeight, इसके चाइल्ड एलिमेंट का ज़्यादा से ज़्यादा minIntrinsicHeight होता है.
  • Divider एलिमेंट की minIntrinsicHeight वैल्यू 0 है, क्योंकि अगर कोई शर्त नहीं दी गई है, तो यह जगह नहीं लेता.
  • Text minIntrinsicHeight, किसी खास width के टेक्स्ट का होता है.
  • इसलिए, Row एलिमेंट की height शर्त, Text की ज़्यादा से ज़्यादा minIntrinsicHeight बन जाती है.
  • इसके बाद, Divider अपने height को Row की ओर से तय की गई height की सीमा तक बढ़ा देता है.

कस्टम लेआउट में इंट्रिन्सिक

कस्टम Layout या layout मॉडिफ़ायर बनाते समय, अनुमान के आधार पर इंट्रिन्सिक मेज़रमेंट अपने-आप कैलकुलेट हो जाते हैं. इसलिए, हो सकता है कि सभी लेआउट के लिए कैलकुलेशन सही न हों. ये एपीआई, इन डिफ़ॉल्ट सेटिंग को बदलने के विकल्प देते हैं.

अपने कस्टम Layout के इंट्रिन्सिक मेज़रमेंट तय करने के लिए, MeasurePolicy इंटरफ़ेस बनाते समय, उसके minIntrinsicWidth, minIntrinsicHeight, maxIntrinsicWidth, और maxIntrinsicHeight को बदलें. ओवरराइड की गई सेटिंग, measure की सेटिंग से मेल खानी चाहिए. उदाहरण के लिए, किसी कस्टम कॉलम में, उसके चाइल्ड एलिमेंट को वर्टिकल तौर पर स्टैक किया जाता है और हर चाइल्ड एलिमेंट को कॉलम की पूरी चौड़ाई दी जाती है. ऐसे में, किसी दिए गए width के लिए कम से कम इंट्रिन्सिक ऊंचाई, उस width के लिए उसके चाइल्ड एलिमेंट की कम से कम इंट्रिन्सिक ऊंचाई का योग होती है:

@Composable
fun MyCustomComposable(
    modifier: Modifier = Modifier,
    content: @Composable () -> Unit
) {
    Layout(
        content = content,
        modifier = modifier,
        measurePolicy = object : MeasurePolicy {
            override fun MeasureScope.measure(
                measurables: List<Measurable>,
                constraints: Constraints
            ): MeasureResult {
                val childConstraints = constraints.copy(minHeight = 0)
                val placeables = measurables.map { measurable ->
                    measurable.measure(childConstraints)
                }
                val width = constraints.constrainWidth(
                    placeables.maxOfOrNull { it.width } ?: 0
                )
                val height = constraints.constrainHeight(
                    placeables.sumOf { it.height }
                )
                return layout(width, height) {
                    var yPosition = 0
                    placeables.forEach { placeable ->
                        placeable.placeRelative(x = 0, y = yPosition)
                        yPosition += placeable.height
                    }
                }
            }

            override fun IntrinsicMeasureScope.minIntrinsicHeight(
                measurables: List<IntrinsicMeasurable>,
                width: Int
            ): Int {
                return measurables.sumOf { measurable ->
                    measurable.minIntrinsicHeight(width)
                }
            }

            // Other intrinsics related methods have a default value,
            // you can override only the methods that you need.
        }
    )
}

कस्टम layout मॉडिफ़ायर बनाते समय, LayoutModifier इंटरफ़ेस में इससे जुड़े तरीकों को बदलें. इंट्रिन्सिक कैलकुलेशन, measure से मैच होना चाहिए. उदाहरण के लिए, किसी दिए गए height के लिए, सभी तरफ़ फ़िक्स्ड पैडिंग जोड़ने वाला मॉडिफ़ायर, चाइल्ड के minIntrinsicWidth के बारे में क्वेरी करने से पहले वर्टिकल पैडिंग को घटाता है और नतीजे में हॉरिज़ॉन्टल पैडिंग जोड़ता है:

fun Modifier.myCustomModifier(padding: Dp = 8.dp) =
    this then object : LayoutModifier {
        override fun MeasureScope.measure(
            measurable: Measurable,
            constraints: Constraints
        ): MeasureResult {
            val paddingPx = padding.roundToPx()
            val horizontal = paddingPx * 2
            val vertical = paddingPx * 2
            val placeable = measurable.measure(
                constraints.offset(-horizontal, -vertical)
            )
            val width = constraints.constrainWidth(placeable.width + horizontal)
            val height = constraints.constrainHeight(placeable.height + vertical)
            return layout(width, height) {
                placeable.place(paddingPx, paddingPx)
            }
        }

        override fun IntrinsicMeasureScope.minIntrinsicWidth(
            measurable: IntrinsicMeasurable,
            height: Int
        ): Int {
            val paddingPx = padding.roundToPx()
            val horizontal = paddingPx * 2
            val vertical = paddingPx * 2
            val childHeight = if (height == Constraints.Infinity) {
                Constraints.Infinity
            } else {
                (height - vertical).coerceAtLeast(0)
            }
            return measurable.minIntrinsicWidth(childHeight) + horizontal
        }

        // Other intrinsics related methods have a default value,
        // you can override only the methods that you need.
    }