Améliorez l'expérience de santé et de remise en forme de votre application en la proposant sur les accessoires connectés équipés de Wear OS.
Ajouter un module Wear OS
Android Studio fournit un assistant pratique pour ajouter un module Wear OS à votre application. Dans le menu File > New Module (Fichier > Nouveau module), sélectionnez Wear OS, comme illustré ci-dessous:
![Assistant du module Wear OS dans Android Studio](https://developer.android.com/static/health-and-fitness/guides/basic-fitness-app/images/basic_fitness_app_img_8.png?authuser=5&hl=fr)
Il est important de noter que la version minimale du SDK doit correspondre à l'API 30 ou à une version ultérieure pour que vous puissiez utiliser la dernière version de Services Santé. Services Santé facilite le suivi des métriques et l'enregistrement des données en configurant automatiquement les capteurs de santé.
Une fois les étapes de l'assistant terminées, synchronisez votre projet. La configuration d'exécution suivante s'affiche:
![Image montrant le bouton d'exécution de l'application Wear OS](https://developer.android.com/static/health-and-fitness/guides/basic-fitness-app/images/basic_fitness_app_img_5.png?authuser=5&hl=fr)
Cela vous permet d'exécuter le module Wear OS sur un accessoire connecté. Deux possibilités s'offrent à vous :
Exécutez-le sur un émulateur.
Exécutez l'application sur un appareil réel.
L'exécution de la configuration déploie l'application sur l'émulateur ou l'appareil Wear OS et affiche une expérience "hello world". Voici la configuration de base de l'interface utilisateur, à l'aide de Compose pour Wear OS, pour commencer à utiliser votre application.
Ajouter Services Santé et Hilt
Intégrez les bibliothèques suivantes à votre module Wear OS:
- Services Santé:rend l'accès aux capteurs et aux données sur la montre très pratique et économe en énergie.
- Hilt:permet d'injecter et de gérer efficacement les dépendances.
Créer le gestionnaire de services Santé
Pour faciliter l'utilisation des Services Santé et exposer une API plus petite et plus fluide, vous pouvez créer un wrapper comme suit:
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()
}
Une fois que vous avez créé le module Hilt pour le gérer, utilisez l'extrait de code suivant:
@Module
@InstallIn(SingletonComponent::class)
internal object DataModule {
@Provides
@Singleton
fun provideHealthServices(@ApplicationContext context: Context): HealthServicesManager = HealthServicesManager(context)
}
vous pouvez injecter HealthServicesManager
comme n'importe quelle autre dépendance de Hilt.
Le nouveau HealthServicesManager
fournit une méthode heartRateMeasureFlow()
qui enregistre un écouteur pour le moniteur cardiaque et émet les données reçues.
Activer la mise à jour des données sur les accessoires connectés
L'autorisation BODY_SENSORS
est nécessaire pour mettre à jour les données liées à l'activité physique. Si vous ne l'avez pas déjà fait, déclarez l'autorisation BODY_SENSORS
dans le fichier manifeste de votre application. Demandez ensuite l'autorisation, comme indiqué dans cet extrait:
val permissionState = rememberPermissionState(
permission = Manifest.permission.BODY_SENSORS,
onPermissionResult = { granted -> /* do something */ }
)
[...]
if (permissionState.status.isGranted) {
// do something
} else {
permissionState.launchPermissionRequest()
}
Si vous testez votre application sur un appareil physique, la mise à jour des données devrait commencer.
À partir de Wear OS 4, les émulateurs affichent également automatiquement les données de test. Sur les versions précédentes, vous pouvez simuler le flux de données du capteur. Dans une fenêtre de terminal, exécutez la commande ADB suivante:
adb shell am broadcast \
-a "whs.USE_SYNTHETIC_PROVIDERS" \
com.google.android.wearable.healthservices
Pour voir les différentes valeurs de fréquence cardiaque, essayez de simuler différents exercices. Cette commande simule la marche:
adb shell am broadcast \
-a "whs.synthetic.user.START_WALKING" \
com.google.android.wearable.healthservices
Cette commande simule l'exécution:
adb shell am broadcast \
-a "whs.synthetic.user.START_RUNNING" \
com.google.android.wearable.healthservices
Pour arrêter de simuler les données, exécutez la commande suivante:
adb shell am broadcast -a \
"whs.USE_SENSOR_PROVIDERS" \
com.google.android.wearable.healthservices
Lire les données de fréquence cardiaque
Avec l'autorisation BODY_SENSORS
accordée, vous pouvez lire la fréquence cardiaque de l'utilisateur (heartRateMeasureFlow()
) dans HealthServicesManager
. Dans l'interface utilisateur de l'application Wear OS, la fréquence cardiaque actuelle s'affiche. Elle est mesurée par le capteur de l'accessoire connecté.
Dans votre ViewModel
, commencez à collecter des données à l'aide de l'objet de flux de fréquence cardiaque, comme indiqué dans l'extrait suivant:
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
}
}
Utilisez un objet composable semblable à celui-ci pour afficher les données actives dans l'interface utilisateur de votre application:
val heartRate by viewModel.hr
Text(
text = "Heart Rate: $heartRate",
style = MaterialTheme.typography.display1
)
Envoyer des données vers un appareil portable
Pour envoyer des données de santé et de remise en forme à un appareil portable, utilisez la classe DataClient
dans Services Santé. L'extrait de code suivant montre comment envoyer les données de fréquence cardiaque précédemment collectées par votre application:
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")
}
}
}
Recevoir les données sur le téléphone
Pour recevoir les données sur le téléphone, créez un 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
}
}
}
}
}
Une fois cette étape terminée, notez quelques détails intéressants:
- L'annotation
@AndroidEntryPoint
nous permet d'utiliser Hilt dans cette classe @Inject lateinit var heartRateMonitor: HeartRateMonitor
injectera en effet une dépendance dans cette classe.- La classe implémente
onDataChanged()
et reçoit une collection d'événements que vous pouvez analyser et utiliser.
La logique HeartRateMonitor
suivante vous permet d'envoyer les valeurs de fréquence cardiaque reçues à une autre partie du codebase de votre application:
class HeartRateMonitor {
private val datapoints = MutableSharedFlow<Int>(extraBufferCapacity = 10)
fun receive(): SharedFlow<Int> = datapoints.asSharedFlow()
fun send(hr: Int) {
datapoints.tryEmit(hr)
}
}
Un bus de données reçoit les événements de la méthode onDataChanged()
et les met à la disposition des observateurs de données à l'aide d'un SharedFlow
.
Le dernier bit est la déclaration de Service
dans l'application pour téléphone 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>
Afficher des données en temps réel sur un appareil portable
Dans la partie de votre application qui s'exécute sur un appareil portable, injectez HeartRateMonitor
dans le constructeur de votre modèle de vue. Cet objet HeartRateMonitor
observe les données de fréquence cardiaque et émet des mises à jour de l'interface utilisateur si nécessaire.