टाइल में डाइनैमिक अपडेट दिखाएं

Tiles 1.2 से, डाइनैमिक एक्सप्रेशन का इस्तेमाल करके, प्लैटफ़ॉर्म के डेटा अपडेट को स्ट्रीम किया जा सकता है. इसके बाद, इन अपडेट को अपनी टाइलों में मौजूद ऐनिमेशन के साथ जोड़ा जा सकता है. आपके ऐप्लिकेशन को हर सेकंड इस वैल्यू के अपडेट मिलते हैं.

डाइनैमिक एक्सप्रेशन का इस्तेमाल करने पर, आपको टाइल का कॉन्टेंट बदलने पर पूरी टाइल को रीफ़्रेश करने की ज़रूरत नहीं होती. अपनी टाइलों में ज़्यादा दिलचस्प अनुभव देने के लिए, डाइनैमिक ऑब्जेक्ट को ऐनिमेट करें.

डेटा सोर्स के साथ डाइनैमिक एक्सप्रेशन जोड़ना

androidx.wear.protolayout और androidx.wear.protolayout.material नेमस्पेस में कई क्लास होती हैं. इनके फ़ील्ड में डाइनैमिक एक्सप्रेशन स्वीकार किए जाते हैं. इसके कुछ उदाहरण यहां दिए गए हैं:

अगर आपको अपनी टाइल में किसी एलिमेंट के लिए, डाइनैमिक एक्सप्रेशन का इस्तेमाल करना है, तो एलिमेंट के *Prop डाइनैमिक प्रॉपर्टी टाइप का इस्तेमाल करें. साथ ही, डाइनैमिक प्रॉपर्टी टाइप के बिल्डर क्लास के setDynamicValue() तरीके में डेटा सोर्स पास करें.

टाइलों में, इन डाइनैमिक प्रॉपर्टी टाइप का इस्तेमाल किया जा सकता है:

  • लीनियर डाइमेंशन के लिए, डिसप्ले-इंडिपेंडेंट पिक्सल में मेज़र किए गए DimensionBuilders.DpProp का इस्तेमाल करें.
  • डिग्री में मेज़र किए गए ऐंगल वाले डाइमेंशन के लिए, DimensionBuilders.DegreesProp का इस्तेमाल करें.
  • स्ट्रिंग वैल्यू के लिए, TypeBuilders.StringProp का इस्तेमाल करें.
  • रंग की वैल्यू के लिए, ColorBuilders.ColorProp का इस्तेमाल करें.
  • फ़्लोटिंग-पॉइंट वैल्यू के लिए, TypeBuilders.FloatProp का इस्तेमाल करें.

जब किसी ऐसे डाइनैमिक एक्सप्रेशन का इस्तेमाल किया जाता है जिससे फ़िज़िकल डाइमेंशन पर असर पड़ता है, तो आपको उससे जुड़ी कुछ पाबंदियां भी तय करनी होंगी. जैसे, स्ट्रिंग फ़ॉर्मैट. फ़िज़िकल डाइमेंशन का मतलब, टाइल में मौजूद रंग के अलावा कोई भी वैल्यू है. इन सीमाओं की मदद से, सिस्टम रेंडरर यह तय कर सकता है कि आपकी टाइल में कोई वैल्यू ज़्यादा से ज़्यादा कितनी जगह ले सकती है. आम तौर पर, इन शर्तों को एलिमेंट लेवल पर तय किया जाता है, न कि डाइनैमिक एक्सप्रेशन लेवल पर. इसके लिए, setLayoutConstraintsForDynamic* से शुरू होने वाले किसी तरीके का इस्तेमाल किया जाता है.

नीचे दिए गए कोड स्निपेट में, दिल की धड़कन की जानकारी को तीन अंकों में दिखाने का तरीका बताया गया है. साथ ही, इसमें फ़ॉलबैक वैल्यू के तौर पर -- का इस्तेमाल किया गया है:

override fun onTileRequest(requestParams: RequestBuilders.TileRequest) =
    Futures.immediateFuture(
        Tile.Builder()
            .setResourcesVersion(RESOURCES_VERSION)
            .setFreshnessIntervalMillis(60 * 60 * 1000) // 60 minutes
            .setTileTimeline(
                Timeline.fromLayoutElement(
                    Text.Builder(
                        this,
                        TypeBuilders.StringProp.Builder("--")
                            .setDynamicValue(
                                PlatformHealthSources.heartRateBpm()
                                    .format()
                                    .concat(DynamicBuilders.DynamicString.constant(" bpm"))
                            )
                            .build(),
                        TypeBuilders.StringLayoutConstraint.Builder("000").build(),
                    )
                        .build()
                )
            )
            .build()
    )
Tile.kt

एक टाइल में कम एक्सप्रेशन इस्तेमाल करें

Wear OS, एक टाइल में इस्तेमाल किए जा सकने वाले एक्सप्रेशन की संख्या तय करता है. अगर किसी टाइल में बहुत ज़्यादा डाइनैमिक एक्सप्रेशन हैं, तो डाइनैमिक वैल्यू को अनदेखा कर दिया जाता है. इसके बाद, सिस्टम उन स्टैटिक वैल्यू का इस्तेमाल करता है जो आपने डाइनैमिक प्रॉपर्टी टाइप के लिए दी हैं.

डाइनैमिक डेटा को किसी स्टेट ऑब्जेक्ट में इकट्ठा करना

डेटा सोर्स से मिले अपडेट के नए सेट को स्टेट में इकट्ठा किया जा सकता है. इसके बाद, वैल्यू रेंडर करने के लिए इसे अपने टाइल पर पास किया जा सकता है.

अपनी टाइलों में राज्य की जानकारी का इस्तेमाल करने के लिए, यह तरीका अपनाएं:

  1. कुंजियों का एक ऐसा सेट बनाएं जो आपकी टाइल की अलग-अलग स्थितियों को दिखाता हो. इस उदाहरण में, पानी पीने और qqq नोट के लिए कुंजियां बनाई गई हैं:

    companion object {
    val KEY_WATER_INTAKE = intAppDataKey("key_water_intake")
    val KEY_NOTE = stringAppDataKey("key_note")
}
    Tile.kt

  2. onTileRequest() को लागू करते समय, setState() को कॉल करें और हर कुंजी से किसी खास डाइनैमिक डेटा वैल्यू के लिए शुरुआती मैपिंग सेट अप करें:

    override fun onTileRequest(
    requestParams: RequestBuilders.TileRequest
): ListenableFuture<Tile?> {
    // If the tile hasn't had any state set yet, use the default values
    val state =
        if (requestParams.currentState.keyToValueMapping.isNotEmpty())
            requestParams.currentState
        else
            StateBuilders.State.Builder()
                .setStateMap(
                    dynamicDataMapOf(
                        KEY_WATER_INTAKE mapTo 200,
                        KEY_NOTE mapTo "Good"
                    )
                )
                .build()

    return Futures.immediateFuture(
        Tile.Builder()
            // Set resources, timeline, and other tile properties.
            .setState(state)
            .build()
    )
}
    Tile.kt

  3. लेआउट बनाते समय, उस जगह पर Dynamic* टाइप ऑब्जेक्ट का इस्तेमाल करें जहां आपको राज्य का यह डेटा दिखाना है. पिछली वैल्यू से मौजूदा वैल्यू तक ऐनिमेशन दिखाने के लिए, animate() को कॉल भी किया जा सकता है:

    val waterIntakeValue =
    DynamicBuilders.DynamicInt32.from(KEY_WATER_INTAKE)
    Tile.kt

  4. ज़रूरत पड़ने पर, नई वैल्यू के साथ स्थिति को भी अपडेट किया जा सकता है. यह किसी टाइल के LoadAction का हिस्सा हो सकता है.

    इस उदाहरण में, पानी पीने की वैल्यू को 400 पर अपडेट किया गया है:

    val loadAction =
    loadAction(
        dynamicDataMapOf(
            KEY_WATER_INTAKE mapTo 400,
            KEY_NOTE mapTo "Outstanding"
        )
    )
    Tile.kt