Zadbaj o zdrowie i kondycję swojej aplikacji, udostępniając ją na urządzenia do noszenia z Wear OS.
Dodaj moduł Wear OS
W Android Studio jest dostępny kreator, za pomocą którego możesz dodać moduł Wear OS do aplikacji. W menu Plik > Nowy moduł wybierz Wear OS, jak pokazano na ilustracji poniżej:
Pamiętaj, że minimalny pakiet SDK musi mieć API 30 lub wyższy, aby można było korzystać z najnowszej wersji usług zdrowotnych. Usługi zdrowotne ułatwiają śledzenie wskaźników i rejestrowanie danych dzięki automatycznej konfiguracji czujników zdrowia.
Po zakończeniu korzystania z kreatora zsynchronizuj projekt. Pojawi się taka konfiguracja Uruchom:
Pozwala to uruchomić moduł Wear OS na urządzeniu do noszenia. Dostępne są dwie opcje:
Uruchom na emulatorze.
Uruchamiaj na prawdziwym urządzeniu.
Uruchomienie konfiguracji spowoduje wdrożenie aplikacji w emulatorze lub na urządzeniu z Wear OS i wyświetlenie interfejsu „hello world”. To jest podstawowa konfiguracja interfejsu użytkownika aplikacji. To jest podstawowa konfiguracja interfejsu użytkownika aplikacji.
Dodaj usługi zdrowotne i hilt
Zintegruj te biblioteki z modułem Wear OS:
- Usługi zdrowotne: dostęp do czujników i danych na zegarku jest bardzo wygodny i energooszczędny.
- Osiągnięcie: umożliwia skuteczne wstrzykiwanie zależności i zarządzanie nimi.
Utwórz menedżera usług medycznych
Aby ułatwić korzystanie z usług zdrowotnych i udostępnić mniejszy i płynniejszy interfejs API, możesz utworzyć otokę w ten sposób:
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()
}
Gdy utworzysz moduł Hilt, który chcesz nim zarządzać, użyj następującego fragmentu kodu:
@Module
@InstallIn(SingletonComponent::class)
internal object DataModule {
@Provides
@Singleton
fun provideHealthServices(@ApplicationContext context: Context): HealthServicesManager = HealthServicesManager(context)
}
możesz wstrzykiwać HealthServicesManager
jako dowolną zależność Hilt.
Nowy HealthServicesManager
udostępnia metodę heartRateMeasureFlow()
, która rejestruje detektor pracy serca i emituje otrzymane dane.
Włącz aktualizacje danych na urządzeniach do noszenia
Aktualizacje danych związanych z aktywnością fizyczną wymagają uprawnienia BODY_SENSORS
. Jeśli nie zostało to jeszcze zrobione, zadeklaruj uprawnienie BODY_SENSORS
w pliku manifestu aplikacji. Następnie poproś o odpowiednie uprawnienia, tak jak w tym fragmencie:
val permissionState = rememberPermissionState(
permission = Manifest.permission.BODY_SENSORS,
onPermissionResult = { granted -> /* do something */ }
)
[...]
if (permissionState.status.isGranted) {
// do something
} else {
permissionState.launchPermissionRequest()
}
Jeśli testujesz aplikację na urządzeniu fizycznym, dane powinny zacząć się aktualizować.
Od Wear OS 4 emulatory automatycznie pokazują też dane testowe. W poprzednich wersjach możesz symulować strumień danych pochodzący z czujnika. W oknie terminala uruchom to polecenie ADB:
adb shell am broadcast \
-a "whs.USE_SYNTHETIC_PROVIDERS" \
com.google.android.wearable.healthservices
Aby zobaczyć różne wartości tętna, spróbuj przeprowadzić symulację różnych ćwiczeń. To polecenie symuluje spacer:
adb shell am broadcast \
-a "whs.synthetic.user.START_WALKING" \
com.google.android.wearable.healthservices
To polecenie symuluje uruchomienie:
adb shell am broadcast \
-a "whs.synthetic.user.START_RUNNING" \
com.google.android.wearable.healthservices
Aby zakończyć symulowanie danych, uruchom to polecenie:
adb shell am broadcast -a \
"whs.USE_SENSOR_PROVIDERS" \
com.google.android.wearable.healthservices
Odczytuj dane o tętnie
Masz uprawnienie BODY_SENSORS
, dzięki któremu możesz odczytywać tętno użytkownika (heartRateMeasureFlow()
) w aplikacji HealthServicesManager
. W interfejsie aplikacji Wear OS pojawi się aktualna wartość tętna mierzona przez czujnik w urządzeniu do noszenia.
W ViewModel
zacznij zbierać dane za pomocą obiektu przepływu tętna,
jak pokazano na tym fragmencie:
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
}
}
Aby wyświetlić bieżące dane w interfejsie aplikacji, użyj obiektu kompozycyjnego podobnego do tego:
val heartRate by viewModel.hr
Text(
text = "Heart Rate: $heartRate",
style = MaterialTheme.typography.display1
)
Wysyłanie danych na urządzenie przenośne
Aby wysyłać dane o zdrowiu i aktywności fizycznej na urządzenie przenośne, skorzystaj z klasy DataClient
w sekcji Usługi zdrowotne. Ten fragment kodu pokazuje, jak przesyłać dane o tętnie, które aplikacja zebrała wcześniej:
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")
}
}
}
Odbierz dane na telefonie
Aby odbierać dane na telefonie, utwórz 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
}
}
}
}
}
Po wykonaniu tego kroku zwróć uwagę na kilka interesujących szczegółów:
- Adnotacja
@AndroidEntryPoint
pozwala nam używać Hilt w tych zajęciach @Inject lateinit var heartRateMonitor: HeartRateMonitor
rzeczywiście wstrzykuje zależność w tej klasie- Klasa implementuje
onDataChanged()
i otrzymuje kolekcję zdarzeń, które możesz analizować i wykorzystywać
Ta logika HeartRateMonitor
umożliwia wysyłanie otrzymanych wartości tętna do innej części bazy kodu aplikacji:
class HeartRateMonitor {
private val datapoints = MutableSharedFlow<Int>(extraBufferCapacity = 10)
fun receive(): SharedFlow<Int> = datapoints.asSharedFlow()
fun send(hr: Int) {
datapoints.tryEmit(hr)
}
}
Magistrala danych odbiera zdarzenia z metody onDataChanged()
i udostępnia je obserwatorom danych za pomocą SharedFlow
.
Ostatnim elementem jest deklaracja Service
w aplikacji telefonicznej 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>
Pokazuj dane w czasie rzeczywistym na urządzeniu mobilnym
W części aplikacji, która działa na urządzeniu mobilnym, wstrzyknij HeartRateMonitor
w konstruktorze modelu widoku. Ten obiekt HeartRateMonitor
obserwuje dane o tętnie i w razie potrzeby aktualizuje interfejs.