ผสานรวมโมดูล Wear OS

ปรับปรุงประสบการณ์ด้านสุขภาพและการออกกำลังกายของแอปด้วยการขยายแอปไปยังอุปกรณ์ที่สวมใส่ได้ อุปกรณ์ที่ขับเคลื่อนโดย Wear OS

เพิ่มโมดูล Wear OS

Android Studio มีวิซาร์ดที่ใช้งานง่ายสำหรับเพิ่มโมดูล Wear OS ลงในแอป ใน ไฟล์ > เมนู "โมดูลใหม่" ให้เลือก Wear OS ตามที่แสดงไว้ใน รูปภาพ:

วันที่

โปรดทราบว่า SDK ขั้นต่ำต้องเป็น API 30 ขึ้นไป เพื่อให้คุณใช้บริการด้านสุขภาพเวอร์ชันล่าสุดได้ บริการด้านสุขภาพ ทำให้ติดตามเมตริกและบันทึกข้อมูลได้ง่ายขึ้นด้วยการกำหนดค่าประสิทธิภาพการทำงาน เซ็นเซอร์โดยอัตโนมัติ

หลังจากที่ทำตามวิซาร์ดเสร็จแล้ว ให้ซิงค์โปรเจ็กต์ การเรียกใช้ต่อไปนี้ การกำหนดค่าจะปรากฏ:

วันที่

ซึ่งจะช่วยให้คุณเรียกใช้โมดูล Wear OS บนอุปกรณ์ที่สวมใส่ได้ คุณมี 2 ตัวเลือกดังนี้

• เรียกใช้บนโปรแกรมจำลอง

• เรียกใช้บนอุปกรณ์จริง

การเรียกใช้การกำหนดค่าทำให้แอปใช้งานได้กับโปรแกรมจำลอง Wear OS หรือ และแสดงคำว่า "สวัสดีโลก" ประสบการณ์การใช้งาน นี่คือการตั้งค่า UI ขั้นพื้นฐานโดยใช้ Compose สำหรับ Wear OS เพื่อเริ่มต้นใช้งานแอป

เพิ่มบริการด้านสุขภาพและฮิลต์

ผสานรวมไลบรารีต่อไปนี้ในโมดูล Wear OS

• บริการข้อมูลสุขภาพ: ทำให้เข้าถึงเซ็นเซอร์และข้อมูลในนาฬิกา สะดวกสบายและประหยัดพลังงานมากยิ่งขึ้น
• Hilt: ช่วยให้มีการแทรกทรัพยากร Dependency และการจัดการที่มีประสิทธิภาพ

สร้างผู้จัดการบริการข้อมูลสุขภาพ

เพื่อให้ใช้บริการข้อมูลสุขภาพสะดวกขึ้นเล็กน้อย และ API ที่ราบรื่นยิ่งขึ้น คุณจะสร้าง Wrapper ได้ดังนี้

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 เป็นทรัพยากร Dependency แบบ Hilt อื่นๆ ได้

HealthServicesManager ใหม่จะมีเมธอด heartRateMeasureFlow() ซึ่ง บันทึกเครื่องฟังเครื่องวัดการเต้นของหัวใจและส่งข้อมูลที่ได้รับ

เปิดใช้การอัปเดตข้อมูลในอุปกรณ์ที่สวมใส่ได้

การอัปเดตข้อมูลที่เกี่ยวข้องกับฟิตเนสต้องมีสิทธิ์ BODY_SENSORS หากคุณ โปรดประกาศสิทธิ์ BODY_SENSORS ใน ไฟล์ Manifest ของแอป จากนั้นขอสิทธิ์ ดังที่แสดงในข้อมูลโค้ดนี้

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 คุณจะอ่านอัตราการเต้นของหัวใจของผู้ใช้ได้ (heartRateMeasureFlow()) ในHealthServicesManager ในแอป Wear OS UI ค่าอัตราการเต้นของหัวใจปัจจุบันจะปรากฏขึ้น โดยมีการวัดโดยเซ็นเซอร์บน อุปกรณ์ที่สวมใส่ได้

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

ใช้ออบเจ็กต์ที่ประกอบได้ที่คล้ายกับรายการต่อไปนี้เพื่อแสดงข้อมูลสดใน UI ของแอป

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จริงๆ แล้ว แทรกทรัพยากร Dependency ในชั้นเรียนนี้
• คลาสนี้จะนำ 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เครื่องนี้ จะสังเกตข้อมูลอัตราการเต้นของหัวใจและแสดงการอัปเดต UI ตามที่จำเป็น