Esta página foi traduzida pela API Cloud Translation.

Integrar um módulo do Wear OS

Melhore a experiência de saúde e condicionamento físico do seu app expandindo-o para dispositivos wearable com tecnologia do Wear OS.

Adicionar um módulo do Wear OS

O Android Studio oferece um assistente útil para adicionar um módulo do Wear OS ao seu app. No menu File > New Module, selecione Wear OS, conforme mostrado na imagem abaixo:

Assistente de módulo do Wear OS no Android Studio — **Figura 1**: criar um módulo do Wear OS

É importante observar que o Minimum SDK precisa ter o nível API 30 ou mais recente para permitir que você use a versão mais recente dos Recursos de saúde. Os Recursos de saúde facilitam o rastreamento de métricas e o registro de dados configurando sensores de saúde automaticamente.

Depois de concluir o assistente, sincronize seu projeto. A configuração de Run a seguir será exibida:

Imagem mostrando o botão de execução do app Wear OS — **Figura 2**: botão "Run" do novo módulo do Wear OS.

Isso permite executar o módulo do Wear OS em um dispositivo wearable. Você tem duas opções:

Execute em um emulador.
Execute em um dispositivo real.

A execução da configuração implanta o app no emulador ou dispositivo do Wear OS e mostra uma experiência "hello world". Essa é a configuração básica da interface, usando o Compose para Wear OS, para começar a usar seu app.

Adicionar os Recursos de saúde e o Hilt

Integre as bibliotecas abaixo ao módulo do Wear OS:

Recursos de saúde:torna o acesso a sensores e dados no relógio muito conveniente e mais eficiente em termos de energia.
Hilt:permite injeção e gerenciamento de dependências eficazes.

Criar o gerenciador de Recursos de saúde

Para tornar o uso dos Recursos de saúde um pouco mais conveniente e expor uma API menor e mais suave, crie um wrapper como este:

private const val TAG = "WATCHMAIN"

class HealthServicesManager(context: Context) {
    private val measureClient = HealthServices.getClient(context).measureClient

    suspend fun hasHeartRateCapability() = runCatching {
        val capabilities = measureClient.getCapabilities()
        (DataType.HEART_RATE_BPM in capabilities.supportedDataTypesMeasure)
    }.getOrDefault(false)

    /**
     * Returns a cold flow. When activated, the flow will register a callback for heart rate data
     * and start to emit messages. When the consuming coroutine is canceled, the measure callback
     * is unregistered.
     *
     * [callbackFlow] creates a  bridge between a callback-based API and Kotlin flows.
     */
    @ExperimentalCoroutinesApi
    fun heartRateMeasureFlow(): Flow<MeasureMessage> = callbackFlow {
        val callback = object : MeasureCallback {
            override fun onAvailabilityChanged(dataType: DeltaDataType<*, *>, availability: Availability) {
                // Only send back DataTypeAvailability (not LocationAvailability)
                if (availability is DataTypeAvailability) {
                    trySendBlocking(MeasureMessage.MeasureAvailability(availability))
                }
            }

            override fun onDataReceived(data: DataPointContainer) {
                val heartRateBpm = data.getData(DataType.HEART_RATE_BPM)
                Log.d(TAG, "💓 Received heart rate: ${heartRateBpm.first().value}")
                trySendBlocking(MeasureMessage.MeasureData(heartRateBpm))
            }
        }

        Log.d(TAG, "⌛ Registering for data...")
        measureClient.registerMeasureCallback(DataType.HEART_RATE_BPM, callback)

        awaitClose {
            Log.d(TAG, "👋 Unregistering for data")
            runBlocking {
                measureClient.unregisterMeasureCallback(DataType.HEART_RATE_BPM, callback)
            }
        }
    }
}

sealed class MeasureMessage {
    class MeasureAvailability(val availability: DataTypeAvailability) : MeasureMessage()
    class MeasureData(val data: List<SampleDataPoint<Double>>) : MeasureMessage()
}

Depois de criar o módulo do Hilt para gerenciá-lo, use o seguinte snippet:

@Module
@InstallIn(SingletonComponent::class)
internal object DataModule {
    @Provides
    @Singleton
    fun provideHealthServices(@ApplicationContext context: Context): HealthServicesManager = HealthServicesManager(context)
}

É possível injetar o HealthServicesManager como qualquer outra dependência do Hilt.

O novo HealthServicesManager fornece um método heartRateMeasureFlow() que registra um listener para o monitor cardíaco e emite os dados recebidos.

Ativar atualizações de dados em dispositivos wearable

As atualizações de dados relacionados ao condicionamento físico exigem a permissão BODY_SENSORS. Caso ainda não tenha feito isso, declare a permissão BODY_SENSORS no arquivo de manifesto do app. Em seguida, solicite a permissão, conforme mostrado neste snippet:

val permissionState = rememberPermissionState(
    permission = Manifest.permission.BODY_SENSORS,
    onPermissionResult = { granted -> /* do something */ }
)

[...]

if (permissionState.status.isGranted) {
    // do something
} else {
    permissionState.launchPermissionRequest()
}

Se você testar o app em um dispositivo físico, os dados começarão a ser atualizados.

A partir do Wear OS 4, os emuladores também mostram dados de teste automaticamente. Em versões anteriores, é possível simular o fluxo de dados do sensor. Em uma janela de terminal, execute este comando ADB:

adb shell am broadcast \
-a "whs.USE_SYNTHETIC_PROVIDERS" \
com.google.android.wearable.healthservices

Para acessar diferentes valores de frequência cardíaca, tente simular exercícios diferentes. Este comando simula uma caminhada:

adb shell am broadcast \
-a "whs.synthetic.user.START_WALKING" \
com.google.android.wearable.healthservices

Este comando simula a execução:

adb shell am broadcast \
-a "whs.synthetic.user.START_RUNNING" \
com.google.android.wearable.healthservices

Para interromper a simulação dos dados, execute este comando:

adb shell am broadcast -a \
"whs.USE_SENSOR_PROVIDERS" \
com.google.android.wearable.healthservices

Ler dados de frequência cardíaca

Com a permissão BODY_SENSORS concedida, você pode ler a frequência cardíaca do usuário (heartRateMeasureFlow()) no HealthServicesManager. Na interface do app para Wear OS, o valor atual da frequência cardíaca é mostrado, medido pelo sensor do dispositivo wearable.

No ViewModel, comece a coletar dados usando o objeto de fluxo de frequência cardíaca, conforme mostrado no snippet abaixo:

val hr: MutableState<Double> = mutableStateOf(0.0)

[...]

healthServicesManager
    .heartRateMeasureFlow()
    .takeWhile { enabled.value }
    .collect { measureMessage ->
        when (measureMessage) {
            is MeasureData -> {
                val latestHeartRateValue = measureMessage.data.last().value
                hr.value = latestHeartRateValue
            }

            is MeasureAvailability -> availability.value =
                    measureMessage.availability
        }
    }

Use um objeto combinável semelhante ao seguinte para mostrar os dados em tempo real na interface do app:

val heartRate by viewModel.hr

Text(
  text = "Heart Rate: $heartRate",
  style = MaterialTheme.typography.display1
)

Enviar dados para um dispositivo portátil

Para enviar dados de saúde e condicionamento físico para um dispositivo portátil, use a classe DataClient nos Recursos de saúde. O snippet de código abaixo mostra como enviar dados de frequência cardíaca que seu app coletou anteriormente:

class HealthServicesManager(context: Context) {
    private val dataClient by lazy { Wearable.getDataClient(context) }

[...]

    suspend fun sendToHandheldDevice(heartRate: Int) {
        try {
            val result = dataClient
                .putDataItem(PutDataMapRequest
                    .create("/heartrate")
                    .apply { dataMap.putInt("heartrate", heartRate) }
                    .asPutDataRequest()
                    .setUrgent())
                .await()

            Log.d(TAG, "DataItem saved: $result")
        } catch (cancellationException: CancellationException) {
            throw cancellationException
        } catch (exception: Exception) {
            Log.d(TAG, "Saving DataItem failed: $exception")
        }
    }
}

Receber os dados no smartphone

Para receber os dados no smartphone, crie um WearableListenerService:

@AndroidEntryPoint
class DataLayerListenerService : WearableListenerService() {

    @Inject
    lateinit var heartRateMonitor: HeartRateMonitor

    override fun onDataChanged(dataEvents: DataEventBuffer) {

        dataEvents.forEach { event ->
            when (event.type) {
                DataEvent.TYPE_CHANGED -> {
                    event.dataItem.run {
                        if (uri.path?.compareTo("/heartrate") == 0) {
                            val heartRate = DataMapItem.fromDataItem(this)
                                    .dataMap.getInt(HR_KEY)
                            Log.d("DataLayerListenerService",
                                    "New heart rate value received: $heartRate")
                            heartRateMonitor.send(heartRate)
                        }
                    }
                }

                DataEvent.TYPE_DELETED -> {
                    // DataItem deleted
                }
            }
        }
    }
}

Após a conclusão dessa etapa, observe alguns detalhes interessantes:

A anotação @AndroidEntryPoint permite usar o Hilt nessa classe
O @Inject lateinit var heartRateMonitor: HeartRateMonitor injetará uma dependência nessa classe
A classe implementa onDataChanged() e recebe uma coleção de eventos que pode ser analisada e usada

A lógica de HeartRateMonitor abaixo permite enviar os valores de frequência cardíaca recebidos para outra parte da base de código do seu app:

class HeartRateMonitor {
    private val datapoints = MutableSharedFlow<Int>(extraBufferCapacity = 10)

    fun receive(): SharedFlow<Int> = datapoints.asSharedFlow()

    fun send(hr: Int) {
        datapoints.tryEmit(hr)
    }
}

Um barramento de dados recebe os eventos do método onDataChanged() e os disponibiliza para observadores de dados usando um SharedFlow.

O bit final é a declaração do Service no aplicativo para smartphones AndroidManifest.xml:

<service
    android:name=".DataLayerListenerService"
    android:exported="true">
    <intent-filter>
        <!-- listeners receive events that match the action and data filters -->
        <action android:name="com.google.android.gms.wearable.DATA_CHANGED" />
        <data
            android:host="*"
            android:pathPrefix="/heartrate"
            android:scheme="wear" />
    </intent-filter>
</service>

Mostrar dados em tempo real em um dispositivo portátil

Na parte do app executada em um dispositivo portátil, injete o HeartRateMonitor no construtor do modelo de visualização. Esse objeto HeartRateMonitor observa os dados de frequência cardíaca e emite atualizações da interface conforme necessário.