Para sincronizar datos

En este documento, se describe cómo sincronizar datos entre un dispositivo Wear OS y un teléfono. Consulta la guía general para saber cuándo usar la API de Data Layer y cuándo usar tu infraestructura.

Envía y sincroniza datos directamente desde la red

Compila apps para Wear OS para comunicarte directamente con la red. Puedes usar las mismas APIs que usas en el desarrollo para dispositivos móviles, pero ten en cuenta las diferencias específicas de Wear OS.

Sincroniza datos con la API de Wear OS Data Layer

Un DataClient expone una API para que los componentes lean o escriban en un DataItem o Asset.

Es posible configurar elementos de datos y recursos mientras no tienes conexión a ningún dispositivo. Se sincronizan cuando los dispositivos establecen una conexión de red. Estos datos son privados para tu app y solo ella puede acceder a ellos en otros dispositivos.

  • Un DataItem se sincroniza en todos los dispositivos de una red de Wear OS. Por lo general, son de tamaño pequeño.

  • Usa un Asset para transferir un objeto más grande, como una imagen. El sistema realiza un seguimiento de los recursos que ya se transfirieron y realiza la deduplicación automáticamente.

Detecta eventos en servicios

Extiende la WearableListenerService clase. El sistema maneja el ciclo de vida del WearableListenerService base; vincula al servicio cuando necesita enviar elementos de datos o mensajes y desvincula el servicio cuando no es necesario realizar tareas.

Detecta eventos en actividades

Implementa la interfaz OnDataChangedListener. Usa esta interfaz en lugar de un WearableListenerService cuando quieras detectar cambios solo cuando el usuario usa activamente tu app.

description: Transfer large binary objects, such as images, between Android phones and Wear OS watches using Assets in the Data Layer API. keywords_public: Wear OS, Data Layer API, Assets, Bluetooth data transfer, data synchronization, DataMap, PutDataRequest

Cómo sincronizar datos

Para compartir objetos binarios grandes a través de Bluetooth, como una grabación de voz desde otro dispositivo, puedes adjuntar un Asset a un elemento de datos y, luego, colocar ese elemento en el almacén de datos replicado.

Nota: La API de Data Layer puede enviar mensajes y sincronizar datos solo con teléfonos que ejecutan Android o relojes Wear OS. Si un dispositivo Wear OS está vinculado con un dispositivo iOS, la API de Data Layer no funcionará.

Por este motivo, no debes usar la API de Data Layer como método principal para comunicarte con una red. En su lugar, sigue el mismo patrón en tu app para Wear OS que en una app para teléfonos, con algunas diferencias leves, como se describe en Acceso a la red y sincronización en Wear OS.

Los recursos manejan automáticamente el almacenamiento en caché de datos para evitar la retransmisión y conservar el ancho de banda de Bluetooth. Un patrón común es que una app para teléfonos descargue una imagen, reduzca su tamaño a uno apropiado de modo que pueda verse en el reloj y la comparta como recurso con la app de reloj. En los siguientes ejemplos, se muestra este patrón.

Cómo transferir un recurso

Crea el recurso usando uno de los create...() métodos en la Asset clase. Convierte un mapa de bits en un array de bytes y, luego, llama a createFromBytes() para crear el recurso, como se muestra en el siguiente ejemplo.

private fun createAssetFromBitmap(bitmap: Bitmap): Asset =
    ByteArrayOutputStream().let { byteStream ->
        bitmap.compress(Bitmap.CompressFormat.PNG, 100, byteStream)
        Asset.createFromBytes(byteStream.toByteArray())
    }

Luego, adjunta el recurso a un elemento de datos con el putAsset() método en DataMap o PutDataRequest. Luego, coloca el elemento de datos en el almacén de datos con el método putDataItem(), como se muestra en los siguientes ejemplos.

En el siguiente ejemplo, se usa PutDataRequest:

private fun Context.sendImagePutDataRequest(): Task<DataItem> {

    val asset: Asset = createAssetFromBitmap(BitmapFactory.decodeResource(resources, R.drawable.ic_walk))
    val request: PutDataRequest = PutDataRequest.create("/image").apply {
        putAsset("profileImage", asset)
    }
    val putTask: Task<DataItem> = Wearable.getDataClient(this).putDataItem(request)

    return putTask
}

En el siguiente ejemplo, se usa PutDataMapRequest:

private fun Context.sendImagePutDataMapRequest(): Task<DataItem> {

    val asset: Asset = createAssetFromBitmap(BitmapFactory.decodeResource(resources, R.drawable.ic_walk))
    val request: PutDataRequest = PutDataMapRequest.create("/image").run {
        dataMap.putAsset("profileImage", asset)
        asPutDataRequest()
    }
    val putTask: Task<DataItem> = Wearable.getDataClient(this).putDataItem(request)

    return putTask
}

Cómo recibir recursos

Después de crear un recurso, por lo general, lo lees y lo extraes en el otro extremo de la conexión. A continuación, se incluye un ejemplo de cómo implementar la devolución de llamada para detectar un cambio de recurso y extraerlo:

override fun onDataChanged(dataEvents: DataEventBuffer) {
    dataEvents
        .filter { it.type == DataEvent.TYPE_CHANGED && it.dataItem.uri.path == "/image" }
        .forEach { event ->
            val asset = DataMapItem.fromDataItem(event.dataItem)
                .dataMap.getAsset("profileImage")

            asset?.let { safeAsset ->
                lifecycleScope.launch {
                    val bitmap = loadBitmapFromAsset(safeAsset)
                    // Do something with the bitmap
                }
            }
        }
}

private suspend fun loadBitmapFromAsset(asset: Asset): Bitmap? = withContext(Dispatchers.IO) {
    try {
        val assetResult = Wearable.getDataClient(this@DataLayerActivity2)
            .getFdForAsset(asset)
            .await()

        assetResult?.inputStream?.use { inputStream ->
            BitmapFactory.decodeStream(inputStream)
        }
    } catch (e: Exception) {
        e.printStackTrace()
        null
    }
}

Para obtener más información, consulta el proyecto de muestra de DataLayer en GitHub.