refactor(wear): add typed command handlers

wear/src/androidTest/java/com/motionapps/sensorbox/emulator/WearToPhoneSyncSenderEmulatorTest.kt

@@ -3,6 +3,8 @@ package com.motionapps.sensorbox.emulator
 import android.content.Context
 import androidx.test.core.app.ApplicationProvider
 import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.motionapps.sensorbox.core.error.AppError
+import com.motionapps.sensorbox.core.error.AppResult
 import com.motionapps.sensorbox.domain.sync.SyncWearMeasurementsUseCase
 import com.motionapps.wearoslib.connectivity.GooglePlayWearConnectionRepository
 import com.motionapps.wearoslib.files.GooglePlayWearFileTransferClient
@@ -41,12 +43,16 @@ class WearToPhoneSyncSenderEmulatorTest {
     }
 
     private suspend fun syncWhenPhoneBecomesReachable(sync: SyncWearMeasurementsUseCase): Int {
-        var lastFailure: Throwable? = null
+        var lastFailure: AppError? = null
         repeat(MAX_ATTEMPTS) {
-            sync().onSuccess { return it }.onFailure { lastFailure = it }
+            when (val result = sync()) {
+                is AppResult.Success -> return result.value
+                is AppResult.Failure -> lastFailure = result.error
+            }
             delay(POLL_INTERVAL_MILLIS)
         }
-        throw AssertionError("Phone emulator did not become reachable", lastFailure)
+        val message = "Phone emulator did not become reachable: ${lastFailure?.code}"
+        throw AssertionError(message, lastFailure?.cause)
     }
 
     private companion object {

wear/src/main/AndroidManifest.xml

@@ -68,7 +68,7 @@
 
                 <data
                     android:host="*"
-                    android:pathPrefix="/sensorbox/v1/wear"
+                    android:pathPrefix="/sensorbox/v2/wear"
                     android:scheme="wear" />
             </intent-filter>
         </service>

wear/src/main/java/com/motionapps/sensorbox/WearSensorBoxApp.kt

@@ -1,13 +1,22 @@
 package com.motionapps.sensorbox
 
 import android.app.Application
-import com.motionapps.sensorbox.core.error.AppDiagnostics
+import com.motionapps.sensorbox.communication.WearRecordingSessionObserver
+import com.motionapps.sensorbox.core.error.FileDiagnostics
 import dagger.hilt.android.HiltAndroidApp
+import javax.inject.Inject
 
 @HiltAndroidApp
 class WearSensorBoxApp : Application() {
+    @Inject
+    lateinit var diagnostics: FileDiagnostics
+
+    @Inject
+    lateinit var recordingSessionObserver: WearRecordingSessionObserver
+
     override fun onCreate() {
         super.onCreate()
-        AppDiagnostics.install(this)
+        diagnostics.installUncaughtExceptionHandler()
+        recordingSessionObserver.start()
     }
 }

wear/src/main/java/com/motionapps/sensorbox/activities/MainActivity.kt

@@ -16,7 +16,7 @@ import androidx.core.net.toUri
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.wear.remote.interactions.RemoteActivityHelper
 import com.motionapps.sensorbox.R
-import com.motionapps.sensorbox.core.error.AppError
+import com.motionapps.sensorbox.core.error.AppErrorCode
 import com.motionapps.sensorbox.core.error.appResult
 import com.motionapps.sensorbox.presentation.dashboard.WearDashboardEffect
 import com.motionapps.sensorbox.presentation.dashboard.WearDashboardIntent
@@ -66,14 +66,14 @@ class MainActivity : ComponentActivity() {
     private fun handleEffect(effect: WearDashboardEffect) {
         when (effect) {
             is WearDashboardEffect.RequestPermissions -> appResult(
-                AppError.Kind.PERMISSION,
+                AppErrorCode.PERMISSION,
                 "Request Wear permissions",
             ) {
                 permissions.launch(effect.permissions.toTypedArray())
             }
 
             WearDashboardEffect.OpenPhone -> appResult(
-                AppError.Kind.EXTERNAL_ACTION,
+                AppErrorCode.EXTERNAL_ACTION,
                 "Open phone launcher",
             ) { startActivity(Intent(this, MoveToMain::class.java)) }
 
@@ -89,12 +89,12 @@ class MainActivity : ComponentActivity() {
         val intent = Intent(Intent.ACTION_VIEW)
             .addCategory(Intent.CATEGORY_BROWSABLE)
             .setData(url.toUri())
-        appResult(AppError.Kind.EXTERNAL_ACTION, "Request phone browser") {
+        appResult(AppErrorCode.EXTERNAL_ACTION, "Request phone browser") {
             RemoteActivityHelper(this).startRemoteActivity(intent)
         }.onSuccess { request ->
             request.addListener(
                 {
-                    appResult(AppError.Kind.EXTERNAL_ACTION, "Open phone browser") { request.get() }
+                    appResult(AppErrorCode.EXTERNAL_ACTION, "Open phone browser") { request.get() }
                         .fold(
                             onSuccess = {
                                 Toast.makeText(this, R.string.open_phone_browser, Toast.LENGTH_SHORT).show()

wear/src/main/java/com/motionapps/sensorbox/communication/MsgListener.kt

@@ -1,108 +1,24 @@
 package com.motionapps.sensorbox.communication
 
-import android.hardware.Sensor
 import com.google.android.gms.wearable.MessageEvent
 import com.google.android.gms.wearable.WearableListenerService
-import com.motionapps.sensorbox.core.error.AppError
-import com.motionapps.sensorbox.core.error.suspendAppResult
-import com.motionapps.sensorbox.core.error.suspendFlatMap
-import com.motionapps.sensorbox.core.error.withAppError
-import com.motionapps.sensorbox.core.preferences.AppPreferencesRepository
-import com.motionapps.sensorbox.domain.measurement.WearMeasurementControlUseCase
-import com.motionapps.sensorbox.domain.measurement.WearMeasurementPermissionUseCase
-import com.motionapps.sensorbox.domain.sensors.GetWearSensorsUseCase
-import com.motionapps.wearoslib.WearOsConstants.PHONE_APP_CAPABILITY
-import com.motionapps.wearoslib.WearOsConstants.PHONE_MESSAGE_PATH
-import com.motionapps.wearoslib.WearOsConstants.WEAR_MESSAGE_PATH
-import com.motionapps.wearoslib.connectivity.SendWearMessageUseCase
-import com.motionapps.wearoslib.protocol.WearCommand
-import com.motionapps.wearoslib.protocol.WearCommandCodec
-import com.motionapps.wearoslib.protocol.WearSensorInfo
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.cancel
-import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.launch
 import javax.inject.Inject
 
 @AndroidEntryPoint
 class MsgListener : WearableListenerService() {
     @Inject
-    lateinit var measurementControl: WearMeasurementControlUseCase
-
-    @Inject
-    lateinit var measurementPermissions: WearMeasurementPermissionUseCase
-
-    @Inject
-    lateinit var preferencesRepository: AppPreferencesRepository
-
-    @Inject
-    lateinit var getWearSensors: GetWearSensorsUseCase
-
-    @Inject
-    lateinit var sendWearMessage: SendWearMessageUseCase
+    lateinit var messageDispatcher: WearMessageDispatcher
 
     private val serviceScope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
 
     override fun onMessageReceived(messageEvent: MessageEvent) {
-        if (messageEvent.path != WEAR_MESSAGE_PATH) return
-        val command = WearCommandCodec.decode(messageEvent.data).fold(
-            onSuccess = { it },
-            onFailure = { return },
-        )
-        when (command) {
-            is WearCommand.StartMeasurement -> startMeasurement(command)
-            WearCommand.StopMeasurement -> measurementControl.stop()
-            WearCommand.RequestSensorList -> sendSensorList()
-            WearCommand.SyncMeasurements, WearCommand.LaunchPhone, is WearCommand.SensorList -> Unit
-        }
-    }
-
-    private fun sendSensorList() {
-        serviceScope.launch {
-            suspendAppResult(AppError.Kind.MEASUREMENT, "Read Wear sensors") {
-                val sensors = getWearSensors().map { sensor ->
-                    WearSensorInfo(sensor.type, sensor.name, sensor.vendor, sensor.isHeartRate)
-                }
-                sensors
-            }.suspendFlatMap { sensors ->
-                WearCommandCodec.encode(WearCommand.SensorList(sensors))
-            }.suspendFlatMap { payload ->
-                sendWearMessage(
-                    PHONE_APP_CAPABILITY,
-                    PHONE_MESSAGE_PATH,
-                    payload,
-                )
-            }.withAppError(AppError.Kind.CONNECTIVITY, "Send Wear sensor list")
-        }
-    }
-
-    private fun startMeasurement(command: WearCommand.StartMeasurement) {
-        serviceScope.launch {
-            suspendAppResult(AppError.Kind.PERMISSION, "Check remote measurement permissions") {
-                val includesHeartRate = Sensor.TYPE_HEART_RATE in command.sensorIds
-                measurementPermissions(command.includesGps, includesHeartRate)
-            }.suspendFlatMap { missingPermissions ->
-                if (missingPermissions.isNotEmpty()) {
-                    return@suspendFlatMap Result.failure(
-                        AppError(AppError.Kind.PERMISSION, "Start remote Wear measurement"),
-                    )
-                }
-                preferencesRepository.preferences.first().suspendFlatMap { preferences ->
-                    measurementControl.start(
-                        sensorIds = command.sensorIds.toSet(),
-                        includesGps = command.includesGps,
-                        preferences = preferences,
-                        folderName = command.folderName,
-                        startAtEpochMillis = command.startAtEpochMillis,
-                        durationMillis = command.durationMillis,
-                        measurementType = command.measurementType,
-                    )
-                }
-            }.withAppError(AppError.Kind.MEASUREMENT, "Handle remote measurement start")
-        }
+        serviceScope.launch { messageDispatcher.dispatch(messageEvent.path, messageEvent.data) }
     }
 
     override fun onDestroy() {

wear/src/main/java/com/motionapps/sensorbox/communication/WearAcknowledgementInbox.kt

@@ -0,0 +1,38 @@
+package com.motionapps.sensorbox.communication
+
+import com.motionapps.wearoslib.protocol.WearCommand
+import com.motionapps.wearoslib.protocol.WearSessionCommand
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.first
+import java.util.concurrent.ConcurrentHashMap
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+class WearAcknowledgementInbox @Inject constructor() {
+    private val acknowledgements = ConcurrentHashMap<Key, WearCommand.Acknowledgement>()
+    private val updates = MutableSharedFlow<WearCommand.Acknowledgement>(extraBufferCapacity = BUFFER_SIZE)
+
+    fun publish(acknowledgement: WearCommand.Acknowledgement) {
+        acknowledgements[acknowledgement.key()] = acknowledgement
+        updates.tryEmit(acknowledgement)
+    }
+
+    fun clear(sessionId: String, command: WearSessionCommand) {
+        acknowledgements.remove(Key(sessionId, command))
+    }
+
+    suspend fun await(sessionId: String, command: WearSessionCommand): WearCommand.Acknowledgement {
+        val key = Key(sessionId, command)
+        acknowledgements[key]?.let { return it }
+        return updates.first { acknowledgement -> acknowledgement.key() == key }
+    }
+
+    private fun WearCommand.Acknowledgement.key() = Key(sessionId, command)
+
+    private data class Key(val sessionId: String, val command: WearSessionCommand)
+
+    private companion object {
+        const val BUFFER_SIZE = 32
+    }
+}

wear/src/main/java/com/motionapps/sensorbox/communication/WearCommandEnvironment.kt

@@ -0,0 +1,43 @@
+package com.motionapps.sensorbox.communication
+
+import android.hardware.Sensor
+import com.motionapps.sensorbox.core.error.AppError
+import com.motionapps.sensorbox.core.error.AppErrorCode
+import com.motionapps.sensorbox.core.error.AppResult
+import com.motionapps.sensorbox.core.preferences.AppPreferences
+import com.motionapps.sensorbox.core.preferences.AppPreferencesRepository
+import com.motionapps.sensorbox.domain.measurement.WearMeasurementPermissionUseCase
+import com.motionapps.sensorbox.domain.sensors.GetWearSensorsUseCase
+import com.motionapps.wearoslib.protocol.WearRecordingRequest
+import com.motionapps.wearoslib.protocol.WearSensorInfo
+import kotlinx.coroutines.flow.first
+import javax.inject.Inject
+
+interface WearCommandEnvironment {
+    suspend fun prepare(request: WearRecordingRequest): AppResult<AppPreferences>
+
+    fun sensors(): List<WearSensorInfo>
+}
+
+class AndroidWearCommandEnvironment @Inject constructor(
+    private val measurementPermissions: WearMeasurementPermissionUseCase,
+    private val preferencesRepository: AppPreferencesRepository,
+    private val getWearSensors: GetWearSensorsUseCase,
+) : WearCommandEnvironment {
+    override suspend fun prepare(request: WearRecordingRequest): AppResult<AppPreferences> {
+        val availableSensorIds = getWearSensors().map { it.type }.toSet()
+        if (!availableSensorIds.containsAll(request.sensorIds)) {
+            return AppResult.failure(AppError(AppErrorCode.VALIDATION, "Validate Wear recording sensors"))
+        }
+        val includesHeartRate = Sensor.TYPE_HEART_RATE in request.sensorIds
+        val missingPermissions = measurementPermissions(request.includesGps, includesHeartRate)
+        if (missingPermissions.isNotEmpty()) {
+            return AppResult.failure(AppError(AppErrorCode.PERMISSION, "Prepare Wear recording permissions"))
+        }
+        return preferencesRepository.preferences.first()
+    }
+
+    override fun sensors(): List<WearSensorInfo> = getWearSensors().map { sensor ->
+        WearSensorInfo(sensor.type, sensor.name, sensor.vendor, sensor.isHeartRate)
+    }
+}