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

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

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

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

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

• लंबाई की कई वैल्यू, जिनमें Arc ऑब्जेक्ट की लंबाई और CircularProgressIndicator ऑब्जेक्ट की लंबाई शामिल है.
• कोई भी रंग, जैसे कि Button ऑब्जेक्ट का कॉन्टेंट रंग.
• कई स्ट्रिंग वैल्यू, जिनमें Text ऑब्जेक्ट का कॉन्टेंट, LayoutElementsBuilders.Text ऑब्जेक्ट का कॉन्टेंट, और CircularProgressIndicator ऑब्जेक्ट का कॉन्टेंट ब्यौरा शामिल है.

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

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

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

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

ध्यान दें: Material कॉम्पोनेंट, लेआउट की इन सीमाओं को अपने-आप सेट करते हैं.

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

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. अपनी टाइल की स्थिति की अलग-अलग वैल्यू दिखाने वाली कुंजियों का एक सेट बनाएं. इस उदाहरण में, पानी के सेवन और नोट के लिए की बनाई गई हैं:

   Kotlin

   companion object {
       val KEY_WATER_INTAKE = AppDataKey<DynamicInt32>("water_intake")
       val KEY_NOTE = AppDataKey<DynamicString>("note")
   }

   Java

   private static final AppDataKey<DynamicInt32> KEY_WATER_INTAKE =
       new AppDataKey<DynamicInt32>("water_intake");
   private static final AppDataKey<DynamicString> KEY_NOTE =
       new AppDataKey<DynamicString>("note");

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

   Kotlin

   override fun onTileRequest(requestParams: TileRequest):
           ListenableFuture<Tile> {
       val state = State.Builder()
           .addKeyToValueMapping(KEY_WATER_INTAKE,
               DynamicDataBuilders.DynamicDataValue.fromInt(200))
           .addKeyToValueMapping(KEY_NOTE,
               DynamicDataBuilders.DynamicDataValue.fromString("Note about day"))
       .build()
       // ...
   
       return Futures.immediateFuture(Tile.Builder()
           // Set resources, timeline, and other tile properties.
           .setState(state)
           .build()
       )

   Java

   @Override
   protected ListenableFuture<Tile> onTileRequest(
               ListenableFuture<Tile> {
       State state = new State.Builder()
           .addKeyToValueMapping(KEY_WATER_INTAKE,
               DynamicDataBuilders.DynamicDataValue.fromInt(200))
           .addKeyToValueMapping(KEY_NOTE,
               DynamicDataBuilders.DynamicDataValue.fromString("Note about day"))
       .build();
       // ...
   
       return Futures.immediateFuture(Tile.Builder()
           // Set resources, timeline, and other tile properties.
           .setState(state)
           .build()
       );
   }

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

   Kotlin

   DynamicInt32.from(KEY_WATER_INTAKE).animate()

   Java

   DynamicInt32.from(KEY_WATER_INTAKE).animate();

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

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

   Kotlin

   val loadAction = LoadAction.Builder()
       .setRequestState(
           State.Builder()
               .addKeyToValueMapping(
                   KEY_WATER_INTAKE,
                   DynamicDataBuilders.DynamicDataValue.fromInt(400)
               )
               .build()
       )
       .build()

   Java

   LoadAction loadAction = new LoadAction.Builder()
       .setRequestState(
           new State.Builder()
               .addKeyToValueMapping(
                   KEY_WATER_INTAKE,
                   DynamicDataBuilders.DynamicDataValue.fromInt(400)
               ).build()
       ).build();