Dynamische Updates in Kacheln anzeigen

Ab Tiles 1.2 kannst du Aktualisierungen von Plattformdaten mit dynamische Ausdrücke. Sie können diese Updates dann mit Animationen verknüpfen. in Ihren Kacheln. Ihre App erhält jede Sekunde Updates zu diesem Wert.

Mit dynamischen Ausdrücken müssen Sie nicht die gesamte Tile aktualisieren, Änderungen der Inhalte. Um Ihre Kacheln interaktiver zu gestalten, können Sie für diese dynamischen Objekte.

Dynamische Ausdrücke mit Datenquellen verknüpfen

androidx.wear.protolayout und androidx.wear.protolayout.material Namespaces enthalten viele Klassen, deren Felder dynamische Ausdrücke akzeptieren. Hier einige Beispiele:

• Mehrere Längenwerte, einschließlich der Länge eines Arc-Objekts und des Länge eines CircularProgressIndicator-Objekts.
• Beliebige Farbe, z. B. die Inhaltsfarbe eines Button-Objekts.
• Viele Stringwerte, darunter der Inhalt eines Text-Objekts, die Inhalt eines LayoutElementsBuilders.Text-Objekts und der Inhalt eines Beschreibung eines CircularProgressIndicator-Objekts.

Um einen dynamischen Ausdruck als möglicher Wert für ein Element in Ihrer Kachel zu verwenden, verwenden Sie den entsprechenden dynamischen Eigenschaftstyp *Prop des Elements und übergeben Sie die Daten Quelle für die Builder-Klasse setDynamicValue() des dynamischen Property-Typs .

Kacheln unterstützen die folgenden dynamischen Eigenschaftstypen:

• Für lineare Dimensionen, die in displayunabhängigen Pixeln gemessen werden, verwenden Sie DimensionBuilders.DpProp
• Für Winkelabmessungen, gemessen in Grad, verwenden Sie DimensionBuilders.DegreesProp
• Verwenden Sie für Stringwerte TypeBuilders.StringProp.
• Verwenden Sie für Farbwerte ColorBuilders.ColorProp.
• Verwenden Sie TypeBuilders.FloatProp für Gleitkommawerte.

Wenn Sie einen dynamischen Ausdruck verwenden, der sich auf physische Dimensionen auswirkt, d. h. einen beliebigen Wert in eine Kachel mit Ausnahme der Farbe – Sie müssen auch eine Reihe verwandter Einschränkungen angeben, wie als Zeichenfolgenformat. Anhand dieser Einschränkungen kann der System-Renderer festlegen, Maximalen Platz, den ein Wert innerhalb Ihrer Kachel einnehmen kann. Normalerweise geben Sie diese Einschränkungen auf Elementebene an, nicht auf dem dynamischen Ausdruck. durch Aufrufen einer Methode, die mit setLayoutConstraintsForDynamic* beginnt.

Das folgende Code-Snippet zeigt, wie Änderungen der Herzfrequenz mit 3 Ziffern, mit dem Fallback-Wert --:

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

Verwenden Sie eine kleine Anzahl von Ausdrücken innerhalb einer einzelnen Kachel

Wear OS ergibt ein Limit für die Anzahl der Ausdrücke, die eine einzelne Kachel verwenden kann haben. Wenn eine Tile insgesamt zu viele dynamische Ausdrücke enthält, werden dynamische Werte ignoriert und das System greift auf die statischen Werte zu, die Sie für die Methode die entsprechenden dynamischen Property-Typen aus.

Sie können die folgenden Ausdrücke sicher zu einer Tile hinzufügen, nicht viele Gesamtausdrücke. Daher verhält sich die Kachel ordnungsgemäß:

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");

Diese Kachel kann jedoch zu viele Ausdrücke enthalten:

// 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)
    );
}

Dynamische Daten in einem Zustandsobjekt konsolidieren

Sie können die neuesten Updates aus Datenquellen in einem Status konsolidieren, die Sie an Ihre Kachel übergeben, um den Wert zu rendern.

Führen Sie die folgenden Schritte aus, um Zustandsinformationen in Ihren Kacheln zu verwenden:

1. Legen Sie eine Reihe von Schlüsseln fest, die die verschiedenen Werte der Tile-Werte Bundesstaat. In diesem Beispiel werden Schlüssel für die Wasseraufnahme und eine Notiz erstellt:

   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. Rufen Sie bei der Implementierung von onTileRequest() setState() auf und richten Sie anfängliche Zuordnungen von jedem Schlüssel zu einem bestimmten dynamischen Datenwert:

   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. Wenn Sie Ihr Layout erstellen, an einer Stelle, an der Sie diese Daten anzeigen möchten verwenden Sie ein Objekt des Typs Dynamic*. Sie können auch animate() anrufen, um Animation vom vorherigen bis zum aktuellen Wert anzeigen:

   Kotlin

   DynamicInt32.from(KEY_WATER_INTAKE).animate()
   

   Java

   DynamicInt32.from(KEY_WATER_INTAKE).animate();
   

4. Bei Bedarf können Sie den Status auch mit neuen Werten aktualisieren. Dabei kann es sich um Teil des LoadAction einer Kachel.

   In diesem Beispiel wird der Wert für die Wasseraufnahme in 400 aktualisiert:

   Kotlin

   state.addKeyToValueMapping(KEY_WATER_INTAKE,
           DynamicDataBuilders.DynamicDataValue.fromInt(400))
   

   Java

   state.addKeyToValueMapping(KEY_WATER_INTAKE,
           DynamicDataBuilders.DynamicDataValue.fromInt(400));