इस पेज का अनुवाद Cloud Translation API से किया गया है.

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

टाइल 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* से शुरू होने वाले तरीके को कॉल करें.

नीचे दिया गया कोड स्निपेट, 3 अंक, जिनकी फ़ॉलबैक वैल्यू -- है:

KotlinJava

import androidx.wear.protolayout.material.Text

public 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(),
                StringLayoutConstraint.Builder("000")
                    .build()
                ).build()
            )
        ).build()
    )

import androidx.wear.protolayout.material.Text;

@Override
protected ListenableFuture<Tile> onTileRequest(
       @NonNull TileRequest requestParams
) {
    return Futures.immediateFuture(new Tile.Builder()
        .setResourcesVersion(RESOURCES_VERSION)
        .setFreshnessIntervalMillis(60 * 60 * 1000) // 60 minutes
        .setTileTimeline(Timeline.fromLayoutElement(
            new Text.Builder(
                this,
                new TypeBuilders.StringProp.Builder("--")
                    .setDynamicValue(PlatformHealthSources.heartRateBpm()
                        .format()
                        .concat(DynamicBuilders.DynamicString.constant(" bpm")))
                    .build(),
                new StringLayoutConstraint.Builder("000")
                    .build()
                ).build())
        ).build()
    );
}

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

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

आप एक टाइल में ये एक्सप्रेशन के सेट सुरक्षित तरीके से जोड़ सकते हैं, क्योंकि बहुत सारे एक्सप्रेशन नहीं होते. इसलिए, यह टाइल सही तरीके से काम करती है:

KotlinJava

val personHealthInfo = DynamicString.constant("This person has walked ")
    .concat(PlatformHealthSources.dailySteps()
        .div(1000)
        .format())
    .concat("thousands of steps and has a current heart rate ")
    .concat(PlatformHealthSources.heartRateBpm()
        .format())
    .concat(" beats per minute")

DynamicString personHealthInfo =
    DynamicString.constant("This person has walked ")
        .concat(PlatformHealthSources.dailySteps()
            .div(1000)
            .format())
        .concat("thousands of steps and has a current heart rate ")
        .concat(PlatformHealthSources.heartRateBpm()
            .format())
        .concat(" beats per minute");

हालांकि, इस टाइल में बहुत ज़्यादा एक्सप्रेशन हो सकते हैं:

KotlinJava

// Note that this template is applied as many times as the loop iterates.
// The system doesn't reuse dynamic expressions.
val dynamicStringTemplate = PlatformHealthSources.dailySteps()
    .div(1000)
    .format()

for (person in people) {
  // SomeProperty
    .setDynamicValue(
        DynamicBuilders.DynamicString.constant("Steps for ")
            .concat(person)
            .concat(" are ")
            .concat(dynamicStringTemplate)
    )
}

// Note that this template is applied as many times as the loop iterates.
// The system doesn't reuse dynamic expressions.
DynamicString dynamicStringTemplate =
    PlatformHealthSources.dailySteps()
        .div(1000)
        .format();

for (int i = 0; i < people.size(); i++) {
  // SomeProperty
    .setDynamicValue(
        DynamicBuilders.DynamicString.constant("Steps for ")
            .concat(people[i])
            .concat(" are ")
            .concat(dynamicStringTemplate)
    );
}

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

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

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

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

KotlinJava

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

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

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

KotlinJava

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

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

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

इस उदाहरण में, पानी पीने की वैल्यू को 400 पर अपडेट किया गया है:
KotlinJava
state.addKeyToValueMapping(KEY_WATER_INTAKE, DynamicDataBuilders.DynamicDataValue.fromInt(400))
state.addKeyToValueMapping(KEY_WATER_INTAKE, DynamicDataBuilders.DynamicDataValue.fromInt(400));

फ़िलहाल कोई सुझाव नहीं है.

अपने Google खाते में साइन इन करने की कोशिश करें.