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

टाइल्स 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()
    )

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

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

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

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

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

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

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

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

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

    val waterIntakeValue =
    DynamicBuilders.DynamicInt32.from(KEY_WATER_INTAKE)

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

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

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