集成 Wear OS 模块

将应用扩展到穿戴式设备上，提升应用的健康与健身体验 搭载 Wear OS 的设备。

添加 Wear OS 模块

Android Studio 提供了一个方便的向导，供您向应用添加 Wear OS 模块。在 文件 >New Module 菜单中，选择 Wear OS，如下所示 图片：

<ph type="x-smartling-placeholder">
</ph> Android Studio 中的 Wear OS 模块向导 <ph type="x-smartling-placeholder">
</ph> 图 1：创建 Wear OS 模块

请务必注意，Minimum SDK 必须为 API 30 或更高 ，让您使用最新版本的健康服务。健康服务 通过配置健康状况，更轻松地跟踪指标和记录数据 传感器。

完成向导后，请同步您的项目。下面的 Run 配置：

<ph type="x-smartling-placeholder">
</ph> 显示 Wear OS 应用运行按钮的图片 <ph type="x-smartling-placeholder">
</ph> 图 2：新 Wear OS 模块的“Run”按钮

这样，您就可以在穿戴式设备上运行 Wear OS 模块。您有两种选择：

运行配置会将应用部署到 Wear OS 模拟器，或者 并显示“hello world”体验这是基本的界面设置，使用 Compose for Wear OS，了解如何开始使用您的应用。

添加健康服务和 Hilt

将以下库集成到您的 Wear OS 模块中：

  • 健康服务：允许手表上访问传感器和数据 非常方便，而且更省电
  • Hilt：支持有效的依赖项注入和管理。

创建健康服务管理器

为了更方便地使用健康服务， 和更流畅的 API，您可以创建如下所示的封装容器：

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()
}

创建 Hilt 模块以对其进行管理后，请使用以下代码段：

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

您可以将 HealthServicesManager 作为任何其他 Hilt 依赖项注入。

新的 HealthServicesManager 提供了一种 heartRateMeasureFlow() 方法， 为心脏监测器注册监听器并发出接收的数据。

在穿戴式设备上启用数据更新

与健身相关的数据更新需要 BODY_SENSORS 权限。如果您 请在您的应用中声明 BODY_SENSORS 权限， 应用的清单文件中然后，请求权限，如以下代码段所示：

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

[...]

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

如果您在实体设备上测试应用，数据应开始更新。

从 Wear OS 4 开始，模拟器也会自动显示测试数据。在上一个 您可以模拟来自传感器的数据流。在终端中 窗口中，运行以下 ADB 命令：

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

如要查看不同的心率值，请尝试模拟不同的锻炼。 此命令模拟步行：

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

此命令模拟运行：

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

如需停止模拟数据，请运行以下命令：

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

读取心率数据

授予 BODY_SENSORS 权限后，您可以读取用户的心率 HealthServicesManager 中的 (heartRateMeasureFlow())。在 Wear OS 应用的 界面中，显示了由设备上的传感器测量的当前心率值 。

在 ViewModel 中，开始使用心率流对象收集数据， 如以下代码段所示：

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
        }
    }

使用类似于以下内容的可组合项对象，在以下位置显示实时数据： 应用界面：

val heartRate by viewModel.hr

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

将数据发送到手持设备

如需将健康和健身数据发送到手持设备，请使用 DataClient 类。以下代码段展示了如何发送爱心 评估您的应用之前收集的数据：

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")
        }
    }
}

在手机上接收数据

要在手机上接收数据，请创建一个 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
                }
            }
        }
    }
}

完成此步骤后，您会注意到一些有趣的细节：

  • 借助 @AndroidEntryPoint 注解，我们可以在此类中使用 Hilt
  • @Inject lateinit var heartRateMonitor: HeartRateMonitor确实会 在此类中注入依赖项
  • 该类会实现 onDataChanged() 并接收一系列事件 您可以解析并使用

通过以下 HeartRateMonitor 逻辑，您可以发送接收的心率 值添加到应用代码库的其他部分：

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

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

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

数据总线接收来自 onDataChanged() 方法的事件，并发出这些事件 可供使用 SharedFlow 的数据观察器使用。

最后一位数是手机应用中 Service 的声明 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>

在手持设备上显示实时数据

在手持设备上运行的应用部分中，注入 HeartRateMonitor 传递到视图模型的构造函数中。这部HeartRateMonitor 对象观察心率数据并根据需要发出界面更新。