Synchronizowanie elementów danych z interfejsem Data Layer API

DataItem definiuje interfejs używany przez system do synchronizacji danych między urządzeniami przenośnymi do noszenia. DataItem zwykle składa się z tych komponentów:

  • Ładunek: tablica bajtów, którą można ustawić z danymi własnych serializacji obiektów, deserializacja. Wielkość ładunku jest ograniczona do 100 KB.
  • Ścieżka: unikalny ciąg, który musi zaczynać się ukośnikiem, np. "/path/to/data"

Uwaga: Interfejs Data Layer API może tylko wysyłać wiadomości i synchronizować dane tylko z telefonami z Androidem lub z Wear OS zegarki. Jeśli Twoje urządzenie z Wear OS jest sparowane z urządzeniem z iOS, interfejs Data Layer API nie będzie działa.

Dlatego nie używaj interfejsu Data Layer API jako to główny sposób komunikacji z siecią. Zamiast tego wykonaj jak w przypadku aplikacji mobilnej, z pewnymi niewielkimi różnicami.

Zwykle nie implementujesz DataItem bezpośrednio. Zamiast tego wykonaj te czynności:

  1. Utwórz PutDataRequest, określając ścieżkę do jednoznacznego identyfikatora elementu.
  2. Zadzwoń do setData(), aby ustawić ładunek.
  3. Jeśli opóźnienie synchronizacji może negatywnie wpłynąć na wrażenia użytkownika, zadzwoń pod numer setUrgent()
  4. Użyj metody putDataItem funkcji DataClient, aby zażądać utworzenia elementu danych przez system.

Po wysłaniu żądania elementów danych system zwraca obiekty, które prawidłowo implementują Interfejs DataItem. Jednak zamiast z nieprzetworzonymi bajtami za pomocą funkcji setData(), zalecamy użyj mapy danych, który udostępnia element danych z interfejsem podobnym do Bundle.

Więcej informacji można znaleźć w DataLayer Sample.

Synchronizowanie danych z mapą danych

W miarę możliwości używaj DataMap zajęcia. Takie podejście umożliwia pracę z elementami danych w postaci Androida Bundle, aby system przeprowadził za Ciebie serializację i deserializację obiektów, dzięki czemu możesz modyfikować dane. za pomocą par klucz-wartość.

Aby użyć mapy danych:

  1. Utwórz PutDataMapRequest, ustawiając ścieżkę do elementu danych.

    Uwaga: ciąg znaków ścieżki jest unikalnym identyfikatorem element danych, który umożliwia dostęp do niego z obu stron połączenia. Ścieżka musi zaczynać się ukośnikiem. Jeśli używasz danych hierarchicznych utwórz schemat ścieżki dopasowany do struktury danych.

  2. Zadzwoń do PutDataMapRequest.getDataMap(), aby uzyskać mapę danych, którą można ustaw wartości.
  3. Ustaw wartości dla zmapowania danych za pomocą metod put...(), takich jak putString().
  4. Jeśli opóźnienie synchronizacji może negatywnie wpłynąć na wrażenia użytkownika, zadzwoń pod numer setUrgent()
  5. Zadzwoń do PutDataMapRequest.asPutDataRequest(), aby uzyskać . PutDataRequest obiekt.
  6. Użyj metody putDataItem funkcji DataClient, aby zażądać utworzenia elementu danych przez system.

    Uwaga: Jeśli telefon i urządzenia do noszenia są odłączone, dane są buforowane i synchronizowane po ponownym nawiązaniu połączenia.

Metoda increaseCounter() w przykładzie poniżej pokazuje, jak utworzyć mapę danych i umieść w niej dane:

Kotlin

private const val COUNT_KEY = "com.example.key.count"

class MainActivity : Activity() {

    private lateinit var dataClient: DataClient
    private var count = 0
    ...
    // Create a data map and put data in it
    private fun increaseCounter() {
        val putDataReq: PutDataRequest = PutDataMapRequest.create("/count").run {
            dataMap.putInt(COUNT_KEY, count++)
            asPutDataRequest()
        }
        val putDataTask: Task<DataItem> = dataClient.putDataItem(putDataReq)
    }
    ...
}

Java

public class MainActivity extends Activity {
    private static final String COUNT_KEY = "com.example.key.count";
    private DataClient dataClient;
    private int count = 0;
    ...
    // Create a data map and put data in it
    private void increaseCounter() {
        PutDataMapRequest putDataMapReq = PutDataMapRequest.create("/count");
        putDataMapReq.getDataMap().putInt(COUNT_KEY, count++);
        PutDataRequest putDataReq = putDataMapReq.asPutDataRequest();
        Task<DataItem> putDataTask = dataClient.putDataItem(putDataReq);
    }
  ...
}

Więcej informacji o obsłudze Tasks, zobacz . dokumentacji.

Ustawianie priorytetu DataItem

Interfejs API DataClient umożliwia pilne żądania synchronizacji DataItem obiektów. Zazwyczaj system opóźnia dostarczanie elementów danych. do sieci Wear OS, aby wydłużyć czas pracy na baterii w urządzeniach użytkowników. jeśli opóźnienie synchronizacji elementów danych negatywnie wpływa na wygodę użytkowników, możesz zaznaczyć jako pilnych. Na przykład w aplikacji pilota, w której użytkownik oczekuje, że mogą być natychmiast odzwierciedlane, system może zsynchronizować elementy danych natychmiast, dzwoniąc pod numer setUrgent()

Jeśli nie zadzwonisz do: setUrgent(), system może opóźnić się do 30 minut przed synchronizować mniej pilne elementy danych, ale zwykle opóźnienia mogą być niewielkie min. Domyślnie nie jest ono pilne, więc musisz użyć setUrgent(), jeśli chcesz zachować natychmiastową synchronizację z poprzednich wersji interfejsu Wear OS API.

Nasłuchuj zdarzeń dotyczących elementu danych

Jeśli jedna strona połączenia w warstwie danych zmieni element danych, powiadom zmiany wprowadzane przez użytkownika po drugiej stronie połączenia. Aby to zrobić, zaimplementuj detektor zdarzeń elementu danych.

Fragment kodu z poniższego przykładu powiadamia aplikację, gdy wartość atrybutu licznik zdefiniowanego w poprzednim przykładzie zmienia się:

Kotlin

private const val COUNT_KEY = "com.example.key.count"

class MainActivity : Activity(), DataClient.OnDataChangedListener {

    private var count = 0

    override fun onResume() {
        super.onResume()
        Wearable.getDataClient(this).addListener(this)
    }

    override fun onPause() {
        super.onPause()
        Wearable.getDataClient(this).removeListener(this)
    }

    override fun onDataChanged(dataEvents: DataEventBuffer) {
        dataEvents.forEach { event ->
            // DataItem changed
            if (event.type == DataEvent.TYPE_CHANGED) {
                event.dataItem.also { item ->
                    if (item.uri.path.compareTo("/count") == 0) {
                        DataMapItem.fromDataItem(item).dataMap.apply {
                            updateCount(getInt(COUNT_KEY))
                        }
                    }
                }
            } else if (event.type == DataEvent.TYPE_DELETED) {
                // DataItem deleted
            }
        }
    }

    // Method to update the count
    private fun updateCount(int: Int) { ... }
    ...
}

Java

public class MainActivity extends Activity implements DataClient.OnDataChangedListener {
    private static final String COUNT_KEY = "com.example.key.count";
    private int count = 0;

    @Override
    protected void onResume() {
        super.onResume();
        Wearable.getDataClient(this).addListener(this);
    }

    @Override
    protected void onPause() {
        super.onPause();
        Wearable.getDataClient(this).removeListener(this);
    }

    @Override
    public void onDataChanged(DataEventBuffer dataEvents) {
        for (DataEvent event : dataEvents) {
            if (event.getType() == DataEvent.TYPE_CHANGED) {
                // DataItem changed
                DataItem item = event.getDataItem();
                if (item.getUri().getPath().compareTo("/count") == 0) {
                    DataMap dataMap = DataMapItem.fromDataItem(item).getDataMap();
                    updateCount(dataMap.getInt(COUNT_KEY));
                }
            } else if (event.getType() == DataEvent.TYPE_DELETED) {
                // DataItem deleted
            }
        }
    }

    // Method to update the count
    private void updateCount(int c) { ... }
    ...
}

To ćwiczenie implementuje DataClient.OnDataChangedListener. Aktywność jest dodawana do siebie jako detektora zdarzeń elementu danych wewnątrz onResume() i usuwa detektor w sekcji Metoda onPause(). Aby zobaczyć implementację przy użyciu obrazów, modeli i modeli więcej informacji można znaleźć w przykładzie DataLayer (w języku angielskim). .

Możesz również wdrożyć detektor jako usługę. Więcej informacji: Nasłuchiwanie warstwy danych wydarzenia.