diff --git a/absdk-bridge/src/test/kotlin/com/flagship/abox/manager/absdk/bridge/AbsdkDeviceBridgeTest.kt b/absdk-bridge/src/test/kotlin/com/flagship/abox/manager/absdk/bridge/AbsdkDeviceBridgeTest.kt index 84002ea..55f63e8 100644 --- a/absdk-bridge/src/test/kotlin/com/flagship/abox/manager/absdk/bridge/AbsdkDeviceBridgeTest.kt +++ b/absdk-bridge/src/test/kotlin/com/flagship/abox/manager/absdk/bridge/AbsdkDeviceBridgeTest.kt @@ -17,10 +17,12 @@ import org.junit.Assert.assertEquals import org.junit.Assert.assertFalse import org.junit.Assert.assertTrue import org.junit.Test +import kotlin.reflect.KClass class AbsdkDeviceBridgeTest { private val profile = ProviderProfileId("abox") private val socket = DeviceName("socket-1") + private val irDevice = DeviceName("ir-room") @Test fun socketControlReturnsConfirmedStatus() = runTest { @@ -83,6 +85,69 @@ class AbsdkDeviceBridgeTest { assertTrue((offline as DomainResult.Failure).error is DomainError.DeviceOffline) } + @Test + fun infraredSendForwardsDeviceAndStableKey() = runTest { + val client = ScriptedAbsdkClient() + val bridge = authenticatedBridge(client) + assertEquals(DomainResult.Success(Unit), bridge.sendKey(profile, irDevice, "app_ir_power")) + assertEquals(listOf("login:demo", "ir-send:ir-room:app_ir_power"), client.calls) + } + + @Test + fun infraredLearnForwardsDeviceAndStableKey() = runTest { + val client = ScriptedAbsdkClient() + val bridge = authenticatedBridge(client) + assertEquals(DomainResult.Success(Unit), bridge.learnKey(profile, irDevice, "app_ir_power")) + assertEquals(listOf("login:demo", "ir-learn:ir-room:app_ir_power"), client.calls) + } + + @Test + fun infraredErrorCodesAreMappedCorrectlyForSendAndLearn() = runTest { + val errorMappings = mapOf>( + "20201" to DomainError.InvalidRequest::class, + "20202" to DomainError.InvalidRequest::class, + "20203" to DomainError.DeviceNotFound::class, + "20204" to DomainError.OperationFailed::class, + "20205" to DomainError.OperationFailed::class, + "20206" to DomainError.DeviceOffline::class, + ) + + for ((code, expectedClass) in errorMappings) { + val client = ScriptedAbsdkClient().apply { + sendResponse = ScriptedAbsdkClient.failure(code, "message for $code") + learnResponse = ScriptedAbsdkClient.failure(code, "message for $code") + } + val bridge = authenticatedBridge(client) + + val sendResult = bridge.sendKey(profile, irDevice, "key1") + assertTrue("Expected send error class $expectedClass for code $code", sendResult is DomainResult.Failure) + assertEquals(expectedClass, (sendResult as DomainResult.Failure).error::class) + assertEquals(code, sendResult.error.externalCode) + + val learnResult = bridge.learnKey(profile, irDevice, "key1") + assertTrue("Expected learn error class $expectedClass for code $code", learnResult is DomainResult.Failure) + assertEquals(expectedClass, (learnResult as DomainResult.Failure).error::class) + assertEquals(code, learnResult.error.externalCode) + } + } + + @Test + fun infraredNullResponseReturnsUnknownDomainError() = runTest { + val client = ScriptedAbsdkClient().apply { + sendResponse = null + learnResponse = null + } + val bridge = authenticatedBridge(client) + + val sendResult = bridge.sendKey(profile, irDevice, "key1") + assertTrue(sendResult is DomainResult.Failure) + assertTrue((sendResult as DomainResult.Failure).error is DomainError.Unknown) + + val learnResult = bridge.learnKey(profile, irDevice, "key1") + assertTrue(learnResult is DomainResult.Failure) + assertTrue((learnResult as DomainResult.Failure).error is DomainError.Unknown) + } + @Test fun infraredCallsAndPartialDownloadResultsAreMapped() = runTest { val codeOne = InfraredCode(DeviceName("ir-1"), "power", "code-1") diff --git a/absdk-bridge/src/test/kotlin/com/flagship/abox/manager/absdk/bridge/AbsdkSerializationTest.kt b/absdk-bridge/src/test/kotlin/com/flagship/abox/manager/absdk/bridge/AbsdkSerializationTest.kt index fe68163..1663410 100644 --- a/absdk-bridge/src/test/kotlin/com/flagship/abox/manager/absdk/bridge/AbsdkSerializationTest.kt +++ b/absdk-bridge/src/test/kotlin/com/flagship/abox/manager/absdk/bridge/AbsdkSerializationTest.kt @@ -48,4 +48,38 @@ class AbsdkSerializationTest { assertEquals(1, client.maxConcurrentCalls.get()) } } + + @Test + fun concurrentInfraredAndOtherDeviceCallsDoNotOverlap() = runBlocking { + withTimeout(5_000) { + val profile = ProviderProfileId("abox") + val client = ScriptedAbsdkClient().apply { + socketStatusResponses = ArrayDeque( + listOf(ScriptedAbsdkClient.success(mapOf("status" to "1"))), + ) + } + val bridge = AbsdkBridge(client, Dispatchers.IO) + bridge.login(profile, LoginCredentials(Username("demo"), Password("secret"))) + + client.onCall = { + if (client.calls.last().startsWith("ir-learn") || client.calls.last().startsWith("temperature")) { + Thread.sleep(75) + } + } + + val irCall = async { + bridge.learnKey(profile, DeviceName("ir-1"), "app_ir_power") + } + val tempCall = async { + bridge.getReading(profile, DeviceName("th-1")) + } + + delay(10) + + irCall.await() + tempCall.await() + + assertEquals(1, client.maxConcurrentCalls.get()) + } + } } diff --git a/android/app/build.gradle.kts b/android/app/build.gradle.kts index f8843f4..08eb8de 100644 --- a/android/app/build.gradle.kts +++ b/android/app/build.gradle.kts @@ -64,6 +64,7 @@ dependencies { implementation(project(":domain")) implementation(project(":android:core:designsystem")) implementation(project(":android:core:session")) + implementation(project(":android:feature:infrared")) implementation(project(":absdk-bridge")) implementation(project(":runtime:simulation")) debugImplementation(project(":testing:fakes")) diff --git a/android/app/src/main/kotlin/com/flagship/abox/manager/ui/ABoxManagerApp.kt b/android/app/src/main/kotlin/com/flagship/abox/manager/ui/ABoxManagerApp.kt index 9a2dc11..5b6998e 100644 --- a/android/app/src/main/kotlin/com/flagship/abox/manager/ui/ABoxManagerApp.kt +++ b/android/app/src/main/kotlin/com/flagship/abox/manager/ui/ABoxManagerApp.kt @@ -11,9 +11,20 @@ import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier import androidx.hilt.navigation.compose.hiltViewModel import androidx.lifecycle.compose.collectAsStateWithLifecycle +import androidx.navigation.NavType +import androidx.navigation.compose.NavHost +import androidx.navigation.compose.composable +import androidx.navigation.compose.rememberNavController +import androidx.navigation.navArgument import com.flagship.abox.manager.designsystem.ABoxLoadingIndicator import com.flagship.abox.manager.designsystem.ABoxSurface import com.flagship.abox.manager.designsystem.ABoxTheme +import com.flagship.abox.manager.domain.ProviderProfile +import com.flagship.abox.manager.domain.Username +import com.flagship.abox.manager.infrared.hub.InfraredHubRoute +import com.flagship.abox.manager.infrared.panel.RemotePanelRoute +import com.flagship.abox.manager.infrared.ui.InfraredControlRoute +import com.flagship.abox.manager.ui.devicecontrollist.DeviceListScreen import com.flagship.abox.manager.ui.login.LoginRoute import com.flagship.abox.manager.ui.login.LoginViewModel import com.flagship.abox.manager.ui.provider.ProviderSelectionRoute @@ -57,18 +68,93 @@ fun ABoxManagerApp( onSwitchProvider = sessionActionsViewModel::switchProvider, viewModel = loginViewModel, ) - is AppSessionUiState.Authenticated -> MainAppShell( - userName = state.username.value, - providerName = state.profile.displayName, - onLogout = sessionActionsViewModel::logout, + is AppSessionUiState.Authenticated -> AuthenticatedNavHost( + username = state.username, + profile = state.profile, actionInProgress = actionState.inProgress, errorMessage = actionState.errorMessage, + onLogout = sessionActionsViewModel::logout, ) } } } } +@Composable +private fun AuthenticatedNavHost( + username: Username, + profile: ProviderProfile, + actionInProgress: Boolean, + errorMessage: String?, + onLogout: () -> Unit, +) { + val navController = rememberNavController() + NavHost( + navController = navController, + startDestination = "home", + ) { + composable("home") { + MainAppShell( + userName = username.value, + providerName = profile.displayName, + onLogout = onLogout, + actionInProgress = actionInProgress, + errorMessage = errorMessage, + devicesSlot = { + val encodedProfileId = android.net.Uri.encode(profile.id.value) + DeviceListScreen( + onInfraredClick = { + navController.navigate("infrared_hub/$encodedProfileId") + }, + ) + }, + ) + } + composable( + route = "infrared_hub/{profileId}", + arguments = listOf( + navArgument("profileId") { type = NavType.StringType }, + ), + ) { + val encodedProfileId = android.net.Uri.encode(profile.id.value) + InfraredHubRoute( + onBack = { navController.popBackStack() }, + onOpenRemote = { remoteId -> + val encodedRemoteId = android.net.Uri.encode(remoteId) + navController.navigate("infrared_panel/$encodedProfileId/$encodedRemoteId") + }, + onOpenSettings = { + navController.navigate("infrared_settings/$encodedProfileId") + }, + onSessionInvalid = onLogout, + ) + } + composable( + route = "infrared_panel/{profileId}/{remoteId}", + arguments = listOf( + navArgument("profileId") { type = NavType.StringType }, + navArgument("remoteId") { type = NavType.StringType }, + ), + ) { + RemotePanelRoute( + onBack = { navController.popBackStack() }, + onSessionInvalid = onLogout, + ) + } + composable( + route = "infrared_settings/{profileId}", + arguments = listOf( + navArgument("profileId") { type = NavType.StringType }, + ), + ) { + InfraredControlRoute( + onBack = { navController.popBackStack() }, + onSessionInvalid = onLogout, + ) + } + } +} + private fun AppSessionUiState.screenKey(): String = when (this) { AppSessionUiState.Loading -> "loading" AppSessionUiState.ProviderSelection -> "providers" diff --git a/android/app/src/main/res/values-zh-rCN/strings.xml b/android/app/src/main/res/values-zh-rCN/strings.xml index f09dfa4..4fe53de 100644 --- a/android/app/src/main/res/values-zh-rCN/strings.xml +++ b/android/app/src/main/res/values-zh-rCN/strings.xml @@ -23,7 +23,6 @@ 切换提供方 已连接到 %1$s 登录后入口已经就绪，设备导航将由对应模块负责人接入。 - 设备 情景 @@ -52,4 +51,6 @@ 进入温湿度状态相关功能。 红外控制器 进入红外控制器相关功能。 + 红外控制 + ABox 会话未认证，请先登录。 diff --git a/android/app/src/main/res/values/strings.xml b/android/app/src/main/res/values/strings.xml index f9455e4..93a151f 100644 --- a/android/app/src/main/res/values/strings.xml +++ b/android/app/src/main/res/values/strings.xml @@ -23,7 +23,6 @@ Switch provider Connected to %1$s The authenticated route is ready. Device navigation will be added by its module owner. - Devices Scenes @@ -52,4 +51,6 @@ View temperature and humidity status. Infrared Controller Access infrared controller features. + Infrared Control + ABox session is not authenticated. Please log in first. diff --git a/android/feature/infrared/build.gradle.kts b/android/feature/infrared/build.gradle.kts new file mode 100644 index 0000000..d088f6b --- /dev/null +++ b/android/feature/infrared/build.gradle.kts @@ -0,0 +1,75 @@ +plugins { + alias(libs.plugins.android.library) + alias(libs.plugins.kotlin.android) + alias(libs.plugins.kotlin.kapt) + alias(libs.plugins.hilt.android) +} + +android { + namespace = "com.flagship.abox.manager.infrared" + compileSdk = 34 + + defaultConfig { + minSdk = 26 + testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner" + } + + buildFeatures { + compose = true + } + + composeOptions { + kotlinCompilerExtensionVersion = libs.versions.composeCompiler.get() + } + + compileOptions { + sourceCompatibility = JavaVersion.VERSION_17 + targetCompatibility = JavaVersion.VERSION_17 + } + + kotlinOptions { + jvmTarget = "17" + } +} + +kapt { + correctErrorTypes = true + arguments { + arg("room.schemaLocation", "$projectDir/schemas") + } +} + +dependencies { + implementation(project(":domain")) + implementation(project(":android:core:designsystem")) + + implementation(libs.room.runtime) + implementation(libs.room.ktx) + kapt(libs.room.compiler) + + implementation(libs.androidx.lifecycle.viewmodel.ktx) + implementation(libs.androidx.lifecycle.runtime.compose) + implementation(libs.androidx.navigation.compose) + implementation(libs.androidx.hilt.navigation.compose) + implementation(libs.hilt.android) + kapt(libs.hilt.compiler) + + implementation(platform(libs.compose.bom)) + implementation(libs.compose.ui) + implementation(libs.compose.ui.tooling.preview) + implementation(libs.compose.material3) + + testImplementation(libs.junit) + testImplementation(libs.kotlinx.coroutines.test) + testImplementation(project(":testing:fakes")) + + androidTestImplementation(platform(libs.compose.bom)) + androidTestImplementation(libs.androidx.junit) + androidTestImplementation(libs.espresso.core) + androidTestImplementation(libs.compose.ui.test.junit4) + androidTestImplementation(libs.room.testing) + androidTestImplementation(libs.kotlinx.coroutines.test) + + debugImplementation(libs.compose.ui.tooling) + debugImplementation(libs.compose.ui.test.manifest) +} diff --git a/android/feature/infrared/schemas/com.flagship.abox.manager.infrared.data.local.InfraredDatabase/1.json b/android/feature/infrared/schemas/com.flagship.abox.manager.infrared.data.local.InfraredDatabase/1.json new file mode 100644 index 0000000..c9bb24d --- /dev/null +++ b/android/feature/infrared/schemas/com.flagship.abox.manager.infrared.data.local.InfraredDatabase/1.json @@ -0,0 +1,136 @@ +{ + "formatVersion": 1, + "database": { + "version": 1, + "identityHash": "be673e12eb4c5275aaa6ef6fc189a861", + "entities": [ + { + "tableName": "infrared_keys", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `profileId` TEXT NOT NULL, `deviceName` TEXT NOT NULL, `displayName` TEXT NOT NULL, `sdkKey` TEXT NOT NULL, `status` TEXT NOT NULL, `lastErrorCode` TEXT, `lastErrorDetail` TEXT, `createdAtEpochMillis` INTEGER NOT NULL, `updatedAtEpochMillis` INTEGER NOT NULL, PRIMARY KEY(`id`))", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "profileId", + "columnName": "profileId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "deviceName", + "columnName": "deviceName", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "displayName", + "columnName": "displayName", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "sdkKey", + "columnName": "sdkKey", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "status", + "columnName": "status", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "lastErrorCode", + "columnName": "lastErrorCode", + "affinity": "TEXT", + "notNull": false + }, + { + "fieldPath": "lastErrorDetail", + "columnName": "lastErrorDetail", + "affinity": "TEXT", + "notNull": false + }, + { + "fieldPath": "createdAtEpochMillis", + "columnName": "createdAtEpochMillis", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAtEpochMillis", + "columnName": "updatedAtEpochMillis", + "affinity": "INTEGER", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "id" + ] + }, + "indices": [ + { + "name": "index_infrared_keys_profileId_deviceName", + "unique": false, + "columnNames": [ + "profileId", + "deviceName" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_infrared_keys_profileId_deviceName` ON `${TABLE_NAME}` (`profileId`, `deviceName`)" + }, + { + "name": "index_infrared_keys_profileId_deviceName_sdkKey", + "unique": true, + "columnNames": [ + "profileId", + "deviceName", + "sdkKey" + ], + "orders": [], + "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_infrared_keys_profileId_deviceName_sdkKey` ON `${TABLE_NAME}` (`profileId`, `deviceName`, `sdkKey`)" + } + ], + "foreignKeys": [] + }, + { + "tableName": "infrared_device_configuration", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`profileId` TEXT NOT NULL, `deviceName` TEXT NOT NULL, PRIMARY KEY(`profileId`))", + "fields": [ + { + "fieldPath": "profileId", + "columnName": "profileId", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "deviceName", + "columnName": "deviceName", + "affinity": "TEXT", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "profileId" + ] + }, + "indices": [], + "foreignKeys": [] + } + ], + "views": [], + "setupQueries": [ + "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)", + "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, 'be673e12eb4c5275aaa6ef6fc189a861')" + ] + } +} \ No newline at end of file diff --git a/android/feature/infrared/src/androidTest/kotlin/com/flagship/abox/manager/infrared/data/local/RoomInfraredKeyRepositoryTest.kt b/android/feature/infrared/src/androidTest/kotlin/com/flagship/abox/manager/infrared/data/local/RoomInfraredKeyRepositoryTest.kt new file mode 100644 index 0000000..97efdde --- /dev/null +++ b/android/feature/infrared/src/androidTest/kotlin/com/flagship/abox/manager/infrared/data/local/RoomInfraredKeyRepositoryTest.kt @@ -0,0 +1,194 @@ +package com.flagship.abox.manager.infrared.data.local + +import android.content.Context +import androidx.room.Room +import androidx.test.core.app.ApplicationProvider +import androidx.test.ext.junit.runners.AndroidJUnit4 +import com.flagship.abox.manager.domain.DeviceName +import com.flagship.abox.manager.domain.DomainResult +import com.flagship.abox.manager.domain.ProviderProfileId +import com.flagship.abox.manager.domain.infrared.INTERRUPTED_LEARNING_ERROR_DETAIL +import com.flagship.abox.manager.domain.infrared.InfraredKeyId +import com.flagship.abox.manager.domain.infrared.InfraredKeyRef +import com.flagship.abox.manager.domain.infrared.InfraredKeyStatus +import com.flagship.abox.manager.domain.infrared.SavedInfraredKey +import kotlinx.coroutines.flow.first +import kotlinx.coroutines.test.runTest +import org.junit.After +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNull +import org.junit.Assert.assertTrue +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith + +@RunWith(AndroidJUnit4::class) +class RoomInfraredKeyRepositoryTest { + + private lateinit var database: InfraredDatabase + private lateinit var repository: RoomInfraredKeyRepository + + @Before + fun setup() { + val context = ApplicationProvider.getApplicationContext() + database = Room.inMemoryDatabaseBuilder(context, InfraredDatabase::class.java) + .allowMainThreadQueries() + .build() + repository = RoomInfraredKeyRepository(database.infraredDao()) + } + + @After + fun teardown() { + database.close() + } + + @Test + fun observesOnlyRequestedProfileAndDevice() = runTest { + repository.insert(testKey(profile = "one", device = "ir-1", id = "a", sdkKey = "key_a")) + repository.insert(testKey(profile = "one", device = "ir-2", id = "b", sdkKey = "key_b")) + repository.insert(testKey(profile = "two", device = "ir-1", id = "c", sdkKey = "key_c")) + + val result = repository.observeKeys( + ProviderProfileId("one"), + DeviceName("ir-1"), + ).first() as DomainResult.Success + + assertEquals(listOf(InfraredKeyId("a")), result.value.map { it.id }) + } + + @Test + fun rejectsDuplicateSdkBinding() = runTest { + val first = repository.insert(testKey(id = "a", sdkKey = "app_ir_power")) + assertTrue(first is DomainResult.Success) + + val duplicate = repository.insert(testKey(id = "b", sdkKey = "app_ir_power")) + assertTrue(duplicate is DomainResult.Failure) + } + + @Test + fun transitionsStatusCorrectly() = runTest { + val key = testKey(id = "a", status = InfraredKeyStatus.LEARNING) + repository.insert(key) + + val transitionResult = repository.transitionStatus( + ref = InfraredKeyRef(key.profileId, key.id), + expectedStatuses = setOf(InfraredKeyStatus.LEARNING), + targetStatus = InfraredKeyStatus.READY, + lastErrorCode = null, + lastErrorDetail = null, + updatedAtEpochMillis = 2_000L, + ) + assertTrue(transitionResult is DomainResult.Success) + + val fetched = (repository.getKey(InfraredKeyRef(key.profileId, key.id)) as DomainResult.Success).value!! + assertEquals(InfraredKeyStatus.READY, fetched.status) + assertEquals(2_000L, fetched.updatedAtEpochMillis) + } + + @Test + fun renamesKeyWithoutChangingSdkKey() = runTest { + val key = testKey(id = "a", displayName = "Old Name", sdkKey = "app_ir_power") + repository.insert(key) + + val renameResult = repository.rename( + ref = InfraredKeyRef(key.profileId, key.id), + displayName = "New Name", + updatedAtEpochMillis = 3_000L, + ) + assertTrue(renameResult is DomainResult.Success) + + val fetched = (repository.getKey(InfraredKeyRef(key.profileId, key.id)) as DomainResult.Success).value!! + assertEquals("New Name", fetched.displayName) + assertEquals("app_ir_power", fetched.sdkKey) + assertEquals(3_000L, fetched.updatedAtEpochMillis) + } + + @Test + fun deleteRejectsLearningKeyAndRemovesReadyKey() = runTest { + val learningKey = testKey(id = "learning", status = InfraredKeyStatus.LEARNING) + val readyKey = testKey(id = "ready", sdkKey = "ready_sdk_key", status = InfraredKeyStatus.READY) + repository.insert(learningKey) + repository.insert(readyKey) + + val deleteLearning = repository.deleteIfNotLearning(InfraredKeyRef(learningKey.profileId, learningKey.id)) + assertTrue(deleteLearning is DomainResult.Failure) + + val deleteReady = repository.deleteIfNotLearning(InfraredKeyRef(readyKey.profileId, readyKey.id)) + assertTrue(deleteReady is DomainResult.Success) + + val fetchedReady = (repository.getKey(InfraredKeyRef(readyKey.profileId, readyKey.id)) as DomainResult.Success).value + assertNull(fetchedReady) + } + + @Test + fun failsInterruptedLearningKeys() = runTest { + repository.insert(testKey(id = "k1", sdkKey = "k1", status = InfraredKeyStatus.LEARNING)) + repository.insert(testKey(id = "k2", sdkKey = "k2", status = InfraredKeyStatus.LEARNING)) + repository.insert(testKey(id = "k3", sdkKey = "k3", status = InfraredKeyStatus.READY)) + + val countResult = repository.failInterruptedLearning(ProviderProfileId("profile1"), 5_000L) as DomainResult.Success + assertEquals(2, countResult.value) + + val k1 = (repository.getKey(InfraredKeyRef(ProviderProfileId("profile1"), InfraredKeyId("k1"))) as DomainResult.Success).value!! + assertEquals(InfraredKeyStatus.FAILED, k1.status) + assertEquals(INTERRUPTED_LEARNING_ERROR_DETAIL, k1.lastErrorDetail) + assertNull(k1.lastErrorCode) + assertEquals(5_000L, k1.updatedAtEpochMillis) + + val k3 = (repository.getKey(InfraredKeyRef(ProviderProfileId("profile1"), InfraredKeyId("k3"))) as DomainResult.Success).value!! + assertEquals(InfraredKeyStatus.READY, k3.status) + } + + @Test + fun failInterruptedLearningRespectsCutoffEpochMillis() = runTest { + repository.insert(testKey(id = "old_k", sdkKey = "old_k", status = InfraredKeyStatus.LEARNING).copy(createdAtEpochMillis = 100L)) + repository.insert(testKey(id = "new_k", sdkKey = "new_k", status = InfraredKeyStatus.LEARNING).copy(createdAtEpochMillis = 200L)) + + val countResult = repository.failInterruptedLearning( + profileId = ProviderProfileId("profile1"), + cutoffEpochMillis = 150L, + updatedAtEpochMillis = 150L, + ) as DomainResult.Success + assertEquals(1, countResult.value) + + val oldK = (repository.getKey(InfraredKeyRef(ProviderProfileId("profile1"), InfraredKeyId("old_k"))) as DomainResult.Success).value!! + assertEquals(InfraredKeyStatus.FAILED, oldK.status) + + val newK = (repository.getKey(InfraredKeyRef(ProviderProfileId("profile1"), InfraredKeyId("new_k"))) as DomainResult.Success).value!! + assertEquals(InfraredKeyStatus.LEARNING, newK.status) + } + + @Test + fun persistsAndObservesDeviceName() = runTest { + val initial = repository.observeDeviceName(ProviderProfileId("profile1")).first() as DomainResult.Success + assertNull(initial.value) + + val setResult = repository.setDeviceName(ProviderProfileId("profile1"), DeviceName("ir_main")) + assertTrue(setResult is DomainResult.Success) + + val observed = repository.observeDeviceName(ProviderProfileId("profile1")).first() as DomainResult.Success + assertEquals(DeviceName("ir_main"), observed.value) + } + + private fun testKey( + profile: String = "profile1", + device: String = "ir-1", + id: String = "key-1", + displayName: String = "Power", + sdkKey: String = "app_ir_key1", + status: InfraredKeyStatus = InfraredKeyStatus.LEARNING, + ): SavedInfraredKey { + return SavedInfraredKey( + id = InfraredKeyId(id), + profileId = ProviderProfileId(profile), + deviceName = DeviceName(device), + displayName = displayName, + sdkKey = sdkKey, + status = status, + lastErrorCode = null, + lastErrorDetail = null, + createdAtEpochMillis = 1_000L, + updatedAtEpochMillis = 1_000L, + ) + } +} diff --git a/android/feature/infrared/src/androidTest/kotlin/com/flagship/abox/manager/infrared/remote/InfraredRemoteScreenTest.kt b/android/feature/infrared/src/androidTest/kotlin/com/flagship/abox/manager/infrared/remote/InfraredRemoteScreenTest.kt new file mode 100644 index 0000000..a071166 --- /dev/null +++ b/android/feature/infrared/src/androidTest/kotlin/com/flagship/abox/manager/infrared/remote/InfraredRemoteScreenTest.kt @@ -0,0 +1,49 @@ +package com.flagship.abox.manager.infrared.remote + +import androidx.compose.ui.test.assertIsDisplayed +import androidx.compose.ui.test.junit4.createComposeRule +import androidx.compose.ui.test.onNodeWithTag +import androidx.compose.ui.test.performClick +import androidx.test.ext.junit.runners.AndroidJUnit4 +import com.flagship.abox.manager.domain.DeviceName +import com.flagship.abox.manager.infrared.remote.ui.InfraredRemoteScreen +import org.junit.Assert.assertEquals +import org.junit.Rule +import org.junit.Test +import org.junit.runner.RunWith + +@RunWith(AndroidJUnit4::class) +class InfraredRemoteScreenTest { + + @get:Rule + val composeTestRule = createComposeRule() + + @Test + fun rendersAcPanelAndTvPanelCorrectly() { + val state = InfraredRemoteUiState( + selectedScene = RemoteScene.AIR_CONDITIONER, + savedDeviceName = DeviceName("ir-1"), + ) + var clickedSpec: RemoteButtonSpec? = null + var settingsClicked = false + + composeTestRule.setContent { + InfraredRemoteScreen( + state = state, + onBack = {}, + onOpenSettings = { settingsClicked = true }, + onSessionInvalid = {}, + onSceneSelected = {}, + onToggleLearningMode = {}, + onButtonClick = { clickedSpec = it }, + onMessageShown = {}, + ) + } + + composeTestRule.onNodeWithTag("remote_button_AC_POWER").assertIsDisplayed().performClick() + assertEquals("AC_POWER", clickedSpec?.id) + + composeTestRule.onNodeWithTag("remote_settings_button").assertIsDisplayed().performClick() + assertTrue(settingsClicked) + } +} diff --git a/android/feature/infrared/src/androidTest/kotlin/com/flagship/abox/manager/infrared/ui/InfraredControlScreenTest.kt b/android/feature/infrared/src/androidTest/kotlin/com/flagship/abox/manager/infrared/ui/InfraredControlScreenTest.kt new file mode 100644 index 0000000..99699b1 --- /dev/null +++ b/android/feature/infrared/src/androidTest/kotlin/com/flagship/abox/manager/infrared/ui/InfraredControlScreenTest.kt @@ -0,0 +1,77 @@ +package com.flagship.abox.manager.infrared.ui + +import androidx.compose.ui.test.assertIsDisplayed +import androidx.compose.ui.test.junit4.createComposeRule +import androidx.compose.ui.test.onNodeWithTag +import androidx.compose.ui.test.performClick +import androidx.compose.ui.test.performTextInput +import androidx.test.ext.junit.runners.AndroidJUnit4 +import com.flagship.abox.manager.domain.DeviceName +import com.flagship.abox.manager.domain.ProviderProfileId +import com.flagship.abox.manager.domain.ProviderType +import com.flagship.abox.manager.domain.infrared.InfraredKeyId +import com.flagship.abox.manager.domain.infrared.InfraredKeyStatus +import com.flagship.abox.manager.domain.infrared.SavedInfraredKey +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Rule +import org.junit.Test +import org.junit.runner.RunWith + +@RunWith(AndroidJUnit4::class) +class InfraredControlScreenTest { + + @get:Rule + val composeTestRule = createComposeRule() + + @Test + fun rendersControlScreenAndTriggersKeyOperations() { + val testKey = SavedInfraredKey( + id = InfraredKeyId("k1"), + profileId = ProviderProfileId("profile1"), + deviceName = DeviceName("ir-1"), + displayName = "Power", + sdkKey = "1", + status = InfraredKeyStatus.READY, + lastErrorCode = null, + lastErrorDetail = null, + createdAtEpochMillis = 100L, + updatedAtEpochMillis = 100L, + ) + val state = InfraredControlUiState( + profileId = ProviderProfileId("profile1"), + providerType = ProviderType.LOCAL_EXPERIENCE, + savedDeviceName = DeviceName("ir-1"), + keys = listOf(testKey), + loading = false, + ) + + var sendClicked = false + var deleteClicked = false + + composeTestRule.setContent { + InfraredControlScreen( + state = state, + onBack = {}, + onSessionInvalid = {}, + onDeviceNameChanged = {}, + onSaveDeviceName = {}, + onLearn = { _, _ -> }, + onRetry = {}, + onSend = { sendClicked = true }, + onRename = { _, _ -> }, + onDelete = { deleteClicked = true }, + onMessageShown = {}, + nextSlot = 2, + ) + } + + composeTestRule.onNodeWithTag("infrared_key_k1").assertIsDisplayed() + composeTestRule.onNodeWithTag("infrared_send_k1").assertIsDisplayed().performClick() + assertTrue(sendClicked) + + composeTestRule.onNodeWithTag("infrared_delete_btn_k1").assertIsDisplayed().performClick() + composeTestRule.onNodeWithTag("infrared_delete_confirm").assertIsDisplayed().performClick() + assertTrue(deleteClicked) + } +} diff --git a/android/feature/infrared/src/main/AndroidManifest.xml b/android/feature/infrared/src/main/AndroidManifest.xml new file mode 100644 index 0000000..9a40236 --- /dev/null +++ b/android/feature/infrared/src/main/AndroidManifest.xml @@ -0,0 +1,3 @@ + + + diff --git a/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/application/InfraredLearningCoordinator.kt b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/application/InfraredLearningCoordinator.kt new file mode 100644 index 0000000..41c7e01 --- /dev/null +++ b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/application/InfraredLearningCoordinator.kt @@ -0,0 +1,72 @@ +package com.flagship.abox.manager.infrared.application + +import com.flagship.abox.manager.domain.DeviceName +import com.flagship.abox.manager.domain.DomainResult +import com.flagship.abox.manager.domain.ProviderProfileId +import com.flagship.abox.manager.domain.infrared.InfraredKeyId +import com.flagship.abox.manager.domain.infrared.InfraredKeyRef +import com.flagship.abox.manager.domain.infrared.InfraredKeyRepository +import com.flagship.abox.manager.domain.infrared.LearnInfraredKey +import com.flagship.abox.manager.domain.infrared.RelearnInfraredKey +import com.flagship.abox.manager.domain.infrared.RetryInfraredKeyLearning +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Deferred +import kotlinx.coroutines.Job +import kotlinx.coroutines.NonCancellable +import kotlinx.coroutines.async +import kotlinx.coroutines.launch +import kotlinx.coroutines.sync.Mutex +import kotlinx.coroutines.sync.withLock + +class InfraredLearningCoordinator( + private val learnInfraredKey: LearnInfraredKey, + private val retryInfraredKeyLearning: RetryInfraredKeyLearning, + private val relearnInfraredKey: RelearnInfraredKey, + private val keyRepository: InfraredKeyRepository, + private val externalScope: CoroutineScope, +) { + private val mutex = Mutex() + private var cleanupJob: Job? = null + + fun learn( + profileId: ProviderProfileId, + deviceName: DeviceName, + displayName: String, + sdkKey: String? = null, + ): Deferred> = externalScope.async { + mutex.withLock { + cleanupJob?.join() + } + learnInfraredKey(profileId, deviceName, displayName, sdkKey) + } + + fun retry(ref: InfraredKeyRef): Deferred> = externalScope.async { + mutex.withLock { + cleanupJob?.join() + } + retryInfraredKeyLearning(ref) + } + + fun relearn(ref: InfraredKeyRef): Deferred> = externalScope.async { + mutex.withLock { + cleanupJob?.join() + } + relearnInfraredKey(ref) + } + + fun failInterruptedLearning( + profileId: ProviderProfileId, + cutoffEpochMillis: Long = System.currentTimeMillis(), + updatedAtEpochMillis: Long = cutoffEpochMillis, + ): Job { + val job = externalScope.launch(NonCancellable) { + keyRepository.failInterruptedLearning( + profileId = profileId, + cutoffEpochMillis = cutoffEpochMillis, + updatedAtEpochMillis = updatedAtEpochMillis, + ) + } + cleanupJob = job + return job + } +} diff --git a/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/data/local/InfraredDao.kt b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/data/local/InfraredDao.kt new file mode 100644 index 0000000..3583952 --- /dev/null +++ b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/data/local/InfraredDao.kt @@ -0,0 +1,222 @@ +package com.flagship.abox.manager.infrared.data.local + +import androidx.room.Dao +import androidx.room.Insert +import androidx.room.OnConflictStrategy +import androidx.room.Query +import kotlinx.coroutines.flow.Flow + +@Dao +interface InfraredDao { + @Query( + """ + SELECT * FROM infrared_keys + WHERE profileId = :profileId AND deviceName = :deviceName + ORDER BY createdAtEpochMillis ASC + """, + ) + fun observeKeys(profileId: String, deviceName: String): Flow> + + @Query( + """ + SELECT * FROM infrared_keys + WHERE profileId = :profileId AND id = :id + LIMIT 1 + """, + ) + suspend fun getKey(profileId: String, id: String): InfraredKeyEntity? + + @Insert(onConflict = OnConflictStrategy.ABORT) + suspend fun insertKey(entity: InfraredKeyEntity) + + @Query( + """ + UPDATE infrared_keys + SET status = :targetStatus, + lastErrorCode = :lastErrorCode, + lastErrorDetail = :lastErrorDetail, + updatedAtEpochMillis = :updatedAtEpochMillis + WHERE profileId = :profileId + AND id = :id + AND status IN (:expectedStatuses) + """, + ) + suspend fun transitionStatus( + profileId: String, + id: String, + expectedStatuses: List, + targetStatus: String, + lastErrorCode: String?, + lastErrorDetail: String?, + updatedAtEpochMillis: Long, + ): Int + + @Query( + """ + UPDATE infrared_keys + SET displayName = :displayName, + updatedAtEpochMillis = :updatedAtEpochMillis + WHERE profileId = :profileId AND id = :id + """, + ) + suspend fun renameKey( + profileId: String, + id: String, + displayName: String, + updatedAtEpochMillis: Long, + ): Int + + @Query( + """ + DELETE FROM infrared_keys + WHERE profileId = :profileId AND id = :id AND status != 'LEARNING' + """, + ) + suspend fun deleteKeyIfNotLearning(profileId: String, id: String): Int + + @Query( + """ + UPDATE infrared_keys + SET status = :targetStatus, + lastErrorCode = NULL, + lastErrorDetail = :errorDetail, + updatedAtEpochMillis = :updatedAtEpochMillis + WHERE profileId = :profileId + AND status = 'LEARNING' + AND createdAtEpochMillis <= :cutoffEpochMillis + """, + ) + suspend fun failInterruptedLearning( + profileId: String, + targetStatus: String, + errorDetail: String, + cutoffEpochMillis: Long, + updatedAtEpochMillis: Long, + ): Int + + @Query( + """ + SELECT * FROM infrared_device_configuration + WHERE profileId = :profileId + LIMIT 1 + """, + ) + fun observeDeviceName(profileId: String): Flow + + @Insert(onConflict = OnConflictStrategy.REPLACE) + suspend fun setDeviceName(entity: InfraredDeviceConfigurationEntity) + + // Virtual Remotes + @Query( + """ + SELECT * FROM virtual_remotes + WHERE profileId = :profileId AND deviceName = :deviceName + ORDER BY createdAtEpochMillis DESC + """, + ) + fun observeVirtualRemotes(profileId: String, deviceName: String): Flow> + + @Query( + """ + SELECT * FROM virtual_remotes + WHERE profileId = :profileId AND id = :id + LIMIT 1 + """, + ) + fun observeVirtualRemote(profileId: String, id: String): Flow + + @Query( + """ + SELECT * FROM virtual_remotes + WHERE profileId = :profileId AND id = :id + LIMIT 1 + """, + ) + suspend fun getVirtualRemote(profileId: String, id: String): VirtualRemoteEntity? + + @Insert(onConflict = OnConflictStrategy.REPLACE) + suspend fun insertVirtualRemote(entity: VirtualRemoteEntity) + + @Query( + """ + DELETE FROM virtual_remotes + WHERE profileId = :profileId AND id = :id + """, + ) + suspend fun deleteVirtualRemote(profileId: String, id: String): Int + + @Query( + """ + UPDATE virtual_remotes + SET acPower = :power, + acMode = :mode, + acTemperature = :temperature, + acFanSpeed = :fanSpeed, + acVerticalSwing = :verticalSwing, + acHorizontalSwing = :horizontalSwing, + acEco = :eco, + updatedAtEpochMillis = :updatedAtEpochMillis + WHERE profileId = :profileId AND id = :id + """, + ) + suspend fun updateAcState( + profileId: String, + id: String, + power: Boolean?, + mode: String?, + temperature: Int?, + fanSpeed: String?, + verticalSwing: Boolean?, + horizontalSwing: Boolean?, + eco: Boolean?, + updatedAtEpochMillis: Long, + ): Int + + // Remote Key Bindings + @Query( + """ + SELECT * FROM remote_key_bindings + WHERE remoteId = :remoteId + """, + ) + fun observeKeyBindings(remoteId: String): Flow> + + @Query( + """ + SELECT * FROM remote_key_bindings + WHERE remoteId = :remoteId + """, + ) + suspend fun getKeyBindings(remoteId: String): List + + @Insert(onConflict = OnConflictStrategy.REPLACE) + suspend fun insertKeyBindings(entities: List) + + @Insert(onConflict = OnConflictStrategy.REPLACE) + suspend fun insertKeyBinding(entity: RemoteKeyBindingEntity) + + @Query( + """ + DELETE FROM remote_key_bindings + WHERE remoteId = :remoteId + """, + ) + suspend fun deleteKeyBindingsByRemoteId(remoteId: String): Int + + @Query( + """ + DELETE FROM remote_key_bindings + WHERE remoteId = :remoteId AND buttonId = :buttonId + """, + ) + suspend fun deleteKeyBinding(remoteId: String, buttonId: String): Int + + @Query( + """ + SELECT b.assignedSlot FROM remote_key_bindings b + INNER JOIN virtual_remotes r ON b.remoteId = r.id + WHERE r.profileId = :profileId AND r.deviceName = :deviceName AND b.assignedSlot IS NOT NULL + """, + ) + fun observeAssignedStaticSlots(profileId: String, deviceName: String): Flow> +} diff --git a/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/data/local/InfraredDatabase.kt b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/data/local/InfraredDatabase.kt new file mode 100644 index 0000000..af179fd --- /dev/null +++ b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/data/local/InfraredDatabase.kt @@ -0,0 +1,18 @@ +package com.flagship.abox.manager.infrared.data.local + +import androidx.room.Database +import androidx.room.RoomDatabase + +@Database( + entities = [ + InfraredKeyEntity::class, + InfraredDeviceConfigurationEntity::class, + VirtualRemoteEntity::class, + RemoteKeyBindingEntity::class, + ], + version = 2, + exportSchema = false, +) +abstract class InfraredDatabase : RoomDatabase() { + abstract fun infraredDao(): InfraredDao +} diff --git a/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/data/local/InfraredEntities.kt b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/data/local/InfraredEntities.kt new file mode 100644 index 0000000..73112e5 --- /dev/null +++ b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/data/local/InfraredEntities.kt @@ -0,0 +1,83 @@ +package com.flagship.abox.manager.infrared.data.local + +import androidx.room.Entity +import androidx.room.Index +import androidx.room.PrimaryKey + +@Entity( + tableName = "infrared_keys", + indices = [ + Index(value = ["profileId", "deviceName"]), + Index(value = ["profileId", "deviceName", "sdkKey"], unique = true), + ], +) +data class InfraredKeyEntity( + @PrimaryKey + val id: String, + val profileId: String, + val deviceName: String, + val displayName: String, + val sdkKey: String, + val status: String, + val lastErrorCode: String?, + val lastErrorDetail: String?, + val createdAtEpochMillis: Long, + val updatedAtEpochMillis: Long, +) + +@Entity(tableName = "infrared_device_configuration") +data class InfraredDeviceConfigurationEntity( + @PrimaryKey + val profileId: String, + val deviceName: String, +) + +@Entity( + tableName = "virtual_remotes", + indices = [ + Index(value = ["profileId", "deviceName"]), + ], +) +data class VirtualRemoteEntity( + @PrimaryKey + val id: String, + val profileId: String, + val deviceName: String, + val displayName: String, + val type: String, + val brandModel: String?, + val layoutStyle: String?, + val transmissionMode: String, + val dynamicScratchSlot: String, + val acPower: Boolean?, + val acMode: String?, + val acTemperature: Int?, + val acFanSpeed: String?, + val acVerticalSwing: Boolean?, + val acHorizontalSwing: Boolean?, + val acEco: Boolean?, + val createdAtEpochMillis: Long, + val updatedAtEpochMillis: Long, +) + +@Entity( + tableName = "remote_key_bindings", + indices = [ + Index(value = ["remoteId"]), + Index(value = ["profileId"]), + ], +) +data class RemoteKeyBindingEntity( + @PrimaryKey + val id: String, + val remoteId: String, + val profileId: String, + val buttonId: String, + val displayName: String, + val assignedSlot: String?, + val rawHexCode: String?, + val status: String, + val lastErrorCode: String?, + val lastErrorDetail: String?, +) + diff --git a/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/data/local/InfraredMappers.kt b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/data/local/InfraredMappers.kt new file mode 100644 index 0000000..7da9a45 --- /dev/null +++ b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/data/local/InfraredMappers.kt @@ -0,0 +1,37 @@ +package com.flagship.abox.manager.infrared.data.local + +import com.flagship.abox.manager.domain.DeviceName +import com.flagship.abox.manager.domain.ProviderProfileId +import com.flagship.abox.manager.domain.infrared.InfraredKeyId +import com.flagship.abox.manager.domain.infrared.InfraredKeyStatus +import com.flagship.abox.manager.domain.infrared.SavedInfraredKey + +fun InfraredKeyEntity.toDomain(): SavedInfraredKey { + return SavedInfraredKey( + id = InfraredKeyId(id), + profileId = ProviderProfileId(profileId), + deviceName = DeviceName(deviceName), + displayName = displayName, + sdkKey = sdkKey, + status = InfraredKeyStatus.valueOf(status), + lastErrorCode = lastErrorCode, + lastErrorDetail = lastErrorDetail, + createdAtEpochMillis = createdAtEpochMillis, + updatedAtEpochMillis = updatedAtEpochMillis, + ) +} + +fun SavedInfraredKey.toEntity(): InfraredKeyEntity { + return InfraredKeyEntity( + id = id.value, + profileId = profileId.value, + deviceName = deviceName.value, + displayName = displayName, + sdkKey = sdkKey, + status = status.name, + lastErrorCode = lastErrorCode, + lastErrorDetail = lastErrorDetail, + createdAtEpochMillis = createdAtEpochMillis, + updatedAtEpochMillis = updatedAtEpochMillis, + ) +} diff --git a/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/data/local/RoomInfraredKeyRepository.kt b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/data/local/RoomInfraredKeyRepository.kt new file mode 100644 index 0000000..b748e39 --- /dev/null +++ b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/data/local/RoomInfraredKeyRepository.kt @@ -0,0 +1,201 @@ +package com.flagship.abox.manager.infrared.data.local + +import android.database.sqlite.SQLiteConstraintException +import com.flagship.abox.manager.domain.DeviceName +import com.flagship.abox.manager.domain.DomainError +import com.flagship.abox.manager.domain.DomainResult +import com.flagship.abox.manager.domain.ProviderProfileId +import com.flagship.abox.manager.domain.infrared.INTERRUPTED_LEARNING_ERROR_DETAIL +import com.flagship.abox.manager.domain.infrared.InfraredDeviceConfigurationRepository +import com.flagship.abox.manager.domain.infrared.InfraredKeyRef +import com.flagship.abox.manager.domain.infrared.InfraredKeyRepository +import com.flagship.abox.manager.domain.infrared.InfraredKeyStatus +import com.flagship.abox.manager.domain.infrared.SavedInfraredKey +import kotlinx.coroutines.CancellationException +import kotlinx.coroutines.flow.Flow +import kotlinx.coroutines.flow.catch +import kotlinx.coroutines.flow.map + +class RoomInfraredKeyRepository( + private val dao: InfraredDao, +) : InfraredKeyRepository, InfraredDeviceConfigurationRepository { + + override fun observeKeys( + profileId: ProviderProfileId, + deviceName: DeviceName, + ): Flow>> { + return dao.observeKeys(profileId.value, deviceName.value) + .map, DomainResult>> { entities -> + DomainResult.Success(entities.map { it.toDomain() }) + } + .catch { throwable -> + if (throwable is kotlinx.coroutines.CancellationException) throw throwable + emit(DomainResult.Failure(mapThrowableToDomainError(throwable))) + } + } + + override fun observeDeviceName(profileId: ProviderProfileId): Flow> { + return dao.observeDeviceName(profileId.value) + .map> { entity -> + DomainResult.Success(entity?.deviceName?.let { DeviceName(it) }) + } + .catch { throwable -> + if (throwable is kotlinx.coroutines.CancellationException) throw throwable + emit(DomainResult.Failure(mapThrowableToDomainError(throwable))) + } + } + + override suspend fun getKey(ref: InfraredKeyRef): DomainResult { + return try { + val entity = dao.getKey(ref.profileId.value, ref.keyId.value) + DomainResult.Success(entity?.toDomain()) + } catch (throwable: Throwable) { + DomainResult.Failure(mapThrowableToDomainError(throwable)) + } + } + + override suspend fun insert(key: SavedInfraredKey): DomainResult { + return try { + dao.insertKey(key.toEntity()) + DomainResult.Success(Unit) + } catch (throwable: Throwable) { + DomainResult.Failure(mapThrowableToDomainError(throwable)) + } + } + + override suspend fun transitionStatus( + ref: InfraredKeyRef, + expectedStatuses: Set, + targetStatus: InfraredKeyStatus, + lastErrorCode: String?, + lastErrorDetail: String?, + updatedAtEpochMillis: Long, + ): DomainResult { + return try { + val updated = dao.transitionStatus( + profileId = ref.profileId.value, + id = ref.keyId.value, + expectedStatuses = expectedStatuses.map { it.name }, + targetStatus = targetStatus.name, + lastErrorCode = lastErrorCode, + lastErrorDetail = lastErrorDetail, + updatedAtEpochMillis = updatedAtEpochMillis, + ) + if (updated > 0) { + DomainResult.Success(Unit) + } else { + val existing = dao.getKey(ref.profileId.value, ref.keyId.value) + if (existing == null) { + DomainResult.Failure(DomainError.NoData(detail = "Infrared key not found")) + } else { + DomainResult.Failure( + DomainError.InvalidRequest( + detail = "Cannot transition key from ${existing.status} to ${targetStatus.name}", + ), + ) + } + } + } catch (throwable: Throwable) { + DomainResult.Failure(mapThrowableToDomainError(throwable)) + } + } + + override suspend fun rename( + ref: InfraredKeyRef, + displayName: String, + updatedAtEpochMillis: Long, + ): DomainResult { + val trimmed = displayName.trim() + if (trimmed.isBlank()) { + return DomainResult.Failure(DomainError.InvalidRequest(detail = "Display name cannot be blank")) + } + return try { + val updated = dao.renameKey( + profileId = ref.profileId.value, + id = ref.keyId.value, + displayName = trimmed, + updatedAtEpochMillis = updatedAtEpochMillis, + ) + if (updated > 0) { + DomainResult.Success(Unit) + } else { + DomainResult.Failure(DomainError.NoData(detail = "Infrared key not found")) + } + } catch (throwable: Throwable) { + DomainResult.Failure(mapThrowableToDomainError(throwable)) + } + } + + override suspend fun deleteIfNotLearning(ref: InfraredKeyRef): DomainResult { + return try { + val deleted = dao.deleteKeyIfNotLearning(ref.profileId.value, ref.keyId.value) + if (deleted > 0) { + DomainResult.Success(Unit) + } else { + val existing = dao.getKey(ref.profileId.value, ref.keyId.value) + if (existing == null) { + DomainResult.Failure(DomainError.NoData(detail = "Infrared key not found")) + } else { + DomainResult.Failure( + DomainError.InvalidRequest(detail = "Cannot delete key while learning is in progress"), + ) + } + } + } catch (throwable: Throwable) { + DomainResult.Failure(mapThrowableToDomainError(throwable)) + } + } + + override suspend fun failInterruptedLearning( + profileId: ProviderProfileId, + cutoffEpochMillis: Long, + updatedAtEpochMillis: Long, + ): DomainResult { + return try { + val count = dao.failInterruptedLearning( + profileId = profileId.value, + targetStatus = InfraredKeyStatus.FAILED.name, + errorDetail = INTERRUPTED_LEARNING_ERROR_DETAIL, + cutoffEpochMillis = cutoffEpochMillis, + updatedAtEpochMillis = updatedAtEpochMillis, + ) + DomainResult.Success(count) + } catch (throwable: Throwable) { + if (throwable is CancellationException) { + throw throwable + } + DomainResult.Failure(mapThrowableToDomainError(throwable)) + } + } + + override suspend fun setDeviceName( + profileId: ProviderProfileId, + deviceName: DeviceName, + ): DomainResult { + val trimmed = deviceName.value.trim() + if (trimmed.isBlank()) { + return DomainResult.Failure(DomainError.InvalidRequest(detail = "Device name cannot be blank")) + } + return try { + dao.setDeviceName( + InfraredDeviceConfigurationEntity( + profileId = profileId.value, + deviceName = trimmed, + ), + ) + DomainResult.Success(Unit) + } catch (throwable: Throwable) { + DomainResult.Failure(mapThrowableToDomainError(throwable)) + } + } + + private fun mapThrowableToDomainError(throwable: Throwable): DomainError { + if (throwable is kotlinx.coroutines.CancellationException) { + throw throwable + } + return when (throwable) { + is SQLiteConstraintException -> DomainError.InvalidRequest(detail = "Database constraint violation") + else -> DomainError.Unknown(detail = "Database operation failed") + } + } +} diff --git a/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/data/local/RoomVirtualRemoteRepository.kt b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/data/local/RoomVirtualRemoteRepository.kt new file mode 100644 index 0000000..712e679 --- /dev/null +++ b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/data/local/RoomVirtualRemoteRepository.kt @@ -0,0 +1,229 @@ +package com.flagship.abox.manager.infrared.data.local + +import com.flagship.abox.manager.domain.DeviceName +import com.flagship.abox.manager.domain.DomainResult +import com.flagship.abox.manager.domain.ProviderProfileId +import com.flagship.abox.manager.domain.infrared.AcFanSpeed +import com.flagship.abox.manager.domain.infrared.AcMode +import com.flagship.abox.manager.domain.infrared.AcStateSnapshot +import com.flagship.abox.manager.domain.infrared.InfraredKeyStatus +import com.flagship.abox.manager.domain.infrared.RemoteDeviceType +import com.flagship.abox.manager.domain.infrared.RemoteKeyBinding +import com.flagship.abox.manager.domain.infrared.SlotQuotaSummary +import com.flagship.abox.manager.domain.infrared.TransmissionMode +import com.flagship.abox.manager.domain.infrared.VirtualRemote +import com.flagship.abox.manager.domain.infrared.VirtualRemoteId +import com.flagship.abox.manager.domain.infrared.VirtualRemoteRepository +import kotlinx.coroutines.flow.Flow +import kotlinx.coroutines.flow.map +import javax.inject.Inject + +class RoomVirtualRemoteRepository @Inject constructor( + private val dao: InfraredDao, +) : VirtualRemoteRepository { + + override fun observeRemotes( + profileId: ProviderProfileId, + deviceName: DeviceName, + ): Flow>> = + dao.observeVirtualRemotes(profileId.value, deviceName.value).map { entities -> + DomainResult.Success(entities.map { it.toDomain() }) + } + + override fun observeRemote( + profileId: ProviderProfileId, + remoteId: VirtualRemoteId, + ): Flow> = + dao.observeVirtualRemote(profileId.value, remoteId.value).map { entity -> + DomainResult.Success(entity?.toDomain()) + } + + override fun observeKeyBindings( + remoteId: VirtualRemoteId, + ): Flow>> = + dao.observeKeyBindings(remoteId.value).map { entities -> + DomainResult.Success(entities.map { it.toDomain() }) + } + + override fun observeSlotQuota( + profileId: ProviderProfileId, + deviceName: DeviceName, + ): Flow> = + dao.observeAssignedStaticSlots(profileId.value, deviceName.value).map { slots -> + val slotInts = slots.mapNotNull { it.toIntOrNull() }.toSet() + DomainResult.Success( + SlotQuotaSummary( + totalCapacity = 100, + dynamicScratchSlot = 100, + assignedStaticSlots = slotInts, + ), + ) + } + + override suspend fun getRemote( + profileId: ProviderProfileId, + remoteId: VirtualRemoteId, + ): DomainResult = try { + val entity = dao.getVirtualRemote(profileId.value, remoteId.value) + DomainResult.Success(entity?.toDomain()) + } catch (e: Exception) { + DomainResult.Failure(com.flagship.abox.manager.domain.DomainError.OperationFailed(detail = e.message)) + } + + override suspend fun getKeyBindings( + remoteId: VirtualRemoteId, + ): DomainResult> = try { + val list = dao.getKeyBindings(remoteId.value) + DomainResult.Success(list.map { it.toDomain() }) + } catch (e: Exception) { + DomainResult.Failure(com.flagship.abox.manager.domain.DomainError.OperationFailed(detail = e.message)) + } + + override suspend fun createRemote( + remote: VirtualRemote, + initialBindings: List, + ): DomainResult = try { + dao.insertVirtualRemote(remote.toEntity()) + dao.insertKeyBindings(initialBindings.map { it.toEntity() }) + DomainResult.Success(remote.id) + } catch (e: Exception) { + DomainResult.Failure(com.flagship.abox.manager.domain.DomainError.OperationFailed(detail = e.message)) + } + + override suspend fun updateRemote(remote: VirtualRemote): DomainResult = try { + dao.insertVirtualRemote(remote.toEntity()) + DomainResult.Success(Unit) + } catch (e: Exception) { + DomainResult.Failure(com.flagship.abox.manager.domain.DomainError.OperationFailed(detail = e.message)) + } + + override suspend fun deleteRemote( + profileId: ProviderProfileId, + remoteId: VirtualRemoteId, + ): DomainResult = try { + dao.deleteVirtualRemote(profileId.value, remoteId.value) + dao.deleteKeyBindingsByRemoteId(remoteId.value) + DomainResult.Success(Unit) + } catch (e: Exception) { + DomainResult.Failure(com.flagship.abox.manager.domain.DomainError.OperationFailed(detail = e.message)) + } + + override suspend fun updateKeyBinding(binding: RemoteKeyBinding): DomainResult = try { + dao.insertKeyBinding(binding.toEntity()) + DomainResult.Success(Unit) + } catch (e: Exception) { + DomainResult.Failure(com.flagship.abox.manager.domain.DomainError.OperationFailed(detail = e.message)) + } + + override suspend fun deleteKeyBinding( + remoteId: VirtualRemoteId, + buttonId: String, + ): DomainResult = try { + dao.deleteKeyBinding(remoteId.value, buttonId) + DomainResult.Success(Unit) + } catch (e: Exception) { + DomainResult.Failure(com.flagship.abox.manager.domain.DomainError.OperationFailed(detail = e.message)) + } + + override suspend fun updateAcState( + profileId: ProviderProfileId, + remoteId: VirtualRemoteId, + state: AcStateSnapshot, + ): DomainResult = try { + dao.updateAcState( + profileId = profileId.value, + id = remoteId.value, + power = state.power, + mode = state.mode.name, + temperature = state.temperature, + fanSpeed = state.fanSpeed.name, + verticalSwing = state.verticalSwing, + horizontalSwing = state.horizontalSwing, + eco = state.eco, + updatedAtEpochMillis = System.currentTimeMillis(), + ) + DomainResult.Success(Unit) + } catch (e: Exception) { + DomainResult.Failure(com.flagship.abox.manager.domain.DomainError.OperationFailed(detail = e.message)) + } +} + +private fun VirtualRemoteEntity.toDomain(): VirtualRemote { + val ac = if (type == RemoteDeviceType.AIR_CONDITIONER.name) { + AcStateSnapshot( + power = acPower ?: true, + mode = acMode?.let { runCatching { AcMode.valueOf(it) }.getOrNull() } ?: AcMode.COOL, + temperature = acTemperature ?: 26, + fanSpeed = acFanSpeed?.let { runCatching { AcFanSpeed.valueOf(it) }.getOrNull() } ?: AcFanSpeed.AUTO, + verticalSwing = acVerticalSwing ?: true, + horizontalSwing = acHorizontalSwing ?: false, + eco = acEco ?: false, + ) + } else null + + val devType = runCatching { RemoteDeviceType.valueOf(type) }.getOrDefault(RemoteDeviceType.CUSTOM) + val parsedLayout = layoutStyle?.let { runCatching { com.flagship.abox.manager.domain.infrared.PanelLayoutStyle.valueOf(it) }.getOrNull() } + ?: VirtualRemote.defaultLayoutFor(devType) + + return VirtualRemote( + id = VirtualRemoteId(id), + profileId = ProviderProfileId(profileId), + deviceName = DeviceName(deviceName), + displayName = displayName, + type = devType, + brandModel = brandModel, + layoutStyle = parsedLayout, + transmissionMode = runCatching { TransmissionMode.valueOf(transmissionMode) }.getOrDefault(TransmissionMode.DYNAMIC_SCRATCH), + dynamicScratchSlot = dynamicScratchSlot, + acState = ac, + createdAtEpochMillis = createdAtEpochMillis, + updatedAtEpochMillis = updatedAtEpochMillis, + ) +} + +private fun VirtualRemote.toEntity(): VirtualRemoteEntity = VirtualRemoteEntity( + id = id.value, + profileId = profileId.value, + deviceName = deviceName.value, + displayName = displayName, + type = type.name, + brandModel = brandModel, + layoutStyle = layoutStyle.name, + transmissionMode = transmissionMode.name, + dynamicScratchSlot = dynamicScratchSlot, + acPower = acState?.power, + acMode = acState?.mode?.name, + acTemperature = acState?.temperature, + acFanSpeed = acState?.fanSpeed?.name, + acVerticalSwing = acState?.verticalSwing, + acHorizontalSwing = acState?.horizontalSwing, + acEco = acState?.eco, + createdAtEpochMillis = createdAtEpochMillis, + updatedAtEpochMillis = updatedAtEpochMillis, +) + +private fun RemoteKeyBindingEntity.toDomain(): RemoteKeyBinding = RemoteKeyBinding( + id = id, + remoteId = VirtualRemoteId(remoteId), + profileId = ProviderProfileId(profileId), + buttonId = buttonId, + displayName = displayName, + assignedSlot = assignedSlot, + rawHexCode = rawHexCode, + status = runCatching { InfraredKeyStatus.valueOf(status) }.getOrDefault(InfraredKeyStatus.READY), + lastErrorCode = lastErrorCode, + lastErrorDetail = lastErrorDetail, +) + +private fun RemoteKeyBinding.toEntity(): RemoteKeyBindingEntity = RemoteKeyBindingEntity( + id = id, + remoteId = remoteId.value, + profileId = profileId.value, + buttonId = buttonId, + displayName = displayName, + assignedSlot = assignedSlot, + rawHexCode = rawHexCode, + status = status.name, + lastErrorCode = lastErrorCode, + lastErrorDetail = lastErrorDetail, +) diff --git a/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/di/InfraredFeatureModule.kt b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/di/InfraredFeatureModule.kt new file mode 100644 index 0000000..13d499a --- /dev/null +++ b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/di/InfraredFeatureModule.kt @@ -0,0 +1,229 @@ +package com.flagship.abox.manager.infrared.di + +import android.content.Context +import androidx.room.Room +import com.flagship.abox.manager.domain.InfraredGateway +import com.flagship.abox.manager.domain.infrared.EpochMillisClock +import com.flagship.abox.manager.domain.infrared.DeleteInfraredKey +import com.flagship.abox.manager.domain.infrared.InfraredDeviceConfigurationRepository +import com.flagship.abox.manager.domain.infrared.InfraredKeyFactory +import com.flagship.abox.manager.domain.infrared.InfraredKeyId +import com.flagship.abox.manager.domain.infrared.InfraredKeyIdGenerator +import com.flagship.abox.manager.domain.infrared.InfraredKeyRepository +import com.flagship.abox.manager.domain.infrared.LearnInfraredKey +import com.flagship.abox.manager.domain.infrared.RecoverInterruptedInfraredLearning +import com.flagship.abox.manager.domain.infrared.RenameInfraredKey +import com.flagship.abox.manager.domain.infrared.RetryInfraredKeyLearning +import com.flagship.abox.manager.domain.infrared.SendInfraredKey +import com.flagship.abox.manager.infrared.application.InfraredLearningCoordinator +import com.flagship.abox.manager.infrared.data.local.InfraredDao +import com.flagship.abox.manager.infrared.data.local.InfraredDatabase +import com.flagship.abox.manager.infrared.data.local.RoomInfraredKeyRepository +import com.flagship.abox.manager.infrared.data.local.RoomVirtualRemoteRepository +import dagger.Module +import dagger.Provides +import dagger.hilt.InstallIn +import dagger.hilt.android.qualifiers.ApplicationContext +import dagger.hilt.components.SingletonComponent +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.SupervisorJob +import java.util.UUID +import javax.inject.Qualifier +import javax.inject.Singleton + +@Qualifier +@Retention(AnnotationRetention.BINARY) +annotation class InfraredApplicationScope + +@Module +@InstallIn(SingletonComponent::class) +object InfraredFeatureModule { + + @Provides + @Singleton + fun provideInfraredDatabase( + @ApplicationContext context: Context, + ): InfraredDatabase { + return Room.databaseBuilder( + context, + InfraredDatabase::class.java, + "abox_infrared.db", + ).fallbackToDestructiveMigration().build() + } + + @Provides + @Singleton + fun provideInfraredDao(database: InfraredDatabase): InfraredDao = database.infraredDao() + + @Provides + @Singleton + fun provideRoomInfraredKeyRepository(dao: InfraredDao): RoomInfraredKeyRepository = + RoomInfraredKeyRepository(dao) + + @Provides + @Singleton + fun provideInfraredKeyRepository( + repository: RoomInfraredKeyRepository, + ): InfraredKeyRepository = repository + + @Provides + @Singleton + fun provideInfraredDeviceConfigurationRepository( + repository: RoomInfraredKeyRepository, + ): InfraredDeviceConfigurationRepository = repository + + @Provides + fun provideInfraredKeyIdGenerator(): InfraredKeyIdGenerator = + InfraredKeyIdGenerator { InfraredKeyId(UUID.randomUUID().toString()) } + + @Provides + fun provideEpochMillisClock(): EpochMillisClock = + EpochMillisClock { System.currentTimeMillis() } + + @Provides + @Singleton + fun provideInfraredKeyFactory( + idGenerator: InfraredKeyIdGenerator, + clock: EpochMillisClock, + ): InfraredKeyFactory = InfraredKeyFactory(idGenerator, clock) + + @Provides + @Singleton + @InfraredApplicationScope + fun provideInfraredApplicationScope(): CoroutineScope = + CoroutineScope(SupervisorJob() + Dispatchers.IO) + + @Provides + @Singleton + fun provideLearnInfraredKey( + repository: InfraredKeyRepository, + gateway: InfraredGateway, + factory: InfraredKeyFactory, + clock: EpochMillisClock, + ): LearnInfraredKey = LearnInfraredKey(repository, gateway, factory, clock) + + @Provides + @Singleton + fun provideRetryInfraredKeyLearning( + repository: InfraredKeyRepository, + gateway: InfraredGateway, + clock: EpochMillisClock, + ): RetryInfraredKeyLearning = RetryInfraredKeyLearning(repository, gateway, clock) + + @Provides + @Singleton + fun provideSendInfraredKey( + repository: InfraredKeyRepository, + gateway: InfraredGateway, + ): SendInfraredKey = SendInfraredKey(repository, gateway) + + @Provides + @Singleton + fun provideRenameInfraredKey( + repository: InfraredKeyRepository, + clock: EpochMillisClock, + ): RenameInfraredKey = RenameInfraredKey(repository, clock) + + @Provides + @Singleton + fun provideDeleteInfraredKey( + repository: InfraredKeyRepository, + ): DeleteInfraredKey = DeleteInfraredKey(repository) + + @Provides + @Singleton + fun provideRecoverInterruptedInfraredLearning( + repository: InfraredKeyRepository, + clock: EpochMillisClock, + ): RecoverInterruptedInfraredLearning = RecoverInterruptedInfraredLearning(repository, clock) + + @Provides + @Singleton + fun provideRelearnInfraredKey( + repository: InfraredKeyRepository, + gateway: InfraredGateway, + clock: EpochMillisClock, + ): com.flagship.abox.manager.domain.infrared.RelearnInfraredKey = + com.flagship.abox.manager.domain.infrared.RelearnInfraredKey(repository, gateway, clock) + + @Provides + @Singleton + fun provideInfraredLearningCoordinator( + learnInfraredKey: LearnInfraredKey, + retryInfraredKeyLearning: RetryInfraredKeyLearning, + relearnInfraredKey: com.flagship.abox.manager.domain.infrared.RelearnInfraredKey, + repository: InfraredKeyRepository, + @InfraredApplicationScope scope: CoroutineScope, + ): InfraredLearningCoordinator = InfraredLearningCoordinator( + learnInfraredKey = learnInfraredKey, + retryInfraredKeyLearning = retryInfraredKeyLearning, + relearnInfraredKey = relearnInfraredKey, + keyRepository = repository, + externalScope = scope, + ) + + @Provides + @Singleton + fun provideRoomVirtualRemoteRepository(dao: InfraredDao): RoomVirtualRemoteRepository = + RoomVirtualRemoteRepository(dao) + + @Provides + @Singleton + fun provideVirtualRemoteRepository( + repository: RoomVirtualRemoteRepository, + ): com.flagship.abox.manager.domain.infrared.VirtualRemoteRepository = repository + + @Provides + @Singleton + fun provideCreateVirtualRemote( + repository: com.flagship.abox.manager.domain.infrared.VirtualRemoteRepository, + gateway: InfraredGateway, + clock: EpochMillisClock, + ): com.flagship.abox.manager.domain.infrared.CreateVirtualRemote = + com.flagship.abox.manager.domain.infrared.CreateVirtualRemote(repository, gateway, clock) + + @Provides + @Singleton + fun provideSendVirtualRemoteAction( + repository: com.flagship.abox.manager.domain.infrared.VirtualRemoteRepository, + gateway: InfraredGateway, + ): com.flagship.abox.manager.domain.infrared.SendVirtualRemoteAction = + com.flagship.abox.manager.domain.infrared.SendVirtualRemoteAction(repository, gateway) + + @Provides + @Singleton + fun provideDeleteVirtualRemote( + repository: com.flagship.abox.manager.domain.infrared.VirtualRemoteRepository, + ): com.flagship.abox.manager.domain.infrared.DeleteVirtualRemote = + com.flagship.abox.manager.domain.infrared.DeleteVirtualRemote(repository) + + @Provides + @Singleton + fun provideLearnVirtualRemoteKey( + repository: com.flagship.abox.manager.domain.infrared.VirtualRemoteRepository, + gateway: InfraredGateway, + ): com.flagship.abox.manager.domain.infrared.LearnVirtualRemoteKey = + com.flagship.abox.manager.domain.infrared.LearnVirtualRemoteKey(repository, gateway) + + @Provides + @Singleton + fun provideAddVirtualRemoteKey( + repository: com.flagship.abox.manager.domain.infrared.VirtualRemoteRepository, + ): com.flagship.abox.manager.domain.infrared.AddVirtualRemoteKey = + com.flagship.abox.manager.domain.infrared.AddVirtualRemoteKey(repository) + + @Provides + @Singleton + fun provideDeleteVirtualRemoteKey( + repository: com.flagship.abox.manager.domain.infrared.VirtualRemoteRepository, + ): com.flagship.abox.manager.domain.infrared.DeleteVirtualRemoteKey = + com.flagship.abox.manager.domain.infrared.DeleteVirtualRemoteKey(repository) + + @Provides + @Singleton + fun provideUpdateVirtualRemoteLayout( + repository: com.flagship.abox.manager.domain.infrared.VirtualRemoteRepository, + ): com.flagship.abox.manager.domain.infrared.UpdateVirtualRemoteLayout = + com.flagship.abox.manager.domain.infrared.UpdateVirtualRemoteLayout(repository) +} diff --git a/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/hub/InfraredHubScreen.kt b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/hub/InfraredHubScreen.kt new file mode 100644 index 0000000..1ee37cb --- /dev/null +++ b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/hub/InfraredHubScreen.kt @@ -0,0 +1,593 @@ +package com.flagship.abox.manager.infrared.hub + +import androidx.compose.foundation.background +import androidx.compose.foundation.clickable +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.lazy.grid.GridCells +import androidx.compose.foundation.lazy.grid.LazyVerticalGrid +import androidx.compose.foundation.lazy.grid.items +import androidx.compose.foundation.shape.CircleShape +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material3.AlertDialog +import androidx.compose.material3.Button +import androidx.compose.material3.Card +import androidx.compose.material3.CardDefaults +import androidx.compose.material3.CircularProgressIndicator +import androidx.compose.material3.DropdownMenuItem +import androidx.compose.material3.ExperimentalMaterial3Api +import androidx.compose.material3.ExposedDropdownMenuBox +import androidx.compose.material3.ExposedDropdownMenuDefaults +import androidx.compose.material3.FilterChip +import androidx.compose.material3.IconButton +import androidx.compose.material3.LinearProgressIndicator +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.OutlinedTextField +import androidx.compose.material3.RadioButton +import androidx.compose.material3.Scaffold +import androidx.compose.material3.SnackbarHost +import androidx.compose.material3.SnackbarHostState +import androidx.compose.material3.Surface +import androidx.compose.material3.Text +import androidx.compose.material3.TextButton +import androidx.compose.material3.TopAppBar +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.clip +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.platform.testTag +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp +import androidx.hilt.navigation.compose.hiltViewModel +import androidx.lifecycle.compose.collectAsStateWithLifecycle +import com.flagship.abox.manager.designsystem.ABoxSurface +import com.flagship.abox.manager.domain.ProviderProfileId +import com.flagship.abox.manager.domain.infrared.PanelLayoutStyle +import com.flagship.abox.manager.domain.infrared.PresetCodeLibrary +import com.flagship.abox.manager.domain.infrared.RemoteDeviceType +import com.flagship.abox.manager.domain.infrared.SlotQuotaSummary +import com.flagship.abox.manager.domain.infrared.TransmissionMode +import com.flagship.abox.manager.domain.infrared.VirtualRemote +import com.flagship.abox.manager.domain.infrared.VirtualRemoteId +import com.flagship.abox.manager.infrared.R +import com.flagship.abox.manager.infrared.remote.UiText + +@Composable +fun InfraredHubRoute( + onBack: () -> Unit, + onOpenRemote: (String) -> Unit, + onOpenSettings: () -> Unit, + onSessionInvalid: () -> Unit, + viewModel: InfraredHubViewModel = hiltViewModel(), +) { + val state by viewModel.state.collectAsStateWithLifecycle() + + InfraredHubScreen( + state = state, + onBack = onBack, + onNavigateToSettings = onOpenSettings, + onOpenRemote = onOpenRemote, + onDeleteRemote = viewModel::deleteRemote, + onCreateRemote = viewModel::createRemote, + onSessionInvalid = onSessionInvalid, + onMessageShown = viewModel::clearMessage, + ) +} + +@OptIn(ExperimentalMaterial3Api::class) +@Composable +internal fun InfraredHubScreen( + state: InfraredHubUiState, + onBack: () -> Unit, + onNavigateToSettings: () -> Unit, + onOpenRemote: (String) -> Unit, + onDeleteRemote: (VirtualRemoteId) -> Unit, + onCreateRemote: (String, RemoteDeviceType, String?, TransmissionMode, PanelLayoutStyle?) -> Unit, + onSessionInvalid: () -> Unit, + onMessageShown: () -> Unit, +) { + val snackbarHostState = remember { SnackbarHostState() } + val context = LocalContext.current + var showCreateDialog by remember { mutableStateOf(false) } + + LaunchedEffect(state.message) { + state.message?.let { msg -> + when (msg) { + is HubUiMessage.Info -> { + val text = when (val t = msg.text) { + is UiText.DynamicString -> t.value + is UiText.StringResource -> context.getString(t.resId, *t.args.toTypedArray()) + } + snackbarHostState.showSnackbar(text) + onMessageShown() + } + is HubUiMessage.Error -> { + val text = when (val t = msg.text) { + is UiText.DynamicString -> t.value + is UiText.StringResource -> context.getString(t.resId, *t.args.toTypedArray()) + } + snackbarHostState.showSnackbar(text) + onMessageShown() + } + is HubUiMessage.SessionInvalid -> { + onSessionInvalid() + onMessageShown() + } + } + } + } + + Scaffold( + topBar = { + TopAppBar( + title = { + Column { + Text( + text = stringResource(R.string.infrared_hub_title), + fontWeight = FontWeight.Bold, + ) + state.providerDisplayName?.let { + Text( + text = it, + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + } + }, + navigationIcon = { + TextButton(onClick = onBack) { + Text(stringResource(R.string.infrared_back)) + } + }, + actions = { + IconButton( + onClick = onNavigateToSettings, + modifier = Modifier.testTag("hub_settings_button"), + ) { + Text("⚙️", fontSize = 20.sp) + } + }, + ) + }, + snackbarHost = { SnackbarHost(snackbarHostState) }, + ) { innerPadding -> + ABoxSurface( + modifier = Modifier + .fillMaxSize() + .padding(innerPadding), + ) { + Column( + modifier = Modifier + .fillMaxSize() + .padding(16.dp), + verticalArrangement = Arrangement.spacedBy(16.dp), + ) { + // 1. 硬件槽位配额看板 (100 槽位预算) + QuotaSummaryCard(quota = state.slotQuota) + + // 2. 遥控器列表标题与新建按钮 + Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.SpaceBetween, + verticalAlignment = Alignment.CenterVertically, + ) { + Text( + text = stringResource(R.string.infrared_hub_my_remotes), + style = MaterialTheme.typography.titleMedium.copy(fontWeight = FontWeight.Bold), + ) + + Button( + onClick = { showCreateDialog = true }, + modifier = Modifier.testTag("hub_add_remote_button"), + ) { + Text("➕ " + stringResource(R.string.infrared_hub_add_remote)) + } + } + + // 3. 遥控器网格卡片 + if (state.remotes.isEmpty()) { + Box( + modifier = Modifier.fillMaxWidth().weight(1f), + contentAlignment = Alignment.Center, + ) { + Text( + text = stringResource(R.string.infrared_hub_no_remotes), + style = MaterialTheme.typography.bodyLarge, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + } else { + LazyVerticalGrid( + columns = GridCells.Fixed(2), + modifier = Modifier.fillMaxWidth().weight(1f), + horizontalArrangement = Arrangement.spacedBy(12.dp), + verticalArrangement = Arrangement.spacedBy(12.dp), + ) { + items(state.remotes, key = { it.id.value }) { remote -> + VirtualRemoteCard( + remote = remote, + onClick = { onOpenRemote(remote.id.value) }, + onDelete = { onDeleteRemote(remote.id) }, + ) + } + } + } + } + } + } + + if (showCreateDialog) { + CreateVirtualRemoteDialog( + onDismiss = { showCreateDialog = false }, + onConfirm = { name, type, brandModel, transMode, layoutStyle -> + onCreateRemote(name, type, brandModel, transMode, layoutStyle) + showCreateDialog = false + }, + ) + } +} + +@Composable +private fun VirtualRemoteCard( + remote: VirtualRemote, + onClick: () -> Unit, + onDelete: () -> Unit, +) { + Card( + modifier = Modifier + .fillMaxWidth() + .clickable(onClick = onClick) + .testTag("remote_card_${remote.id.value}"), + elevation = CardDefaults.cardElevation(defaultElevation = 2.dp), + ) { + Column( + modifier = Modifier + .fillMaxWidth() + .padding(14.dp), + verticalArrangement = Arrangement.spacedBy(8.dp), + ) { + Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.SpaceBetween, + verticalAlignment = Alignment.CenterVertically, + ) { + val icon = when (remote.type) { + RemoteDeviceType.TV -> "📺" + RemoteDeviceType.AIR_CONDITIONER -> "❄️" + RemoteDeviceType.FAN -> "🌀" + RemoteDeviceType.CUSTOM -> "🎛️" + } + Text(icon, fontSize = 28.sp) + IconButton(onClick = onDelete, modifier = Modifier.testTag("delete_remote_${remote.id.value}")) { + Text("🗑️", fontSize = 16.sp) + } + } + + Text( + text = remote.displayName, + style = MaterialTheme.typography.titleMedium.copy(fontWeight = FontWeight.Bold), + ) + + val modeText = if (remote.type == RemoteDeviceType.AIR_CONDITIONER) { + "❄️ 状态机动态写码" + } else if (remote.transmissionMode == TransmissionMode.STATIC_SLOTS) { + "🚀 静态独占槽位" + } else { + "📦 动态写码" + } + + Text( + text = "${remote.layoutStyle.name} · $modeText", + fontSize = 11.sp, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + } +} + +@Composable +private fun QuotaSummaryCard(quota: SlotQuotaSummary) { + Card( + modifier = Modifier.fillMaxWidth(), + colors = CardDefaults.cardColors( + containerColor = MaterialTheme.colorScheme.surfaceVariant, + ), + ) { + Column( + modifier = Modifier + .fillMaxWidth() + .padding(16.dp), + verticalArrangement = Arrangement.spacedBy(8.dp), + ) { + Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.SpaceBetween, + verticalAlignment = Alignment.CenterVertically, + ) { + Text( + text = "硬件槽位配额 (总计 100 槽位)", + fontWeight = FontWeight.Bold, + fontSize = 14.sp, + ) + Text( + text = "${quota.usedCount} / ${quota.totalCapacity} 已占用", + fontWeight = FontWeight.Bold, + color = if (quota.isStaticFull) MaterialTheme.colorScheme.error else MaterialTheme.colorScheme.primary, + fontSize = 13.sp, + ) + } + + LinearProgressIndicator( + progress = { quota.usedCount.toFloat() / quota.totalCapacity.toFloat() }, + modifier = Modifier + .fillMaxWidth() + .height(8.dp) + .clip(RoundedCornerShape(4.dp)), + ) + + Text( + text = "静态槽位占用: ${quota.assignedStaticSlots.size} 个 | 动态缓冲: Slot 100 (共享) | 剩余静态: ${quota.remainingStaticCount} 个", + fontSize = 11.sp, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + } +} + +@OptIn(ExperimentalMaterial3Api::class) +@Composable +private fun CreateVirtualRemoteDialog( + onDismiss: () -> Unit, + onConfirm: (name: String, type: RemoteDeviceType, brandModel: String?, transMode: TransmissionMode, layoutStyle: PanelLayoutStyle?) -> Unit, +) { + var name by remember { mutableStateOf("") } + var selectedType by remember { mutableStateOf(RemoteDeviceType.TV) } + var selectedBrand by remember { mutableStateOf(PresetCodeLibrary.availablePresets.first()) } + var selectedCustomLayout by remember { mutableStateOf(PanelLayoutStyle.TV_NAV) } + var transmissionMode by remember { mutableStateOf(TransmissionMode.STATIC_SLOTS) } + + var typeDropdownExpanded by remember { mutableStateOf(false) } + var brandDropdownExpanded by remember { mutableStateOf(false) } + var layoutDropdownExpanded by remember { mutableStateOf(false) } + + val filteredPresets = PresetCodeLibrary.availablePresets.filter { it.deviceType == selectedType } + + AlertDialog( + onDismissRequest = onDismiss, + title = { Text(stringResource(R.string.infrared_hub_create_dialog_title)) }, + text = { + Column( + modifier = Modifier.fillMaxWidth(), + verticalArrangement = Arrangement.spacedBy(12.dp), + ) { + // 1. 设备类型选择 + ExposedDropdownMenuBox( + expanded = typeDropdownExpanded, + onExpandedChange = { typeDropdownExpanded = !typeDropdownExpanded }, + ) { + OutlinedTextField( + value = when (selectedType) { + RemoteDeviceType.TV -> stringResource(R.string.infrared_hub_device_type_tv) + RemoteDeviceType.AIR_CONDITIONER -> stringResource(R.string.infrared_hub_device_type_ac) + RemoteDeviceType.FAN -> stringResource(R.string.infrared_hub_device_type_fan) + RemoteDeviceType.CUSTOM -> stringResource(R.string.infrared_hub_device_type_custom) + }, + onValueChange = {}, + readOnly = true, + label = { Text(stringResource(R.string.infrared_hub_device_type_label)) }, + trailingIcon = { ExposedDropdownMenuDefaults.TrailingIcon(expanded = typeDropdownExpanded) }, + modifier = Modifier.fillMaxWidth().menuAnchor(), + ) + ExposedDropdownMenu( + expanded = typeDropdownExpanded, + onDismissRequest = { typeDropdownExpanded = false }, + ) { + RemoteDeviceType.entries.forEach { type -> + val label = when (type) { + RemoteDeviceType.TV -> stringResource(R.string.infrared_hub_device_type_tv) + RemoteDeviceType.AIR_CONDITIONER -> stringResource(R.string.infrared_hub_device_type_ac) + RemoteDeviceType.FAN -> stringResource(R.string.infrared_hub_device_type_fan) + RemoteDeviceType.CUSTOM -> stringResource(R.string.infrared_hub_device_type_custom) + } + DropdownMenuItem( + text = { Text(label) }, + onClick = { + selectedType = type + val matched = PresetCodeLibrary.availablePresets.firstOrNull { it.deviceType == type } + if (matched != null) selectedBrand = matched + if (type == RemoteDeviceType.AIR_CONDITIONER) { + transmissionMode = TransmissionMode.DYNAMIC_SCRATCH + } else if (type == RemoteDeviceType.CUSTOM) { + transmissionMode = TransmissionMode.STATIC_SLOTS + } + typeDropdownExpanded = false + }, + ) + } + } + } + + // 2. 遥控器名称输入 + OutlinedTextField( + value = name, + onValueChange = { name = it }, + label = { Text("遥控器名称（如：客厅电视、我的遥控器）") }, + singleLine = true, + modifier = Modifier.fillMaxWidth().testTag("create_remote_name_input"), + ) + + // 3. 自定义遥控器时：选择初始布局模板 + if (selectedType == RemoteDeviceType.CUSTOM) { + ExposedDropdownMenuBox( + expanded = layoutDropdownExpanded, + onExpandedChange = { layoutDropdownExpanded = !layoutDropdownExpanded }, + ) { + OutlinedTextField( + value = when (selectedCustomLayout) { + PanelLayoutStyle.TV_NAV -> "📺 电视导航布局 (内置方向盘/音量/频道)" + PanelLayoutStyle.MEDIA_PLAYER -> "🎵 媒体播放器布局 (播放/快进/切歌)" + PanelLayoutStyle.GRID -> "🎛️ 自由网格布局 (可自由增删按键)" + PanelLayoutStyle.AC_COMPACT -> "❄️ 空调布局" + }, + onValueChange = {}, + readOnly = true, + label = { Text("选择初始布局模板") }, + trailingIcon = { ExposedDropdownMenuDefaults.TrailingIcon(expanded = layoutDropdownExpanded) }, + modifier = Modifier.fillMaxWidth().menuAnchor(), + ) + ExposedDropdownMenu( + expanded = layoutDropdownExpanded, + onDismissRequest = { layoutDropdownExpanded = false }, + ) { + DropdownMenuItem( + text = { Text("📺 电视导航布局 (内置方向盘/音量/频道)") }, + onClick = { + selectedCustomLayout = PanelLayoutStyle.TV_NAV + layoutDropdownExpanded = false + }, + ) + DropdownMenuItem( + text = { Text("🎵 媒体播放器布局 (播放/快进/切歌)") }, + onClick = { + selectedCustomLayout = PanelLayoutStyle.MEDIA_PLAYER + layoutDropdownExpanded = false + }, + ) + DropdownMenuItem( + text = { Text("🎛️ 自由网格布局 (可自由增删按键)") }, + onClick = { + selectedCustomLayout = PanelLayoutStyle.GRID + layoutDropdownExpanded = false + }, + ) + } + } + + Card( + colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surfaceVariant), + modifier = Modifier.fillMaxWidth(), + ) { + Text( + text = "💡 自定义学习按键由硬件固化录制，将自动分配独占静态槽位 (1..99)，创建后开启学习模式即可对准录码。", + fontSize = 12.sp, + modifier = Modifier.padding(10.dp), + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + } else if (filteredPresets.isNotEmpty()) { + // 码库预设设备：选择品牌型号 + ExposedDropdownMenuBox( + expanded = brandDropdownExpanded, + onExpandedChange = { brandDropdownExpanded = !brandDropdownExpanded }, + ) { + OutlinedTextField( + value = selectedBrand.displayName, + onValueChange = {}, + readOnly = true, + label = { Text(stringResource(R.string.infrared_hub_brand_label)) }, + trailingIcon = { ExposedDropdownMenuDefaults.TrailingIcon(expanded = brandDropdownExpanded) }, + modifier = Modifier.fillMaxWidth().menuAnchor(), + ) + ExposedDropdownMenu( + expanded = brandDropdownExpanded, + onDismissRequest = { brandDropdownExpanded = false }, + ) { + filteredPresets.forEach { preset -> + DropdownMenuItem( + text = { Text(preset.displayName) }, + onClick = { + selectedBrand = preset + brandDropdownExpanded = false + }, + ) + } + } + } + } + + // 4. 传输模式选择（仅对非空调、非纯自定义设备可选） + if (selectedType != RemoteDeviceType.AIR_CONDITIONER && selectedType != RemoteDeviceType.CUSTOM) { + Column(verticalArrangement = Arrangement.spacedBy(4.dp)) { + Text(stringResource(R.string.infrared_hub_trans_mode_label), fontWeight = FontWeight.Bold, fontSize = 13.sp) + + Row( + verticalAlignment = Alignment.CenterVertically, + modifier = Modifier.fillMaxWidth().clickable { transmissionMode = TransmissionMode.STATIC_SLOTS }, + ) { + RadioButton( + selected = transmissionMode == TransmissionMode.STATIC_SLOTS, + onClick = { transmissionMode = TransmissionMode.STATIC_SLOTS }, + ) + Column { + Text("🚀 静态独占槽位模式", fontWeight = FontWeight.Medium) + Text(stringResource(R.string.infrared_hub_trans_mode_static_desc), fontSize = 11.sp, color = MaterialTheme.colorScheme.onSurfaceVariant) + } + } + + Row( + verticalAlignment = Alignment.CenterVertically, + modifier = Modifier.fillMaxWidth().clickable { transmissionMode = TransmissionMode.DYNAMIC_SCRATCH }, + ) { + RadioButton( + selected = transmissionMode == TransmissionMode.DYNAMIC_SCRATCH, + onClick = { transmissionMode = TransmissionMode.DYNAMIC_SCRATCH }, + ) + Column { + Text("📦 动态写码模式", fontWeight = FontWeight.Medium) + Text(stringResource(R.string.infrared_hub_trans_mode_dynamic_desc), fontSize = 11.sp, color = MaterialTheme.colorScheme.onSurfaceVariant) + } + } + } + } else if (selectedType == RemoteDeviceType.AIR_CONDITIONER) { + Card( + colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.secondaryContainer.copy(alpha = 0.5f)), + modifier = Modifier.fillMaxWidth(), + ) { + Text( + text = "❄️ 空调多维状态自动采用 App 状态机 + 动态缓冲写码，杜绝状态踩踏并节省槽位。", + fontSize = 12.sp, + modifier = Modifier.padding(10.dp), + color = MaterialTheme.colorScheme.onSecondaryContainer, + ) + } + } + } + }, + confirmButton = { + Button( + onClick = { + val finalName = if (name.isNotBlank()) name.trim() else if (selectedType == RemoteDeviceType.CUSTOM) "自定义遥控器" else selectedBrand.displayName + val layout = if (selectedType == RemoteDeviceType.CUSTOM) selectedCustomLayout else null + onConfirm(finalName, selectedType, selectedBrand.id, transmissionMode, layout) + }, + modifier = Modifier.testTag("create_remote_confirm_button"), + ) { + Text(stringResource(R.string.infrared_dialog_confirm)) + } + }, + dismissButton = { + TextButton(onClick = onDismiss) { + Text(stringResource(R.string.infrared_dialog_cancel)) + } + }, + ) +} diff --git a/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/hub/InfraredHubUiState.kt b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/hub/InfraredHubUiState.kt new file mode 100644 index 0000000..06d10b5 --- /dev/null +++ b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/hub/InfraredHubUiState.kt @@ -0,0 +1,25 @@ +package com.flagship.abox.manager.infrared.hub + +import com.flagship.abox.manager.domain.DeviceName +import com.flagship.abox.manager.domain.ProviderProfileId +import com.flagship.abox.manager.domain.ProviderType +import com.flagship.abox.manager.domain.infrared.SlotQuotaSummary +import com.flagship.abox.manager.domain.infrared.VirtualRemote +import com.flagship.abox.manager.infrared.remote.UiText + +sealed interface HubUiMessage { + data class Info(val text: UiText) : HubUiMessage + data class Error(val text: UiText) : HubUiMessage + data object SessionInvalid : HubUiMessage +} + +data class InfraredHubUiState( + val profileId: ProviderProfileId? = null, + val providerType: ProviderType? = null, + val providerDisplayName: String? = null, + val savedDeviceName: DeviceName = DeviceName("红外控制器"), + val remotes: List = emptyList(), + val slotQuota: SlotQuotaSummary = SlotQuotaSummary(), + val loading: Boolean = true, + val message: HubUiMessage? = null, +) diff --git a/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/hub/InfraredHubViewModel.kt b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/hub/InfraredHubViewModel.kt new file mode 100644 index 0000000..9e69efd --- /dev/null +++ b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/hub/InfraredHubViewModel.kt @@ -0,0 +1,200 @@ +package com.flagship.abox.manager.infrared.hub + +import androidx.lifecycle.SavedStateHandle +import androidx.lifecycle.ViewModel +import androidx.lifecycle.viewModelScope +import com.flagship.abox.manager.domain.DeviceName +import com.flagship.abox.manager.domain.DomainError +import com.flagship.abox.manager.domain.DomainResult +import com.flagship.abox.manager.domain.ProviderProfile +import com.flagship.abox.manager.domain.ProviderProfileId +import com.flagship.abox.manager.domain.ProviderProfileStore +import com.flagship.abox.manager.domain.infrared.CreateVirtualRemote +import com.flagship.abox.manager.domain.infrared.DeleteVirtualRemote +import com.flagship.abox.manager.domain.infrared.InfraredDeviceConfigurationRepository +import com.flagship.abox.manager.domain.infrared.RemoteDeviceType +import com.flagship.abox.manager.domain.infrared.SlotQuotaSummary +import com.flagship.abox.manager.domain.infrared.TransmissionMode +import com.flagship.abox.manager.domain.infrared.VirtualRemote +import com.flagship.abox.manager.domain.infrared.VirtualRemoteId +import com.flagship.abox.manager.domain.infrared.VirtualRemoteRepository +import com.flagship.abox.manager.infrared.R +import com.flagship.abox.manager.infrared.remote.UiText +import dagger.hilt.android.lifecycle.HiltViewModel +import kotlinx.coroutines.ExperimentalCoroutinesApi +import kotlinx.coroutines.flow.Flow +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.SharingStarted +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.combine +import kotlinx.coroutines.flow.flatMapLatest +import kotlinx.coroutines.flow.flowOf +import kotlinx.coroutines.flow.map +import kotlinx.coroutines.flow.stateIn +import kotlinx.coroutines.launch +import javax.inject.Inject + +@OptIn(ExperimentalCoroutinesApi::class) +@HiltViewModel +class InfraredHubViewModel @Inject constructor( + savedStateHandle: SavedStateHandle, + private val providerProfileStore: ProviderProfileStore, + private val deviceConfigurationRepository: InfraredDeviceConfigurationRepository, + private val virtualRemoteRepository: VirtualRemoteRepository, + private val createVirtualRemote: CreateVirtualRemote, + private val deleteVirtualRemote: DeleteVirtualRemote, +) : ViewModel() { + + private val rawProfileId: String? = savedStateHandle["profileId"] + val profileId: ProviderProfileId? = rawProfileId?.takeIf { it.isNotBlank() }?.let { ProviderProfileId(it) } + + private val messageFlow = MutableStateFlow(null) + + private data class HubSnapshot( + val providerProfile: ProviderProfile? = null, + val savedDevice: DeviceName = DEFAULT_DEVICE_NAME, + val remotes: List = emptyList(), + val slotQuota: SlotQuotaSummary = SlotQuotaSummary(), + val configError: DomainError? = null, + ) + + private val hubSnapshotFlow: Flow = + if (profileId == null) { + flowOf(HubSnapshot()) + } else { + providerProfileStore.observeProfiles().flatMapLatest { profiles -> + val active = profiles.find { it.id == profileId } + deviceConfigurationRepository.observeDeviceName(profileId).flatMapLatest { devResult -> + when (devResult) { + is DomainResult.Failure -> flowOf(HubSnapshot(providerProfile = active, configError = devResult.error)) + is DomainResult.Success -> { + val deviceName = devResult.value ?: DEFAULT_DEVICE_NAME + combine( + virtualRemoteRepository.observeRemotes(profileId, deviceName), + virtualRemoteRepository.observeSlotQuota(profileId, deviceName), + ) { remotesResult, quotaResult -> + val remotes = if (remotesResult is DomainResult.Success) remotesResult.value else emptyList() + val quota = if (quotaResult is DomainResult.Success) quotaResult.value else SlotQuotaSummary() + HubSnapshot( + providerProfile = active, + savedDevice = deviceName, + remotes = remotes, + slotQuota = quota, + ) + } + } + } + } + } + } + + val state: StateFlow = combine( + hubSnapshotFlow, + messageFlow, + ) { snapshot, msg -> + val resolvedMessage = msg ?: snapshot.configError?.let { error -> + when (error) { + is DomainError.TokenInvalid, is DomainError.Authentication -> HubUiMessage.SessionInvalid + is DomainError.DeviceOffline -> HubUiMessage.Error( + UiText.StringResource(R.string.infrared_msg_device_offline, listOf(error.externalCode ?: "20206")), + ) + else -> HubUiMessage.Error( + error.detail?.let { UiText.DynamicString(it) } + ?: UiText.StringResource(R.string.infrared_msg_load_failed), + ) + } + } + + InfraredHubUiState( + profileId = profileId, + providerType = snapshot.providerProfile?.type, + providerDisplayName = snapshot.providerProfile?.displayName, + savedDeviceName = snapshot.savedDevice, + remotes = snapshot.remotes, + slotQuota = snapshot.slotQuota, + loading = false, + message = resolvedMessage, + ) + }.stateIn( + scope = viewModelScope, + started = SharingStarted.WhileSubscribed(5_000), + initialValue = InfraredHubUiState(profileId = profileId, loading = true), + ) + + fun createRemote( + name: String, + type: RemoteDeviceType, + brandModel: String? = null, + transmissionMode: TransmissionMode, + layoutStyle: com.flagship.abox.manager.domain.infrared.PanelLayoutStyle? = null, + ) { + val currentProfile = profileId ?: return + val currentDevice = state.value.savedDeviceName + viewModelScope.launch { + when (val res = createVirtualRemote( + profileId = currentProfile, + deviceName = currentDevice, + displayName = name, + type = type, + brandModel = brandModel, + transmissionMode = transmissionMode, + layoutStyle = layoutStyle, + )) { + is DomainResult.Success -> { + messageFlow.value = HubUiMessage.Info(UiText.DynamicString("已成功创建遥控器")) + } + is DomainResult.Failure -> handleDomainError(res.error) + } + } + } + + fun deleteRemote(remoteId: VirtualRemoteId) { + val currentProfile = profileId ?: return + viewModelScope.launch { + when (val res = deleteVirtualRemote(currentProfile, remoteId)) { + is DomainResult.Success -> { + messageFlow.value = HubUiMessage.Info(UiText.DynamicString("遥控器已删除")) + } + is DomainResult.Failure -> handleDomainError(res.error) + } + } + } + + fun saveDeviceName(newName: String) { + val currentProfile = profileId ?: return + val trimmed = newName.trim() + if (trimmed.isBlank()) { + messageFlow.value = HubUiMessage.Error(UiText.StringResource(R.string.infrared_msg_device_name_blank)) + return + } + viewModelScope.launch { + when (val res = deviceConfigurationRepository.setDeviceName(currentProfile, DeviceName(trimmed))) { + is DomainResult.Success -> { + messageFlow.value = HubUiMessage.Info(UiText.StringResource(R.string.infrared_msg_device_name_saved)) + } + is DomainResult.Failure -> handleDomainError(res.error) + } + } + } + + fun clearMessage() { + messageFlow.value = null + } + + private fun handleDomainError(error: DomainError) { + when (error) { + is DomainError.TokenInvalid, is DomainError.Authentication -> messageFlow.value = HubUiMessage.SessionInvalid + is DomainError.DeviceOffline -> messageFlow.value = HubUiMessage.Error( + UiText.StringResource(R.string.infrared_msg_device_offline, listOf(error.externalCode ?: "20206")), + ) + else -> messageFlow.value = HubUiMessage.Error( + error.detail?.let { UiText.DynamicString(it) } + ?: UiText.StringResource(R.string.infrared_msg_operation_failed), + ) + } + } + + companion object { + val DEFAULT_DEVICE_NAME = DeviceName("红外控制器") + } +} diff --git a/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/panel/RemotePanelScreen.kt b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/panel/RemotePanelScreen.kt new file mode 100644 index 0000000..34f4dd6 --- /dev/null +++ b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/panel/RemotePanelScreen.kt @@ -0,0 +1,801 @@ +package com.flagship.abox.manager.infrared.panel + +import androidx.compose.foundation.background +import androidx.compose.foundation.clickable +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.lazy.grid.GridCells +import androidx.compose.foundation.lazy.grid.LazyVerticalGrid +import androidx.compose.foundation.lazy.grid.items +import androidx.compose.foundation.shape.CircleShape +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material3.AlertDialog +import androidx.compose.material3.Button +import androidx.compose.material3.ButtonDefaults +import androidx.compose.material3.Card +import androidx.compose.material3.CardDefaults +import androidx.compose.material3.CircularProgressIndicator +import androidx.compose.material3.DropdownMenu +import androidx.compose.material3.DropdownMenuItem +import androidx.compose.material3.ExperimentalMaterial3Api +import androidx.compose.material3.FilterChip +import androidx.compose.material3.FilterChipDefaults +import androidx.compose.material3.Icon +import androidx.compose.material3.IconButton +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.OutlinedButton +import androidx.compose.material3.OutlinedTextField +import androidx.compose.material3.Scaffold +import androidx.compose.material3.SnackbarHost +import androidx.compose.material3.SnackbarHostState +import androidx.compose.material3.Surface +import androidx.compose.material3.Text +import androidx.compose.material3.TextButton +import androidx.compose.material3.TopAppBar +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.clip +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.platform.testTag +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp +import androidx.hilt.navigation.compose.hiltViewModel +import androidx.lifecycle.compose.collectAsStateWithLifecycle +import com.flagship.abox.manager.designsystem.ABoxSurface +import com.flagship.abox.manager.domain.infrared.AcFanSpeed +import com.flagship.abox.manager.domain.infrared.AcMode +import com.flagship.abox.manager.domain.infrared.AcStateSnapshot +import com.flagship.abox.manager.domain.infrared.InfraredKeyStatus +import com.flagship.abox.manager.domain.infrared.PanelLayoutStyle +import com.flagship.abox.manager.domain.infrared.RemoteDeviceType +import com.flagship.abox.manager.domain.infrared.RemoteKeyBinding +import com.flagship.abox.manager.domain.infrared.VirtualRemote +import com.flagship.abox.manager.infrared.R +import com.flagship.abox.manager.infrared.remote.UiText + +@Composable +fun RemotePanelRoute( + onBack: () -> Unit, + onSessionInvalid: () -> Unit, + viewModel: RemotePanelViewModel = hiltViewModel(), +) { + val state by viewModel.state.collectAsStateWithLifecycle() + + RemotePanelScreen( + state = state, + onBack = onBack, + onSessionInvalid = onSessionInvalid, + onButtonClick = viewModel::onButtonClick, + onToggleLearnMode = viewModel::toggleLearnMode, + onAddCustomButton = viewModel::addCustomButton, + onDeleteButton = viewModel::deleteButton, + onToggleAcPower = viewModel::toggleAcPower, + onAdjustAcTemp = viewModel::adjustAcTemperature, + onSetAcMode = viewModel::setAcMode, + onSetFanSpeed = viewModel::setAcFanSpeed, + onToggleAcVerticalSwing = viewModel::toggleAcVerticalSwing, + onToggleAcHorizontalSwing = viewModel::toggleAcHorizontalSwing, + onToggleAcEco = viewModel::toggleAcEco, + onMessageShown = viewModel::clearMessage, + ) +} + +@OptIn(ExperimentalMaterial3Api::class) +@Composable +internal fun RemotePanelScreen( + state: RemotePanelUiState, + onBack: () -> Unit, + onSessionInvalid: () -> Unit, + onButtonClick: (String) -> Unit, + onToggleLearnMode: () -> Unit, + onAddCustomButton: (String) -> Unit, + onDeleteButton: (String) -> Unit, + onToggleAcPower: () -> Unit, + onAdjustAcTemp: (Int) -> Unit, + onSetAcMode: (AcMode) -> Unit, + onSetFanSpeed: (AcFanSpeed) -> Unit, + onToggleAcVerticalSwing: () -> Unit, + onToggleAcHorizontalSwing: () -> Unit, + onToggleAcEco: () -> Unit, + onMessageShown: () -> Unit, +) { + val snackbarHostState = remember { SnackbarHostState() } + val context = LocalContext.current + + var showAddKeyDialog by remember { mutableStateOf(false) } + + LaunchedEffect(state.message) { + state.message?.let { msg -> + when (msg) { + is PanelUiMessage.Info -> { + val text = when (val t = msg.text) { + is UiText.DynamicString -> t.value + is UiText.StringResource -> context.getString(t.resId, *t.args.toTypedArray()) + } + snackbarHostState.showSnackbar(text) + onMessageShown() + } + is PanelUiMessage.Error -> { + val text = when (val t = msg.text) { + is UiText.DynamicString -> t.value + is UiText.StringResource -> context.getString(t.resId, *t.args.toTypedArray()) + } + snackbarHostState.showSnackbar(text) + onMessageShown() + } + is PanelUiMessage.SessionInvalid -> { + onSessionInvalid() + onMessageShown() + } + } + } + } + + Scaffold( + topBar = { + TopAppBar( + title = { + Column { + Text( + text = state.remote?.displayName ?: stringResource(R.string.infrared_remote_title), + fontWeight = FontWeight.Bold, + fontSize = 18.sp, + ) + state.remote?.let { + val layoutLabel = when (it.layoutStyle) { + PanelLayoutStyle.TV_NAV -> "电视导航布局" + PanelLayoutStyle.MEDIA_PLAYER -> "媒体播放布局" + PanelLayoutStyle.GRID -> "自由网格布局" + PanelLayoutStyle.AC_COMPACT -> "空调全状态布局" + } + Text( + text = layoutLabel, + fontSize = 11.sp, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + } + }, + navigationIcon = { + TextButton(onClick = onBack) { + Text(stringResource(R.string.infrared_back)) + } + }, + actions = { + // 非空调面板显示学习模式开关 + if (state.remote?.layoutStyle != PanelLayoutStyle.AC_COMPACT) { + FilterChip( + selected = state.isLearnMode, + onClick = onToggleLearnMode, + label = { Text(if (state.isLearnMode) "🔴 录制中" else "⚪ 学习模式") }, + colors = FilterChipDefaults.filterChipColors( + selectedContainerColor = Color(0xFFFF5252), + selectedLabelColor = Color.White, + ), + modifier = Modifier.testTag("learn_mode_toggle"), + ) + } + }, + ) + }, + snackbarHost = { SnackbarHost(snackbarHostState) }, + ) { innerPadding -> + ABoxSurface( + modifier = Modifier + .fillMaxSize() + .padding(innerPadding), + ) { + val remote = state.remote + if (remote == null) { + Box(modifier = Modifier.fillMaxSize(), contentAlignment = Alignment.Center) { + CircularProgressIndicator() + } + } else { + Column(modifier = Modifier.fillMaxSize()) { + // 学习模式指示横幅 + if (state.isLearnMode) { + Card( + colors = CardDefaults.cardColors(containerColor = Color(0xFFFFEBEE)), + shape = RoundedCornerShape(0.dp), + modifier = Modifier.fillMaxWidth(), + ) { + Row( + modifier = Modifier.fillMaxWidth().padding(horizontal = 16.dp, vertical = 10.dp), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(8.dp), + ) { + Text("🔴", fontSize = 16.sp) + Text( + text = "学习模式已开启：点击任意按键，然后将物理实体遥控器对准转发器按下即可录码", + color = Color(0xFFC62828), + fontSize = 12.sp, + fontWeight = FontWeight.Medium, + ) + } + } + } + + // 面板内容区 + Box(modifier = Modifier.fillMaxSize().weight(1f)) { + when (remote.layoutStyle) { + PanelLayoutStyle.AC_COMPACT -> { + AcControlPanel( + acState = state.acState, + onTogglePower = onToggleAcPower, + onAdjustTemp = onAdjustAcTemp, + onSetMode = onSetAcMode, + onSetFanSpeed = onSetFanSpeed, + onToggleVSwing = onToggleAcVerticalSwing, + onToggleHSwing = onToggleAcHorizontalSwing, + onToggleEco = onToggleAcEco, + ) + } + PanelLayoutStyle.TV_NAV -> { + TvControlPanel( + bindings = state.bindings, + isLearnMode = state.isLearnMode, + learningButtonId = state.learningButtonId, + sendingButtonId = state.sendingButtonId, + onButtonClick = onButtonClick, + ) + } + PanelLayoutStyle.MEDIA_PLAYER -> { + MediaPlayerControlPanel( + bindings = state.bindings, + isLearnMode = state.isLearnMode, + learningButtonId = state.learningButtonId, + sendingButtonId = state.sendingButtonId, + onButtonClick = onButtonClick, + ) + } + PanelLayoutStyle.GRID -> { + GenericGridControlPanel( + bindings = state.bindings, + isLearnMode = state.isLearnMode, + learningButtonId = state.learningButtonId, + sendingButtonId = state.sendingButtonId, + onButtonClick = onButtonClick, + onDeleteButton = onDeleteButton, + onAddButton = { showAddKeyDialog = true }, + ) + } + } + } + } + } + } + } + + if (showAddKeyDialog) { + AddCustomKeyDialog( + onDismiss = { showAddKeyDialog = false }, + onConfirm = { name -> + onAddCustomButton(name) + showAddKeyDialog = false + }, + ) + } +} + +@Composable +private fun AcControlPanel( + acState: AcStateSnapshot, + onTogglePower: () -> Unit, + onAdjustTemp: (Int) -> Unit, + onSetMode: (AcMode) -> Unit, + onSetFanSpeed: (AcFanSpeed) -> Unit, + onToggleVSwing: () -> Unit, + onToggleHSwing: () -> Unit, + onToggleEco: () -> Unit, +) { + Column( + modifier = Modifier + .fillMaxSize() + .padding(16.dp), + horizontalAlignment = Alignment.CenterHorizontally, + verticalArrangement = Arrangement.spacedBy(16.dp), + ) { + Card( + modifier = Modifier.fillMaxWidth(), + colors = CardDefaults.cardColors( + containerColor = if (acState.power) MaterialTheme.colorScheme.primaryContainer else MaterialTheme.colorScheme.surfaceVariant, + ), + ) { + Column( + modifier = Modifier + .fillMaxWidth() + .padding(20.dp), + horizontalAlignment = Alignment.CenterHorizontally, + verticalArrangement = Arrangement.spacedBy(10.dp), + ) { + Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.SpaceBetween, + verticalAlignment = Alignment.CenterVertically, + ) { + Text( + text = if (acState.power) "● 运行中" else "○ 已关机", + color = if (acState.power) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.onSurfaceVariant, + fontWeight = FontWeight.Bold, + ) + IconButton( + onClick = onTogglePower, + modifier = Modifier + .size(44.dp) + .clip(CircleShape) + .background(if (acState.power) Color(0xFFFF5252) else MaterialTheme.colorScheme.outline) + .testTag("ac_power_toggle"), + ) { + Text("⏻", color = Color.White, fontSize = 20.sp, fontWeight = FontWeight.Bold) + } + } + + Text( + text = "${acState.temperature}°C", + fontSize = 64.sp, + fontWeight = FontWeight.Black, + color = if (acState.power) MaterialTheme.colorScheme.onPrimaryContainer else MaterialTheme.colorScheme.onSurfaceVariant, + ) + + Text( + text = "模式: ${acState.mode.name} | 风速: ${acState.fanSpeed.name} | 扫风: ${if (acState.verticalSwing) "开" else "关"}", + style = MaterialTheme.typography.bodyMedium, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + + Row( + horizontalArrangement = Arrangement.spacedBy(32.dp), + verticalAlignment = Alignment.CenterVertically, + ) { + Button( + onClick = { onAdjustTemp(-1) }, + modifier = Modifier.size(56.dp).testTag("ac_temp_down"), + shape = CircleShape, + ) { + Text("－", fontSize = 24.sp, fontWeight = FontWeight.Bold) + } + Button( + onClick = { onAdjustTemp(1) }, + modifier = Modifier.size(56.dp).testTag("ac_temp_up"), + shape = CircleShape, + ) { + Text("＋", fontSize = 24.sp, fontWeight = FontWeight.Bold) + } + } + } + } + + Text("模式选择", style = MaterialTheme.typography.titleMedium.copy(fontWeight = FontWeight.Bold), modifier = Modifier.align(Alignment.Start)) + Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.spacedBy(8.dp), + ) { + AcMode.entries.forEach { mode -> + FilterChip( + selected = acState.mode == mode, + onClick = { onSetMode(mode) }, + label = { Text(mode.name) }, + modifier = Modifier.weight(1f), + ) + } + } + + Text("风速调节", style = MaterialTheme.typography.titleMedium.copy(fontWeight = FontWeight.Bold), modifier = Modifier.align(Alignment.Start)) + Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.spacedBy(8.dp), + ) { + AcFanSpeed.entries.forEach { speed -> + FilterChip( + selected = acState.fanSpeed == speed, + onClick = { onSetFanSpeed(speed) }, + label = { Text(speed.name) }, + modifier = Modifier.weight(1f), + ) + } + } + + Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.spacedBy(8.dp), + ) { + FilterChip( + selected = acState.verticalSwing, + onClick = onToggleVSwing, + label = { Text("↕ 上下扫风") }, + modifier = Modifier.weight(1f), + ) + FilterChip( + selected = acState.horizontalSwing, + onClick = onToggleHSwing, + label = { Text("↔ 左右扫风") }, + modifier = Modifier.weight(1f), + ) + FilterChip( + selected = acState.eco, + onClick = onToggleEco, + label = { Text("🌱 节能 ECO") }, + modifier = Modifier.weight(1f), + ) + } + } +} + +@Composable +private fun TvControlPanel( + bindings: List, + isLearnMode: Boolean, + learningButtonId: String?, + sendingButtonId: String?, + onButtonClick: (String) -> Unit, +) { + val bindingMap = remember(bindings) { bindings.associateBy { it.buttonId } } + + Column( + modifier = Modifier + .fillMaxSize() + .padding(16.dp), + horizontalAlignment = Alignment.CenterHorizontally, + verticalArrangement = Arrangement.spacedBy(16.dp), + ) { + // 顶部控制行 (电源、静音、信号源) + Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.SpaceAround, + verticalAlignment = Alignment.CenterVertically, + ) { + InteractiveRemoteButton("TV_POWER", "⏻ 电源", Color(0xFFFF5252), bindingMap["TV_POWER"], isLearnMode, learningButtonId, sendingButtonId, onButtonClick) + InteractiveRemoteButton("TV_MUTE", "🔇 静音", MaterialTheme.colorScheme.secondary, bindingMap["TV_MUTE"], isLearnMode, learningButtonId, sendingButtonId, onButtonClick) + InteractiveRemoteButton("TV_SOURCE", "📺 信号源", MaterialTheme.colorScheme.secondary, bindingMap["TV_SOURCE"], isLearnMode, learningButtonId, sendingButtonId, onButtonClick) + } + + Spacer(modifier = Modifier.height(8.dp)) + + // 中部五向方向导航盘 + Card( + shape = CircleShape, + modifier = Modifier.size(220.dp), + colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surfaceVariant), + ) { + Box(modifier = Modifier.fillMaxSize(), contentAlignment = Alignment.Center) { + // 上 + IconButton( + onClick = { onButtonClick("TV_NAV_UP") }, + modifier = Modifier.align(Alignment.TopCenter).padding(top = 10.dp).testTag("tv_nav_up"), + ) { + ButtonIndicatorText("TV_NAV_UP", "▲", learningButtonId, sendingButtonId) + } + + // 下 + IconButton( + onClick = { onButtonClick("TV_NAV_DOWN") }, + modifier = Modifier.align(Alignment.BottomCenter).padding(bottom = 10.dp).testTag("tv_nav_down"), + ) { + ButtonIndicatorText("TV_NAV_DOWN", "▼", learningButtonId, sendingButtonId) + } + + // 左 + IconButton( + onClick = { onButtonClick("TV_NAV_LEFT") }, + modifier = Modifier.align(Alignment.CenterStart).padding(start = 10.dp).testTag("tv_nav_left"), + ) { + ButtonIndicatorText("TV_NAV_LEFT", "◀", learningButtonId, sendingButtonId) + } + + // 右 + IconButton( + onClick = { onButtonClick("TV_NAV_RIGHT") }, + modifier = Modifier.align(Alignment.CenterEnd).padding(end = 10.dp).testTag("tv_nav_right"), + ) { + ButtonIndicatorText("TV_NAV_RIGHT", "▶", learningButtonId, sendingButtonId) + } + + // OK 居中大按钮 + Button( + onClick = { onButtonClick("TV_OK") }, + shape = CircleShape, + modifier = Modifier.size(76.dp).testTag("tv_ok"), + ) { + ButtonIndicatorText("TV_OK", "OK", learningButtonId, sendingButtonId) + } + } + } + + // 辅助按键行 (返回、主页、菜单) + Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.SpaceAround, + ) { + InteractiveRemoteButton("TV_BACK", "↩ 返回", MaterialTheme.colorScheme.outline, bindingMap["TV_BACK"], isLearnMode, learningButtonId, sendingButtonId, onButtonClick) + InteractiveRemoteButton("TV_HOME", "⌂ 主页", MaterialTheme.colorScheme.outline, bindingMap["TV_HOME"], isLearnMode, learningButtonId, sendingButtonId, onButtonClick) + InteractiveRemoteButton("TV_MENU", "☰ 菜单", MaterialTheme.colorScheme.outline, bindingMap["TV_MENU"], isLearnMode, learningButtonId, sendingButtonId, onButtonClick) + } + + // 底部音量与频道调节柱 + Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.SpaceEvenly, + ) { + Column( + horizontalAlignment = Alignment.CenterHorizontally, + verticalArrangement = Arrangement.spacedBy(6.dp), + ) { + Text("音量 VOL", fontWeight = FontWeight.Bold, fontSize = 12.sp) + Button(onClick = { onButtonClick("TV_VOL_UP") }, modifier = Modifier.size(54.dp), shape = RoundedCornerShape(12.dp)) { + ButtonIndicatorText("TV_VOL_UP", "+", learningButtonId, sendingButtonId) + } + Button(onClick = { onButtonClick("TV_VOL_DOWN") }, modifier = Modifier.size(54.dp), shape = RoundedCornerShape(12.dp)) { + ButtonIndicatorText("TV_VOL_DOWN", "-", learningButtonId, sendingButtonId) + } + } + + Column( + horizontalAlignment = Alignment.CenterHorizontally, + verticalArrangement = Arrangement.spacedBy(6.dp), + ) { + Text("频道 CH", fontWeight = FontWeight.Bold, fontSize = 12.sp) + Button(onClick = { onButtonClick("TV_CH_UP") }, modifier = Modifier.size(54.dp), shape = RoundedCornerShape(12.dp)) { + ButtonIndicatorText("TV_CH_UP", "▲", learningButtonId, sendingButtonId) + } + Button(onClick = { onButtonClick("TV_CH_DOWN") }, modifier = Modifier.size(54.dp), shape = RoundedCornerShape(12.dp)) { + ButtonIndicatorText("TV_CH_DOWN", "▼", learningButtonId, sendingButtonId) + } + } + } + } +} + +@Composable +private fun MediaPlayerControlPanel( + bindings: List, + isLearnMode: Boolean, + learningButtonId: String?, + sendingButtonId: String?, + onButtonClick: (String) -> Unit, +) { + val bindingMap = remember(bindings) { bindings.associateBy { it.buttonId } } + + Column( + modifier = Modifier.fillMaxSize().padding(24.dp), + horizontalAlignment = Alignment.CenterHorizontally, + verticalArrangement = Arrangement.spacedBy(20.dp), + ) { + Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.SpaceBetween, + ) { + InteractiveRemoteButton("MEDIA_POWER", "⏻ 电源", Color(0xFFFF5252), bindingMap["MEDIA_POWER"], isLearnMode, learningButtonId, sendingButtonId, onButtonClick) + InteractiveRemoteButton("MEDIA_MUTE", "🔇 静音", MaterialTheme.colorScheme.secondary, bindingMap["MEDIA_MUTE"], isLearnMode, learningButtonId, sendingButtonId, onButtonClick) + } + + Spacer(modifier = Modifier.height(16.dp)) + + // 播放控制中心大圆盘 + Card( + shape = CircleShape, + modifier = Modifier.size(240.dp), + colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surfaceVariant), + ) { + Box(modifier = Modifier.fillMaxSize(), contentAlignment = Alignment.Center) { + // 快进 >> + IconButton(onClick = { onButtonClick("MEDIA_FF") }, modifier = Modifier.align(Alignment.CenterEnd).padding(end = 12.dp)) { + ButtonIndicatorText("MEDIA_FF", "⏩", learningButtonId, sendingButtonId) + } + // 快退 << + IconButton(onClick = { onButtonClick("MEDIA_REWIND") }, modifier = Modifier.align(Alignment.CenterStart).padding(start = 12.dp)) { + ButtonIndicatorText("MEDIA_REWIND", "⏪", learningButtonId, sendingButtonId) + } + // 上一曲 + IconButton(onClick = { onButtonClick("MEDIA_PREV") }, modifier = Modifier.align(Alignment.TopCenter).padding(top = 12.dp)) { + ButtonIndicatorText("MEDIA_PREV", "⏮", learningButtonId, sendingButtonId) + } + // 下一曲 + IconButton(onClick = { onButtonClick("MEDIA_NEXT") }, modifier = Modifier.align(Alignment.BottomCenter).padding(bottom = 12.dp)) { + ButtonIndicatorText("MEDIA_NEXT", "⏭", learningButtonId, sendingButtonId) + } + // 播放/暂停 + Button(onClick = { onButtonClick("MEDIA_PLAY_PAUSE") }, shape = CircleShape, modifier = Modifier.size(80.dp)) { + ButtonIndicatorText("MEDIA_PLAY_PAUSE", "⏯", learningButtonId, sendingButtonId) + } + } + } + } +} + +@Composable +private fun GenericGridControlPanel( + bindings: List, + isLearnMode: Boolean, + learningButtonId: String?, + sendingButtonId: String?, + onButtonClick: (String) -> Unit, + onDeleteButton: (String) -> Unit, + onAddButton: () -> Unit, +) { + Column( + modifier = Modifier.fillMaxSize().padding(16.dp), + verticalArrangement = Arrangement.spacedBy(12.dp), + ) { + Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.SpaceBetween, + verticalAlignment = Alignment.CenterVertically, + ) { + Text("按键列表 (${bindings.size})", fontWeight = FontWeight.Bold, fontSize = 16.sp) + Button(onClick = onAddButton, modifier = Modifier.testTag("grid_add_key_button")) { + Text("➕ 添加按键") + } + } + + if (bindings.isEmpty()) { + Box(modifier = Modifier.fillMaxWidth().weight(1f), contentAlignment = Alignment.Center) { + Text("暂无自定义按键，点击上方【➕ 添加按键】新建", color = MaterialTheme.colorScheme.onSurfaceVariant) + } + } else { + LazyVerticalGrid( + columns = GridCells.Fixed(2), + modifier = Modifier.fillMaxSize().weight(1f), + horizontalArrangement = Arrangement.spacedBy(12.dp), + verticalArrangement = Arrangement.spacedBy(12.dp), + ) { + items(bindings, key = { it.id }) { binding -> + GridButtonCard( + binding = binding, + isLearnMode = isLearnMode, + isLearning = learningButtonId == binding.buttonId, + isSending = sendingButtonId == binding.buttonId, + onClick = { onButtonClick(binding.buttonId) }, + onDelete = { onDeleteButton(binding.buttonId) }, + ) + } + } + } + } +} + +@Composable +private fun GridButtonCard( + binding: RemoteKeyBinding, + isLearnMode: Boolean, + isLearning: Boolean, + isSending: Boolean, + onClick: () -> Unit, + onDelete: () -> Unit, +) { + Card( + modifier = Modifier + .fillMaxWidth() + .height(76.dp) + .clickable(onClick = onClick) + .testTag("generic_btn_${binding.buttonId}"), + elevation = CardDefaults.cardElevation(defaultElevation = 2.dp), + ) { + Row( + modifier = Modifier.fillMaxSize().padding(horizontal = 12.dp, vertical = 8.dp), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.SpaceBetween, + ) { + Column(modifier = Modifier.weight(1f)) { + Text(binding.displayName, fontWeight = FontWeight.Bold, fontSize = 15.sp) + val statusText = when { + isLearning -> "🟡 正在录制信号..." + binding.status == InfraredKeyStatus.READY -> "🟢 已就绪 (Slot ${binding.assignedSlot ?: "动态"})" + else -> "⚪ 待录制 (点击录码)" + } + Text(statusText, fontSize = 11.sp, color = MaterialTheme.colorScheme.onSurfaceVariant) + } + + if (isSending || isLearning) { + CircularProgressIndicator(modifier = Modifier.size(20.dp)) + } else { + // 始终提供删除操作按钮 + IconButton( + onClick = onDelete, + modifier = Modifier.size(36.dp).testTag("delete_key_${binding.buttonId}"), + ) { + Text("🗑️", fontSize = 15.sp) + } + } + } + } +} + +@Composable +private fun InteractiveRemoteButton( + buttonId: String, + label: String, + containerColor: Color, + binding: RemoteKeyBinding?, + isLearnMode: Boolean, + learningButtonId: String?, + sendingButtonId: String?, + onButtonClick: (String) -> Unit, +) { + val isUnlearned = binding != null && binding.status != InfraredKeyStatus.READY + + Button( + onClick = { onButtonClick(buttonId) }, + colors = ButtonDefaults.buttonColors( + containerColor = when { + learningButtonId == buttonId -> Color(0xFFFF9800) + isUnlearned -> MaterialTheme.colorScheme.surfaceVariant + else -> containerColor + }, + contentColor = if (isUnlearned) MaterialTheme.colorScheme.onSurfaceVariant else Color.White, + ), + modifier = Modifier.testTag("tv_btn_$buttonId"), + ) { + ButtonIndicatorText(buttonId, label, learningButtonId, sendingButtonId) + } +} + +@Composable +private fun ButtonIndicatorText( + buttonId: String, + defaultLabel: String, + learningButtonId: String?, + sendingButtonId: String?, +) { + if (learningButtonId == buttonId) { + Text("🟡 录制中", fontSize = 12.sp, fontWeight = FontWeight.Bold) + } else if (sendingButtonId == buttonId) { + CircularProgressIndicator(modifier = Modifier.size(16.dp), color = Color.White) + } else { + Text(defaultLabel, fontWeight = FontWeight.Bold) + } +} + +@Composable +private fun AddCustomKeyDialog( + onDismiss: () -> Unit, + onConfirm: (name: String) -> Unit, +) { + var name by remember { mutableStateOf("") } + AlertDialog( + onDismissRequest = onDismiss, + title = { Text("添加自定义按键") }, + text = { + Column(verticalArrangement = Arrangement.spacedBy(8.dp)) { + Text("输入按键显示名称，创建后点击按键或开启【学习模式】即可录制实体按键：", fontSize = 13.sp) + OutlinedTextField( + value = name, + onValueChange = { name = it }, + label = { Text("按键名称（如：静音、低音增强）") }, + singleLine = true, + modifier = Modifier.fillMaxWidth().testTag("add_key_name_input"), + ) + } + }, + confirmButton = { + Button( + onClick = { + if (name.isNotBlank()) onConfirm(name.trim()) + }, + modifier = Modifier.testTag("add_key_confirm_button"), + ) { + Text("确认添加") + } + }, + dismissButton = { + TextButton(onClick = onDismiss) { Text("取消") } + }, + ) +} diff --git a/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/panel/RemotePanelUiState.kt b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/panel/RemotePanelUiState.kt new file mode 100644 index 0000000..da8de39 --- /dev/null +++ b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/panel/RemotePanelUiState.kt @@ -0,0 +1,25 @@ +package com.flagship.abox.manager.infrared.panel + +import com.flagship.abox.manager.domain.ProviderProfileId +import com.flagship.abox.manager.domain.infrared.AcStateSnapshot +import com.flagship.abox.manager.domain.infrared.RemoteKeyBinding +import com.flagship.abox.manager.domain.infrared.VirtualRemote +import com.flagship.abox.manager.infrared.remote.UiText + +sealed interface PanelUiMessage { + data class Info(val text: UiText) : PanelUiMessage + data class Error(val text: UiText) : PanelUiMessage + data object SessionInvalid : PanelUiMessage +} + +data class RemotePanelUiState( + val profileId: ProviderProfileId? = null, + val remote: VirtualRemote? = null, + val bindings: List = emptyList(), + val acState: AcStateSnapshot = AcStateSnapshot(), + val isLearnMode: Boolean = false, + val learningButtonId: String? = null, + val sendingButtonId: String? = null, + val loading: Boolean = true, + val message: PanelUiMessage? = null, +) diff --git a/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/panel/RemotePanelViewModel.kt b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/panel/RemotePanelViewModel.kt new file mode 100644 index 0000000..221dad3 --- /dev/null +++ b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/panel/RemotePanelViewModel.kt @@ -0,0 +1,297 @@ +package com.flagship.abox.manager.infrared.panel + +import androidx.lifecycle.SavedStateHandle +import androidx.lifecycle.ViewModel +import androidx.lifecycle.viewModelScope +import com.flagship.abox.manager.domain.DomainError +import com.flagship.abox.manager.domain.DomainResult +import com.flagship.abox.manager.domain.ProviderProfileId +import com.flagship.abox.manager.domain.infrared.AcFanSpeed +import com.flagship.abox.manager.domain.infrared.AcMode +import com.flagship.abox.manager.domain.infrared.AcStateSnapshot +import com.flagship.abox.manager.domain.infrared.AddVirtualRemoteKey +import com.flagship.abox.manager.domain.infrared.DeleteVirtualRemoteKey +import com.flagship.abox.manager.domain.infrared.LearnVirtualRemoteKey +import com.flagship.abox.manager.domain.infrared.PanelLayoutStyle +import com.flagship.abox.manager.domain.infrared.RemoteKeyBinding +import com.flagship.abox.manager.domain.infrared.SendVirtualRemoteAction +import com.flagship.abox.manager.domain.infrared.UpdateVirtualRemoteLayout +import com.flagship.abox.manager.domain.infrared.VirtualRemote +import com.flagship.abox.manager.domain.infrared.VirtualRemoteId +import com.flagship.abox.manager.domain.infrared.VirtualRemoteRepository +import com.flagship.abox.manager.infrared.R +import com.flagship.abox.manager.infrared.remote.UiText +import dagger.hilt.android.lifecycle.HiltViewModel +import kotlinx.coroutines.ExperimentalCoroutinesApi +import kotlinx.coroutines.Job +import kotlinx.coroutines.delay +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.SharingStarted +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.combine +import kotlinx.coroutines.flow.flatMapLatest +import kotlinx.coroutines.flow.flowOf +import kotlinx.coroutines.flow.stateIn +import kotlinx.coroutines.launch +import javax.inject.Inject + +@OptIn(ExperimentalCoroutinesApi::class) +@HiltViewModel +class RemotePanelViewModel @Inject constructor( + savedStateHandle: SavedStateHandle, + private val virtualRemoteRepository: VirtualRemoteRepository, + private val sendVirtualRemoteAction: SendVirtualRemoteAction, + private val learnVirtualRemoteKey: LearnVirtualRemoteKey, + private val addVirtualRemoteKey: AddVirtualRemoteKey, + private val deleteVirtualRemoteKey: DeleteVirtualRemoteKey, + private val updateVirtualRemoteLayout: UpdateVirtualRemoteLayout, +) : ViewModel() { + + private val rawProfileId: String? = savedStateHandle["profileId"] + val profileId: ProviderProfileId? = rawProfileId?.takeIf { it.isNotBlank() }?.let { ProviderProfileId(it) } + + private val rawRemoteId: String? = savedStateHandle["remoteId"] + val remoteId: VirtualRemoteId? = rawRemoteId?.takeIf { it.isNotBlank() }?.let { VirtualRemoteId(it) } + + private val isLearnModeFlow = MutableStateFlow(false) + private val learningButtonIdFlow = MutableStateFlow(null) + private val sendingButtonIdFlow = MutableStateFlow(null) + private val localAcStateFlow = MutableStateFlow(null) + private val messageFlow = MutableStateFlow(null) + private var acDebounceJob: Job? = null + + private val remoteFlow = if (profileId == null || remoteId == null) { + flowOf(null) + } else { + virtualRemoteRepository.observeRemote(profileId, remoteId).flatMapLatest { res -> + val remote = if (res is DomainResult.Success) res.value else null + flowOf(remote) + } + } + + private val bindingsFlow = if (remoteId == null) { + flowOf(emptyList()) + } else { + virtualRemoteRepository.observeKeyBindings(remoteId).flatMapLatest { res -> + val list = if (res is DomainResult.Success) res.value else emptyList() + flowOf(list) + } + } + + private data class RemoteSnapshot( + val remote: VirtualRemote?, + val bindings: List, + ) + + private val snapshotFlow = combine(remoteFlow, bindingsFlow) { remote, bindings -> + RemoteSnapshot(remote, bindings) + } + + private data class ActionState( + val isLearnMode: Boolean, + val learningButtonId: String?, + val sendingButtonId: String?, + ) + + private val actionStateFlow = combine( + isLearnModeFlow, + learningButtonIdFlow, + sendingButtonIdFlow, + ) { isLearn, learningBtn, sendingBtn -> + ActionState(isLearn, learningBtn, sendingBtn) + } + + val state: StateFlow = combine( + snapshotFlow, + localAcStateFlow, + actionStateFlow, + messageFlow, + ) { snapshot, localAc, action, msg -> + val resolvedAc = localAc ?: snapshot.remote?.acState ?: AcStateSnapshot() + RemotePanelUiState( + profileId = profileId, + remote = snapshot.remote, + bindings = snapshot.bindings, + acState = resolvedAc, + isLearnMode = action.isLearnMode, + learningButtonId = action.learningButtonId, + sendingButtonId = action.sendingButtonId, + loading = snapshot.remote == null, + message = msg, + ) + }.stateIn( + scope = viewModelScope, + started = SharingStarted.WhileSubscribed(5_000), + initialValue = RemotePanelUiState(profileId = profileId, loading = true), + ) + + fun toggleLearnMode() { + val newMode = !isLearnModeFlow.value + isLearnModeFlow.value = newMode + if (newMode) { + messageFlow.value = PanelUiMessage.Info(UiText.StringResource(R.string.infrared_msg_learning_mode_enabled)) + } + } + + fun onButtonClick(buttonId: String) { + if (isLearnModeFlow.value) { + learnButton(buttonId) + } else { + sendButton(buttonId) + } + } + + private fun sendButton(buttonId: String) { + val currentProfile = profileId ?: return + val currentRemoteId = remoteId ?: return + if (state.value.sendingButtonId != null || state.value.learningButtonId != null) return + + sendingButtonIdFlow.value = buttonId + viewModelScope.launch { + try { + when (val res = sendVirtualRemoteAction.sendButton(currentProfile, currentRemoteId, buttonId)) { + is DomainResult.Success -> { + messageFlow.value = PanelUiMessage.Info(UiText.StringResource(R.string.infrared_msg_signal_sent, listOf(buttonId))) + } + is DomainResult.Failure -> handleDomainError(res.error) + } + } finally { + sendingButtonIdFlow.value = null + } + } + } + + fun learnButton(buttonId: String) { + val currentProfile = profileId ?: return + val currentRemoteId = remoteId ?: return + if (state.value.learningButtonId != null) return + + learningButtonIdFlow.value = buttonId + viewModelScope.launch { + try { + when (val res = learnVirtualRemoteKey(currentProfile, currentRemoteId, buttonId)) { + is DomainResult.Success -> { + messageFlow.value = PanelUiMessage.Info(UiText.StringResource(R.string.infrared_msg_learned_success, listOf(buttonId))) + } + is DomainResult.Failure -> handleDomainError(res.error) + } + } finally { + learningButtonIdFlow.value = null + } + } + } + + fun addCustomButton(displayName: String) { + val currentProfile = profileId ?: return + val currentRemoteId = remoteId ?: return + viewModelScope.launch { + when (val res = addVirtualRemoteKey(currentProfile, currentRemoteId, displayName)) { + is DomainResult.Success -> { + messageFlow.value = PanelUiMessage.Info(UiText.DynamicString("已添加按键【${displayName}】，开启学习模式即可录制")) + } + is DomainResult.Failure -> handleDomainError(res.error) + } + } + } + + fun deleteButton(buttonId: String) { + val currentProfile = profileId ?: return + val currentRemoteId = remoteId ?: return + viewModelScope.launch { + when (val res = deleteVirtualRemoteKey(currentProfile, currentRemoteId, buttonId)) { + is DomainResult.Success -> { + messageFlow.value = PanelUiMessage.Info(UiText.DynamicString("按键已删除")) + } + is DomainResult.Failure -> handleDomainError(res.error) + } + } + } + + fun switchLayout(newLayout: PanelLayoutStyle) { + val currentProfile = profileId ?: return + val currentRemoteId = remoteId ?: return + viewModelScope.launch { + when (val res = updateVirtualRemoteLayout(currentProfile, currentRemoteId, newLayout)) { + is DomainResult.Success -> { + messageFlow.value = PanelUiMessage.Info(UiText.DynamicString("已切换面板布局风格")) + } + is DomainResult.Failure -> handleDomainError(res.error) + } + } + } + + fun toggleAcPower() { + val current = state.value.acState + updateAndDebounceAc(current.copy(power = !current.power)) + } + + fun adjustAcTemperature(delta: Int) { + val current = state.value.acState + val target = (current.temperature + delta).coerceIn(16, 30) + if (target != current.temperature) { + updateAndDebounceAc(current.copy(temperature = target)) + } + } + + fun setAcMode(mode: AcMode) { + val current = state.value.acState + updateAndDebounceAc(current.copy(mode = mode)) + } + + fun setAcFanSpeed(fanSpeed: AcFanSpeed) { + val current = state.value.acState + updateAndDebounceAc(current.copy(fanSpeed = fanSpeed)) + } + + fun toggleAcVerticalSwing() { + val current = state.value.acState + updateAndDebounceAc(current.copy(verticalSwing = !current.verticalSwing)) + } + + fun toggleAcHorizontalSwing() { + val current = state.value.acState + updateAndDebounceAc(current.copy(horizontalSwing = !current.horizontalSwing)) + } + + fun toggleAcEco() { + val current = state.value.acState + updateAndDebounceAc(current.copy(eco = !current.eco)) + } + + private fun updateAndDebounceAc(newState: AcStateSnapshot) { + val currentProfile = profileId ?: return + val currentRemoteId = remoteId ?: return + + // 1. Optimistic UI update + localAcStateFlow.value = newState + + // 2. Debounce transmission (300ms) + acDebounceJob?.cancel() + acDebounceJob = viewModelScope.launch { + delay(300L) + when (val res = sendVirtualRemoteAction.sendAcState(currentProfile, currentRemoteId, newState)) { + is DomainResult.Success -> { + messageFlow.value = PanelUiMessage.Info(UiText.DynamicString("已同步空调状态：${newState.temperature}℃ | ${newState.mode.name}")) + } + is DomainResult.Failure -> handleDomainError(res.error) + } + } + } + + fun clearMessage() { + messageFlow.value = null + } + + private fun handleDomainError(error: DomainError) { + when (error) { + is DomainError.TokenInvalid, is DomainError.Authentication -> messageFlow.value = PanelUiMessage.SessionInvalid + is DomainError.DeviceOffline -> messageFlow.value = PanelUiMessage.Error( + UiText.StringResource(R.string.infrared_msg_device_offline, listOf(error.externalCode ?: "20206")), + ) + else -> messageFlow.value = PanelUiMessage.Error( + error.detail?.let { UiText.DynamicString(it) } + ?: UiText.StringResource(R.string.infrared_msg_operation_failed), + ) + } + } +} diff --git a/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/remote/InfraredRemoteViewModel.kt b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/remote/InfraredRemoteViewModel.kt new file mode 100644 index 0000000..50057c9 --- /dev/null +++ b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/remote/InfraredRemoteViewModel.kt @@ -0,0 +1,331 @@ +package com.flagship.abox.manager.infrared.remote + +import androidx.lifecycle.SavedStateHandle +import androidx.lifecycle.ViewModel +import androidx.lifecycle.viewModelScope +import com.flagship.abox.manager.domain.DeviceName +import com.flagship.abox.manager.domain.DomainError +import com.flagship.abox.manager.domain.DomainResult +import com.flagship.abox.manager.domain.ProviderProfile +import com.flagship.abox.manager.domain.ProviderProfileId +import com.flagship.abox.manager.domain.ProviderProfileStore +import com.flagship.abox.manager.domain.ProviderType +import com.flagship.abox.manager.domain.infrared.InfraredDeviceConfigurationRepository +import com.flagship.abox.manager.domain.infrared.InfraredKeyId +import com.flagship.abox.manager.domain.infrared.InfraredKeyRef +import com.flagship.abox.manager.domain.infrared.InfraredKeyRepository +import com.flagship.abox.manager.domain.infrared.InfraredKeyStatus +import com.flagship.abox.manager.domain.infrared.SavedInfraredKey +import com.flagship.abox.manager.domain.infrared.SendInfraredKey +import com.flagship.abox.manager.infrared.R +import com.flagship.abox.manager.infrared.application.InfraredLearningCoordinator +import dagger.hilt.android.lifecycle.HiltViewModel +import kotlinx.coroutines.ExperimentalCoroutinesApi +import kotlinx.coroutines.Job +import kotlinx.coroutines.flow.Flow +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.SharingStarted +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.combine +import kotlinx.coroutines.flow.flatMapLatest +import kotlinx.coroutines.flow.flowOf +import kotlinx.coroutines.flow.map +import kotlinx.coroutines.flow.stateIn +import kotlinx.coroutines.launch +import javax.inject.Inject + +sealed interface RemoteUiMessage { + data class Info(val text: UiText) : RemoteUiMessage + data class Error(val text: UiText) : RemoteUiMessage + data object SessionInvalid : RemoteUiMessage +} + +data class InfraredRemoteUiState( + val selectedScene: RemoteScene = RemoteScene.AIR_CONDITIONER, + val isLearningMode: Boolean = false, + val profileId: ProviderProfileId? = null, + val providerType: ProviderType? = null, + val providerDisplayName: String? = null, + val savedDeviceName: DeviceName? = null, + val learnedSlotMap: Map = emptyMap(), + val sendingKeySlot: String? = null, + val activeLearningSlot: String? = null, + val message: RemoteUiMessage? = null, +) + +@OptIn(ExperimentalCoroutinesApi::class) +@HiltViewModel +class InfraredRemoteViewModel @Inject constructor( + savedStateHandle: SavedStateHandle, + private val keyRepository: InfraredKeyRepository, + private val deviceConfigurationRepository: InfraredDeviceConfigurationRepository, + private val providerProfileStore: ProviderProfileStore, + private val learningCoordinator: InfraredLearningCoordinator, + private val sendInfraredKey: SendInfraredKey, +) : ViewModel() { + + private val rawProfileId: String? = savedStateHandle["profileId"] + val profileId: ProviderProfileId? = rawProfileId?.takeIf { it.isNotBlank() }?.let { ProviderProfileId(it) } + + private val sceneFlow = MutableStateFlow(RemoteScene.AIR_CONDITIONER) + private val isLearningModeFlow = MutableStateFlow(false) + private val sendingKeySlotFlow = MutableStateFlow(null) + private val activeLearningSlotFlow = MutableStateFlow(null) + private val messageFlow = MutableStateFlow(null) + private var activeLearningJob: Job? = null + private var underlyingLearningDeferred: kotlinx.coroutines.Deferred<*>? = null + + init { + if (profileId != null) { + val startupCutoff = System.currentTimeMillis() + learningCoordinator.failInterruptedLearning(profileId, cutoffEpochMillis = startupCutoff) + } + } + + private data class InfraredRemoteConfigSnapshot( + val providerProfile: ProviderProfile? = null, + val savedDeviceName: DeviceName = DEFAULT_DEVICE_NAME, + val learnedSlotMap: Map = emptyMap(), + val configError: DomainError? = null, + ) + + private val configSnapshotFlow: Flow = + if (profileId == null) { + flowOf(InfraredRemoteConfigSnapshot()) + } else { + providerProfileStore.observeProfiles().flatMapLatest { profiles -> + val active = profiles.find { it.id == profileId } + deviceConfigurationRepository.observeDeviceName(profileId).flatMapLatest { deviceResult -> + when (deviceResult) { + is DomainResult.Failure -> flowOf( + InfraredRemoteConfigSnapshot( + providerProfile = active, + configError = deviceResult.error, + ), + ) + is DomainResult.Success -> { + val deviceName = deviceResult.value ?: DEFAULT_DEVICE_NAME + keyRepository.observeKeys(profileId, deviceName).map { keysResult -> + when (keysResult) { + is DomainResult.Failure -> InfraredRemoteConfigSnapshot( + providerProfile = active, + savedDeviceName = deviceName, + configError = keysResult.error, + ) + is DomainResult.Success -> InfraredRemoteConfigSnapshot( + providerProfile = active, + savedDeviceName = deviceName, + learnedSlotMap = keysResult.value.associateBy { it.sdkKey }, + ) + } + } + } + } + } + } + } + + val state: StateFlow = combine( + sceneFlow, + isLearningModeFlow, + configSnapshotFlow, + combine(sendingKeySlotFlow, activeLearningSlotFlow, messageFlow) { sending, learning, msg -> + Triple(sending, learning, msg) + }, + ) { scene, isLearning, snapshot, (sendingSlot, learningSlot, msg) -> + val resolvedMessage = msg ?: snapshot.configError?.let { error -> + when (error) { + is DomainError.TokenInvalid, is DomainError.Authentication -> RemoteUiMessage.SessionInvalid + is DomainError.DeviceOffline -> RemoteUiMessage.Error( + UiText.StringResource(R.string.infrared_msg_device_offline, listOf(error.externalCode ?: "20206")), + ) + else -> RemoteUiMessage.Error( + error.detail?.let { UiText.DynamicString(it) } + ?: UiText.StringResource(R.string.infrared_msg_load_failed), + ) + } + } + InfraredRemoteUiState( + selectedScene = scene, + isLearningMode = isLearning, + profileId = profileId, + providerType = snapshot.providerProfile?.type, + providerDisplayName = snapshot.providerProfile?.displayName, + savedDeviceName = snapshot.savedDeviceName, + learnedSlotMap = snapshot.learnedSlotMap, + sendingKeySlot = sendingSlot, + activeLearningSlot = learningSlot, + message = resolvedMessage, + ) + }.stateIn( + scope = viewModelScope, + started = SharingStarted.WhileSubscribed(5_000), + initialValue = InfraredRemoteUiState(profileId = profileId), + ) + + fun switchScene(scene: RemoteScene) { + sceneFlow.value = scene + } + + fun toggleLearningMode(enabled: Boolean) { + isLearningModeFlow.value = enabled + if (!enabled) { + val shutdownCutoff = System.currentTimeMillis() + underlyingLearningDeferred?.cancel() + underlyingLearningDeferred = null + activeLearningJob?.cancel() + activeLearningJob = null + activeLearningSlotFlow.value = null + profileId?.let { profile -> + learningCoordinator.failInterruptedLearning(profile, cutoffEpochMillis = shutdownCutoff) + } + } else { + messageFlow.value = RemoteUiMessage.Info( + UiText.StringResource(R.string.infrared_msg_learning_mode_enabled), + ) + } + } + + fun onButtonClick(spec: RemoteButtonSpec) { + val currentProfile = profileId ?: return + val currentDevice = state.value.savedDeviceName ?: DEFAULT_DEVICE_NAME + + if (isLearningModeFlow.value) { + if (underlyingLearningDeferred?.isActive == true || activeLearningJob?.isActive == true || activeLearningSlotFlow.value != null) { + return + } + val existingKey = state.value.learnedSlotMap[spec.defaultSlot] + messageFlow.value = RemoteUiMessage.Info( + UiText.StringResource( + R.string.infrared_msg_recording_key, + listOf(spec.displayName, spec.defaultSlot), + ), + ) + activeLearningSlotFlow.value = spec.defaultSlot + val deferred = when (existingKey?.status) { + InfraredKeyStatus.FAILED -> learningCoordinator.retry(InfraredKeyRef(currentProfile, existingKey.id)) + InfraredKeyStatus.READY, InfraredKeyStatus.LEARNING -> learningCoordinator.relearn(InfraredKeyRef(currentProfile, existingKey.id)) + null -> learningCoordinator.learn( + profileId = currentProfile, + deviceName = currentDevice, + displayName = spec.displayName, + sdkKey = spec.defaultSlot, + ) + } + underlyingLearningDeferred = deferred + val job = viewModelScope.launch { + try { + val result = if (existingKey != null) { + @Suppress("UNCHECKED_CAST") + (deferred as kotlinx.coroutines.Deferred>).await() + } else { + @Suppress("UNCHECKED_CAST") + when (val res = (deferred as kotlinx.coroutines.Deferred>).await()) { + is DomainResult.Success -> DomainResult.Success(Unit) + is DomainResult.Failure -> DomainResult.Failure(res.error) + } + } + when (result) { + is DomainResult.Success -> { + messageFlow.value = RemoteUiMessage.Info( + UiText.StringResource( + R.string.infrared_msg_learned_success, + listOf(spec.displayName), + ), + ) + } + is DomainResult.Failure -> { + handleDomainError(result.error) + } + } + } catch (e: kotlinx.coroutines.CancellationException) { + throw e + } finally { + if (underlyingLearningDeferred === deferred) { + underlyingLearningDeferred = null + } + if (activeLearningSlotFlow.value == spec.defaultSlot) { + activeLearningSlotFlow.value = null + } + } + } + activeLearningJob = job + } else { + if (sendingKeySlotFlow.value != null) { + return + } + val key = state.value.learnedSlotMap[spec.defaultSlot] + if (key == null || key.status != InfraredKeyStatus.READY || key.profileId != currentProfile || key.deviceName != currentDevice) { + messageFlow.value = RemoteUiMessage.Error( + UiText.StringResource( + R.string.infrared_msg_key_not_learned, + listOf(spec.displayName), + ), + ) + return + } + sendingKeySlotFlow.value = spec.defaultSlot + viewModelScope.launch { + try { + when (val result = sendInfraredKey(InfraredKeyRef(currentProfile, key.id))) { + is DomainResult.Success -> { + messageFlow.value = RemoteUiMessage.Info( + UiText.StringResource( + R.string.infrared_msg_signal_sent, + listOf(spec.displayName), + ), + ) + } + is DomainResult.Failure -> { + handleDomainError(result.error) + } + } + } finally { + sendingKeySlotFlow.value = null + } + } + } + } + + override fun onCleared() { + super.onCleared() + val teardownCutoff = System.currentTimeMillis() + underlyingLearningDeferred?.cancel() + underlyingLearningDeferred = null + activeLearningJob?.cancel() + activeLearningJob = null + profileId?.let { profile -> + learningCoordinator.failInterruptedLearning(profile, cutoffEpochMillis = teardownCutoff) + } + } + + fun clearMessage() { + messageFlow.value = null + } + + private fun handleDomainError(error: DomainError) { + when (error) { + is DomainError.TokenInvalid, is DomainError.Authentication -> { + messageFlow.value = RemoteUiMessage.SessionInvalid + } + is DomainError.DeviceOffline -> { + messageFlow.value = RemoteUiMessage.Error( + UiText.StringResource( + R.string.infrared_msg_device_offline, + listOf(error.externalCode ?: "20206"), + ), + ) + } + else -> { + messageFlow.value = RemoteUiMessage.Error( + error.detail?.let { UiText.DynamicString(it) } + ?: UiText.StringResource(R.string.infrared_msg_operation_failed), + ) + } + } + } + + companion object { + val DEFAULT_DEVICE_NAME = DeviceName("红外控制器") + } +} diff --git a/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/remote/RemoteModels.kt b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/remote/RemoteModels.kt new file mode 100644 index 0000000..bb50d7a --- /dev/null +++ b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/remote/RemoteModels.kt @@ -0,0 +1,61 @@ +package com.flagship.abox.manager.infrared.remote + +import androidx.annotation.StringRes +import com.flagship.abox.manager.infrared.R + +sealed interface UiText { + data class DynamicString(val value: String) : UiText + data class StringResource( + @StringRes val resId: Int, + val args: List = emptyList(), + ) : UiText +} + +enum class RemoteScene { + AIR_CONDITIONER, + TELEVISION, +} + +data class RemoteButtonSpec( + val id: String, + val defaultSlot: String, + @StringRes val nameRes: Int, + val displayName: String, + val symbol: String, +) + +object RemoteSceneConfig { + object AirConditioner { + val POWER = RemoteButtonSpec("AC_POWER", "1", R.string.infrared_key_ac_power, "空调-电源", "⏻") + val TEMP_UP = RemoteButtonSpec("AC_TEMP_UP", "2", R.string.infrared_key_ac_temp_up, "空调-温度+", "▲") + val TEMP_DOWN = RemoteButtonSpec("AC_TEMP_DOWN", "3", R.string.infrared_key_ac_temp_down, "空调-温度-", "▼") + val MODE = RemoteButtonSpec("AC_MODE", "4", R.string.infrared_key_ac_mode, "空调-模式", "模式 ❄/☀") + val FAN = RemoteButtonSpec("AC_FAN", "5", R.string.infrared_key_ac_fan, "空调-风速", "风速 💨") + val SWING = RemoteButtonSpec("AC_SWING", "6", R.string.infrared_key_ac_swing, "空调-扫风", "扫风 ↔") + val TIMER = RemoteButtonSpec("AC_TIMER", "7", R.string.infrared_key_ac_timer, "空调-定时", "定时 ⏱") + + val buttons = listOf(POWER, TEMP_UP, TEMP_DOWN, MODE, FAN, SWING, TIMER) + } + + object Television { + val POWER = RemoteButtonSpec("TV_POWER", "21", R.string.infrared_key_tv_power, "电视-电源", "⏻") + val MUTE = RemoteButtonSpec("TV_MUTE", "22", R.string.infrared_key_tv_mute, "电视-静音", "🔇") + val NAV_UP = RemoteButtonSpec("TV_NAV_UP", "23", R.string.infrared_key_tv_nav_up, "电视-上", "▲") + val NAV_DOWN = RemoteButtonSpec("TV_NAV_DOWN", "24", R.string.infrared_key_tv_nav_down, "电视-下", "▼") + val NAV_LEFT = RemoteButtonSpec("TV_NAV_LEFT", "25", R.string.infrared_key_tv_nav_left, "电视-左", "◀") + val NAV_RIGHT = RemoteButtonSpec("TV_NAV_RIGHT", "26", R.string.infrared_key_tv_nav_right, "电视-右", "▶") + val OK = RemoteButtonSpec("TV_OK", "27", R.string.infrared_key_tv_ok, "电视-确定", "OK") + val VOL_UP = RemoteButtonSpec("TV_VOL_UP", "28", R.string.infrared_key_tv_vol_up, "电视-音量+", "VOL +") + val VOL_DOWN = RemoteButtonSpec("TV_VOL_DOWN", "29", R.string.infrared_key_tv_vol_down, "电视-音量-", "VOL -") + val CH_UP = RemoteButtonSpec("TV_CH_UP", "30", R.string.infrared_key_tv_ch_up, "电视-频道+", "CH +") + val CH_DOWN = RemoteButtonSpec("TV_CH_DOWN", "31", R.string.infrared_key_tv_ch_down, "电视-频道-", "CH -") + val HOME = RemoteButtonSpec("TV_HOME", "32", R.string.infrared_key_tv_home, "电视-主页", "🏠") + val BACK = RemoteButtonSpec("TV_BACK", "33", R.string.infrared_key_tv_back, "电视-返回", "↩") + val MENU = RemoteButtonSpec("TV_MENU", "34", R.string.infrared_key_tv_menu, "电视-菜单", "☰") + + val buttons = listOf( + POWER, MUTE, NAV_UP, NAV_DOWN, NAV_LEFT, NAV_RIGHT, OK, + VOL_UP, VOL_DOWN, CH_UP, CH_DOWN, HOME, BACK, MENU, + ) + } +} diff --git a/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/remote/ui/AcRemotePanel.kt b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/remote/ui/AcRemotePanel.kt new file mode 100644 index 0000000..2f3f043 --- /dev/null +++ b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/remote/ui/AcRemotePanel.kt @@ -0,0 +1,174 @@ +package com.flagship.abox.manager.infrared.remote.ui + +import androidx.compose.foundation.background +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material3.Card +import androidx.compose.material3.CardDefaults +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.shadow +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.text.font.FontFamily +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp +import com.flagship.abox.manager.domain.infrared.InfraredKeyStatus +import com.flagship.abox.manager.domain.infrared.SavedInfraredKey +import com.flagship.abox.manager.infrared.R +import com.flagship.abox.manager.infrared.remote.RemoteButtonSpec +import com.flagship.abox.manager.infrared.remote.RemoteSceneConfig + +@Composable +fun AcRemotePanel( + learnedSlotMap: Map, + activeLearningSlot: String?, + sendingKeySlot: String?, + isLearningMode: Boolean, + onButtonClick: (RemoteButtonSpec) -> Unit, + modifier: Modifier = Modifier, +) { + RemoteChassis(modifier = modifier) { + // 顶部虚拟 LCD 液晶显示区 + AcLcdDisplay() + + // 电源与温度控制行 + Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.SpaceEvenly, + verticalAlignment = Alignment.CenterVertically, + ) { + // 电源按键 + val powerSpec = RemoteSceneConfig.AirConditioner.POWER + val isPowerLearned = learnedSlotMap[powerSpec.defaultSlot]?.status == InfraredKeyStatus.READY + val isPowerLoading = activeLearningSlot == powerSpec.defaultSlot || sendingKeySlot == powerSpec.defaultSlot + + RemoteCircleButton( + spec = powerSpec, + isLearned = isPowerLearned, + isLoading = isPowerLoading, + isLearningMode = isLearningMode, + onClick = { onButtonClick(powerSpec) }, + size = 72.dp, + containerColor = Color(0xFFE53935), + contentColor = Color.White, + ) + + // 垂直胶囊温度调节器 + val tempUpSpec = RemoteSceneConfig.AirConditioner.TEMP_UP + val tempDownSpec = RemoteSceneConfig.AirConditioner.TEMP_DOWN + + VerticalCapsuleRocker( + upSpec = tempUpSpec, + downSpec = tempDownSpec, + isUpLearned = learnedSlotMap[tempUpSpec.defaultSlot]?.status == InfraredKeyStatus.READY, + isDownLearned = learnedSlotMap[tempDownSpec.defaultSlot]?.status == InfraredKeyStatus.READY, + isUpLoading = activeLearningSlot == tempUpSpec.defaultSlot || sendingKeySlot == tempUpSpec.defaultSlot, + isDownLoading = activeLearningSlot == tempDownSpec.defaultSlot || sendingKeySlot == tempDownSpec.defaultSlot, + isLearningMode = isLearningMode, + onUpClick = { onButtonClick(tempUpSpec) }, + onDownClick = { onButtonClick(tempDownSpec) }, + label = stringResource(R.string.infrared_label_temp_control), + ) + } + + Spacer(modifier = Modifier.height(4.dp)) + + // 功能按键网格 (模式 / 风速 / 扫风 / 定时) + Column( + verticalArrangement = Arrangement.spacedBy(14.dp), + horizontalAlignment = Alignment.CenterHorizontally, + ) { + Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.SpaceEvenly, + ) { + AcGridButton(RemoteSceneConfig.AirConditioner.MODE, learnedSlotMap, activeLearningSlot, sendingKeySlot, isLearningMode, onButtonClick) + AcGridButton(RemoteSceneConfig.AirConditioner.FAN, learnedSlotMap, activeLearningSlot, sendingKeySlot, isLearningMode, onButtonClick) + } + Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.SpaceEvenly, + ) { + AcGridButton(RemoteSceneConfig.AirConditioner.SWING, learnedSlotMap, activeLearningSlot, sendingKeySlot, isLearningMode, onButtonClick) + AcGridButton(RemoteSceneConfig.AirConditioner.TIMER, learnedSlotMap, activeLearningSlot, sendingKeySlot, isLearningMode, onButtonClick) + } + } + } +} + +@Composable +private fun AcGridButton( + spec: RemoteButtonSpec, + learnedSlotMap: Map, + activeLearningSlot: String?, + sendingKeySlot: String?, + isLearningMode: Boolean, + onButtonClick: (RemoteButtonSpec) -> Unit, +) { + RemoteRectButton( + spec = spec, + isLearned = learnedSlotMap[spec.defaultSlot]?.status == InfraredKeyStatus.READY, + isLoading = activeLearningSlot == spec.defaultSlot || sendingKeySlot == spec.defaultSlot, + isLearningMode = isLearningMode, + onClick = { onButtonClick(spec) }, + width = 120.dp, + height = 52.dp, + ) +} + +@Composable +private fun AcLcdDisplay() { + Card( + modifier = Modifier + .fillMaxWidth() + .height(96.dp) + .shadow(4.dp, shape = RoundedCornerShape(16.dp)), + shape = RoundedCornerShape(16.dp), + colors = CardDefaults.cardColors( + containerColor = Color(0xFF1E293B), + ), + ) { + Row( + modifier = Modifier + .padding(16.dp) + .fillMaxWidth(), + horizontalArrangement = Arrangement.SpaceBetween, + verticalAlignment = Alignment.CenterVertically, + ) { + Column { + Text( + text = stringResource(R.string.infrared_label_cool_mode), + color = Color(0xFF38BDF8), + fontSize = 14.sp, + fontWeight = FontWeight.Medium, + ) + Text( + text = stringResource(R.string.infrared_label_ac_status), + color = Color(0xFF94A3B8), + fontSize = 12.sp, + ) + } + + Text( + text = "26°C", + color = Color(0xFF4ADE80), + fontSize = 38.sp, + fontFamily = FontFamily.Monospace, + fontWeight = FontWeight.Bold, + ) + } + } +} diff --git a/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/remote/ui/InfraredRemoteScreen.kt b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/remote/ui/InfraredRemoteScreen.kt new file mode 100644 index 0000000..97ccfc3 --- /dev/null +++ b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/remote/ui/InfraredRemoteScreen.kt @@ -0,0 +1,263 @@ +package com.flagship.abox.manager.infrared.remote.ui + +import androidx.compose.foundation.background +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.rememberScrollState +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.foundation.verticalScroll +import androidx.compose.material3.ExperimentalMaterial3Api +import androidx.compose.material3.FilterChip +import androidx.compose.material3.FilterChipDefaults +import androidx.compose.material3.Icon +import androidx.compose.material3.IconButton +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Scaffold +import androidx.compose.material3.SnackbarHost +import androidx.compose.material3.SnackbarHostState +import androidx.compose.material3.Switch +import androidx.compose.material3.SwitchDefaults +import androidx.compose.material3.Text +import androidx.compose.material3.TextButton +import androidx.compose.material3.TopAppBar +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.remember +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.platform.testTag +import androidx.compose.ui.res.painterResource +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp +import androidx.hilt.navigation.compose.hiltViewModel +import androidx.lifecycle.compose.collectAsStateWithLifecycle +import com.flagship.abox.manager.designsystem.ABoxSurface +import com.flagship.abox.manager.infrared.R +import com.flagship.abox.manager.infrared.remote.InfraredRemoteUiState +import com.flagship.abox.manager.infrared.remote.InfraredRemoteViewModel +import com.flagship.abox.manager.infrared.remote.RemoteButtonSpec +import com.flagship.abox.manager.infrared.remote.RemoteScene +import com.flagship.abox.manager.infrared.remote.RemoteUiMessage +import com.flagship.abox.manager.infrared.remote.UiText + +@Composable +fun InfraredRemoteRoute( + onBack: () -> Unit, + onOpenSettings: () -> Unit, + onSessionInvalid: () -> Unit, + viewModel: InfraredRemoteViewModel = hiltViewModel(), +) { + val state by viewModel.state.collectAsStateWithLifecycle() + + InfraredRemoteScreen( + state = state, + onBack = onBack, + onOpenSettings = onOpenSettings, + onSessionInvalid = onSessionInvalid, + onSceneSelected = viewModel::switchScene, + onToggleLearningMode = viewModel::toggleLearningMode, + onButtonClick = viewModel::onButtonClick, + onMessageShown = viewModel::clearMessage, + ) +} + +@OptIn(ExperimentalMaterial3Api::class) +@Composable +internal fun InfraredRemoteScreen( + state: InfraredRemoteUiState, + onBack: () -> Unit, + onOpenSettings: () -> Unit, + onSessionInvalid: () -> Unit, + onSceneSelected: (RemoteScene) -> Unit, + onToggleLearningMode: (Boolean) -> Unit, + onButtonClick: (RemoteButtonSpec) -> Unit, + onMessageShown: () -> Unit, +) { + val snackbarHostState = remember { SnackbarHostState() } + val context = LocalContext.current + + LaunchedEffect(state.message) { + state.message?.let { msg -> + when (msg) { + is RemoteUiMessage.Info -> { + val text = when (val t = msg.text) { + is UiText.DynamicString -> t.value + is UiText.StringResource -> context.getString(t.resId, *t.args.toTypedArray()) + } + snackbarHostState.showSnackbar(text) + onMessageShown() + } + is RemoteUiMessage.Error -> { + val text = when (val t = msg.text) { + is UiText.DynamicString -> t.value + is UiText.StringResource -> context.getString(t.resId, *t.args.toTypedArray()) + } + snackbarHostState.showSnackbar(text) + onMessageShown() + } + is RemoteUiMessage.SessionInvalid -> { + onSessionInvalid() + onMessageShown() + } + } + } + } + + Scaffold( + topBar = { + TopAppBar( + title = { + Text( + text = stringResource(R.string.infrared_remote_title), + style = MaterialTheme.typography.titleLarge.copy(fontWeight = FontWeight.Bold), + ) + }, + navigationIcon = { + TextButton(onClick = onBack) { + Text(stringResource(R.string.infrared_back)) + } + }, + actions = { + // 学习模式开关 + Row( + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(4.dp), + ) { + Text( + text = if (state.isLearningMode) { + stringResource(R.string.infrared_remote_recording) + } else { + stringResource(R.string.infrared_remote_learning_mode) + }, + fontSize = 12.sp, + fontWeight = if (state.isLearningMode) FontWeight.Bold else FontWeight.Normal, + color = if (state.isLearningMode) MaterialTheme.colorScheme.error else MaterialTheme.colorScheme.onSurface, + ) + Switch( + checked = state.isLearningMode, + onCheckedChange = onToggleLearningMode, + modifier = Modifier.testTag("remote_learning_mode_switch"), + colors = SwitchDefaults.colors( + checkedThumbColor = MaterialTheme.colorScheme.error, + checkedTrackColor = MaterialTheme.colorScheme.errorContainer, + ), + ) + } + + // 按键管理 / 设置入口按钮 + IconButton( + onClick = onOpenSettings, + modifier = Modifier.testTag("remote_settings_button"), + ) { + Text("⚙️", fontSize = 20.sp) + } + }, + ) + }, + snackbarHost = { SnackbarHost(snackbarHostState) }, + ) { innerPadding -> + ABoxSurface( + modifier = Modifier + .fillMaxSize() + .padding(innerPadding), + ) { + Column( + modifier = Modifier + .fillMaxSize() + .verticalScroll(rememberScrollState()) + .padding(horizontal = 16.dp, vertical = 8.dp), + horizontalAlignment = Alignment.CenterHorizontally, + verticalArrangement = Arrangement.spacedBy(16.dp), + ) { + // 学习模式顶部横幅提示 + if (state.isLearningMode) { + Box( + modifier = Modifier + .fillMaxWidth() + .background( + color = MaterialTheme.colorScheme.errorContainer.copy(alpha = 0.8f), + shape = RoundedCornerShape(12.dp), + ) + .padding(vertical = 8.dp, horizontal = 12.dp), + contentAlignment = Alignment.Center, + ) { + Text( + text = stringResource(R.string.infrared_remote_learning_banner), + style = MaterialTheme.typography.bodyMedium.copy( + color = MaterialTheme.colorScheme.onErrorContainer, + fontWeight = FontWeight.SemiBold, + ), + ) + } + } + + // 场景切换 Tab (空调 | 电视) + Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.Center, + verticalAlignment = Alignment.CenterVertically, + ) { + FilterChip( + selected = state.selectedScene == RemoteScene.AIR_CONDITIONER, + onClick = { onSceneSelected(RemoteScene.AIR_CONDITIONER) }, + label = { Text(stringResource(R.string.infrared_remote_scene_ac)) }, + modifier = Modifier + .padding(end = 8.dp) + .testTag("scene_tab_ac"), + colors = FilterChipDefaults.filterChipColors( + selectedContainerColor = MaterialTheme.colorScheme.primaryContainer, + selectedLabelColor = MaterialTheme.colorScheme.onPrimaryContainer, + ), + ) + FilterChip( + selected = state.selectedScene == RemoteScene.TELEVISION, + onClick = { onSceneSelected(RemoteScene.TELEVISION) }, + label = { Text(stringResource(R.string.infrared_remote_scene_tv)) }, + modifier = Modifier.testTag("scene_tab_tv"), + colors = FilterChipDefaults.filterChipColors( + selectedContainerColor = MaterialTheme.colorScheme.primaryContainer, + selectedLabelColor = MaterialTheme.colorScheme.onPrimaryContainer, + ), + ) + } + + // 对应场景遥控器面板 + when (state.selectedScene) { + RemoteScene.AIR_CONDITIONER -> { + AcRemotePanel( + learnedSlotMap = state.learnedSlotMap, + activeLearningSlot = state.activeLearningSlot, + sendingKeySlot = state.sendingKeySlot, + isLearningMode = state.isLearningMode, + onButtonClick = onButtonClick, + ) + } + RemoteScene.TELEVISION -> { + TvRemotePanel( + learnedSlotMap = state.learnedSlotMap, + activeLearningSlot = state.activeLearningSlot, + sendingKeySlot = state.sendingKeySlot, + isLearningMode = state.isLearningMode, + onButtonClick = onButtonClick, + ) + } + } + + Spacer(modifier = Modifier.height(16.dp)) + } + } + } +} diff --git a/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/remote/ui/RemoteComponents.kt b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/remote/ui/RemoteComponents.kt new file mode 100644 index 0000000..94100e4 --- /dev/null +++ b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/remote/ui/RemoteComponents.kt @@ -0,0 +1,429 @@ +package com.flagship.abox.manager.infrared.remote.ui + +import androidx.compose.foundation.background +import androidx.compose.foundation.border +import androidx.compose.foundation.clickable +import androidx.compose.foundation.interaction.MutableInteractionSource +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.shape.CircleShape +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material3.Card +import androidx.compose.material3.CardDefaults +import androidx.compose.material3.CircularProgressIndicator +import androidx.compose.material3.Divider +import androidx.compose.material3.HorizontalDivider +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Surface +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.runtime.remember +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.clip +import androidx.compose.ui.draw.shadow +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.platform.testTag +import androidx.compose.ui.text.font.FontFamily +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.text.style.TextAlign +import androidx.compose.ui.unit.Dp +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp +import com.flagship.abox.manager.infrared.remote.RemoteButtonSpec + +@Composable +fun RemoteChassis( + modifier: Modifier = Modifier, + content: @Composable () -> Unit, +) { + Card( + modifier = modifier + .fillMaxWidth() + .padding(horizontal = 8.dp) + .shadow(12.dp, shape = RoundedCornerShape(32.dp)), + shape = RoundedCornerShape(32.dp), + colors = CardDefaults.cardColors( + containerColor = MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.65f), + ), + ) { + Column( + modifier = Modifier + .fillMaxWidth() + .padding(20.dp), + horizontalAlignment = Alignment.CenterHorizontally, + verticalArrangement = Arrangement.spacedBy(20.dp), + ) { + content() + } + } +} + +@Composable +fun RemoteCircleButton( + spec: RemoteButtonSpec, + isLearned: Boolean, + isLoading: Boolean, + isLearningMode: Boolean, + onClick: () -> Unit, + modifier: Modifier = Modifier, + size: Dp = 64.dp, + containerColor: Color? = null, + contentColor: Color? = null, +) { + val defaultContainer = when { + isLearningMode -> MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.8f) + isLearned -> containerColor ?: MaterialTheme.colorScheme.primary + else -> MaterialTheme.colorScheme.surface + } + + val defaultContent = when { + isLearningMode -> MaterialTheme.colorScheme.onPrimaryContainer + isLearned -> contentColor ?: MaterialTheme.colorScheme.onPrimary + else -> MaterialTheme.colorScheme.onSurface.copy(alpha = 0.6f) + } + + val borderModifier = if (isLearningMode) { + Modifier.border(2.dp, MaterialTheme.colorScheme.primary, CircleShape) + } else if (!isLearned) { + Modifier.border(1.dp, MaterialTheme.colorScheme.outline.copy(alpha = 0.5f), CircleShape) + } else { + Modifier + } + + Surface( + modifier = modifier + .size(size) + .then(borderModifier) + .testTag("remote_button_${spec.id}"), + shape = CircleShape, + color = defaultContainer, + contentColor = defaultContent, + shadowElevation = if (isLearned) 4.dp else 1.dp, + enabled = !isLoading, + onClick = onClick, + ) { + Box( + modifier = Modifier.fillMaxSize(), + contentAlignment = Alignment.Center, + ) { + if (isLoading) { + CircularProgressIndicator( + modifier = Modifier.size(size * 0.45f), + strokeWidth = 2.5.dp, + color = defaultContent, + ) + } else { + Text( + text = spec.symbol, + style = MaterialTheme.typography.titleMedium.copy( + fontSize = if (spec.symbol.length <= 2) 22.sp else 14.sp, + fontWeight = FontWeight.Bold, + ), + textAlign = TextAlign.Center, + ) + } + } + } +} + +@Composable +fun RemoteRectButton( + spec: RemoteButtonSpec, + isLearned: Boolean, + isLoading: Boolean, + isLearningMode: Boolean, + onClick: () -> Unit, + modifier: Modifier = Modifier, + width: Dp = 100.dp, + height: Dp = 48.dp, +) { + val containerColor = when { + isLearningMode -> MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.8f) + isLearned -> MaterialTheme.colorScheme.secondaryContainer + else -> MaterialTheme.colorScheme.surface + } + val contentColor = when { + isLearningMode -> MaterialTheme.colorScheme.onPrimaryContainer + isLearned -> MaterialTheme.colorScheme.onSecondaryContainer + else -> MaterialTheme.colorScheme.onSurface.copy(alpha = 0.6f) + } + + val borderModifier = if (isLearningMode) { + Modifier.border(2.dp, MaterialTheme.colorScheme.primary, RoundedCornerShape(16.dp)) + } else if (!isLearned) { + Modifier.border(1.dp, MaterialTheme.colorScheme.outline.copy(alpha = 0.5f), RoundedCornerShape(16.dp)) + } else { + Modifier + } + + Surface( + modifier = modifier + .width(width) + .height(height) + .then(borderModifier) + .testTag("remote_button_${spec.id}"), + shape = RoundedCornerShape(16.dp), + color = containerColor, + contentColor = contentColor, + shadowElevation = if (isLearned) 3.dp else 1.dp, + enabled = !isLoading, + onClick = onClick, + ) { + Box( + modifier = Modifier.fillMaxSize(), + contentAlignment = Alignment.Center, + ) { + if (isLoading) { + CircularProgressIndicator( + modifier = Modifier.size(20.dp), + strokeWidth = 2.dp, + color = contentColor, + ) + } else { + Text( + text = spec.symbol, + style = MaterialTheme.typography.bodyMedium.copy(fontWeight = FontWeight.SemiBold), + textAlign = TextAlign.Center, + ) + } + } + } +} + +@Composable +fun VerticalCapsuleRocker( + upSpec: RemoteButtonSpec, + downSpec: RemoteButtonSpec, + isUpLearned: Boolean, + isDownLearned: Boolean, + isUpLoading: Boolean, + isDownLoading: Boolean, + isLearningMode: Boolean, + onUpClick: () -> Unit, + onDownClick: () -> Unit, + modifier: Modifier = Modifier, + label: String = "", +) { + Column( + modifier = modifier, + horizontalAlignment = Alignment.CenterHorizontally, + verticalArrangement = Arrangement.spacedBy(4.dp), + ) { + Card( + modifier = Modifier + .width(68.dp) + .height(136.dp) + .shadow(4.dp, shape = RoundedCornerShape(34.dp)), + shape = RoundedCornerShape(34.dp), + colors = CardDefaults.cardColors( + containerColor = MaterialTheme.colorScheme.surface, + ), + ) { + Column( + modifier = Modifier.fillMaxSize(), + ) { + // Top half + Box( + modifier = Modifier + .weight(1f) + .fillMaxWidth() + .clip(RoundedCornerShape(topStart = 34.dp, topEnd = 34.dp)) + .background( + if (isLearningMode) MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.8f) + else if (isUpLearned) MaterialTheme.colorScheme.primary.copy(alpha = 0.15f) + else Color.Transparent, + ) + .clickable(enabled = !isUpLoading, onClick = onUpClick) + .testTag("remote_button_${upSpec.id}"), + contentAlignment = Alignment.Center, + ) { + if (isUpLoading) { + CircularProgressIndicator(modifier = Modifier.size(18.dp), strokeWidth = 2.dp) + } else { + Text( + text = upSpec.symbol, + style = MaterialTheme.typography.titleMedium.copy(fontWeight = FontWeight.Bold), + ) + } + } + + HorizontalDivider(color = MaterialTheme.colorScheme.outlineVariant) + + // Bottom half + Box( + modifier = Modifier + .weight(1f) + .fillMaxWidth() + .clip(RoundedCornerShape(bottomStart = 34.dp, bottomEnd = 34.dp)) + .background( + if (isLearningMode) MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.8f) + else if (isDownLearned) MaterialTheme.colorScheme.primary.copy(alpha = 0.15f) + else Color.Transparent, + ) + .clickable(enabled = !isDownLoading, onClick = onDownClick) + .testTag("remote_button_${downSpec.id}"), + contentAlignment = Alignment.Center, + ) { + if (isDownLoading) { + CircularProgressIndicator(modifier = Modifier.size(18.dp), strokeWidth = 2.dp) + } else { + Text( + text = downSpec.symbol, + style = MaterialTheme.typography.titleMedium.copy(fontWeight = FontWeight.Bold), + ) + } + } + } + } + if (label.isNotBlank()) { + Text( + text = label, + style = MaterialTheme.typography.labelMedium, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + } +} + +@Composable +fun RemoteDpadWheel( + upSpec: RemoteButtonSpec, + downSpec: RemoteButtonSpec, + leftSpec: RemoteButtonSpec, + rightSpec: RemoteButtonSpec, + okSpec: RemoteButtonSpec, + isUpLearned: Boolean, + isDownLearned: Boolean, + isLeftLearned: Boolean, + isRightLearned: Boolean, + isOkLearned: Boolean, + isUpLoading: Boolean, + isDownLoading: Boolean, + isLeftLoading: Boolean, + isRightLoading: Boolean, + isOkLoading: Boolean, + isLearningMode: Boolean, + onUpClick: () -> Unit, + onDownClick: () -> Unit, + onLeftClick: () -> Unit, + onRightClick: () -> Unit, + onOkClick: () -> Unit, + modifier: Modifier = Modifier, + wheelSize: Dp = 190.dp, +) { + Card( + modifier = modifier + .size(wheelSize) + .shadow(6.dp, shape = CircleShape), + shape = CircleShape, + colors = CardDefaults.cardColors( + containerColor = MaterialTheme.colorScheme.surface, + ), + ) { + Box( + modifier = Modifier.fillMaxSize(), + contentAlignment = Alignment.Center, + ) { + // Up Button + Box( + modifier = Modifier + .align(Alignment.TopCenter) + .padding(top = 10.dp) + .size(54.dp) + .clip(CircleShape) + .background( + if (isLearningMode) MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.8f) + else if (isUpLearned) MaterialTheme.colorScheme.primary.copy(alpha = 0.15f) + else Color.Transparent, + ) + .clickable(enabled = !isUpLoading, onClick = onUpClick) + .testTag("remote_button_${upSpec.id}"), + contentAlignment = Alignment.Center, + ) { + if (isUpLoading) CircularProgressIndicator(modifier = Modifier.size(18.dp)) + else Text(upSpec.symbol, style = MaterialTheme.typography.titleLarge) + } + + // Down Button + Box( + modifier = Modifier + .align(Alignment.BottomCenter) + .padding(bottom = 10.dp) + .size(54.dp) + .clip(CircleShape) + .background( + if (isLearningMode) MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.8f) + else if (isDownLearned) MaterialTheme.colorScheme.primary.copy(alpha = 0.15f) + else Color.Transparent, + ) + .clickable(enabled = !isDownLoading, onClick = onDownClick) + .testTag("remote_button_${downSpec.id}"), + contentAlignment = Alignment.Center, + ) { + if (isDownLoading) CircularProgressIndicator(modifier = Modifier.size(18.dp)) + else Text(downSpec.symbol, style = MaterialTheme.typography.titleLarge) + } + + // Left Button + Box( + modifier = Modifier + .align(Alignment.CenterStart) + .padding(start = 10.dp) + .size(54.dp) + .clip(CircleShape) + .background( + if (isLearningMode) MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.8f) + else if (isLeftLearned) MaterialTheme.colorScheme.primary.copy(alpha = 0.15f) + else Color.Transparent, + ) + .clickable(enabled = !isLeftLoading, onClick = onLeftClick) + .testTag("remote_button_${leftSpec.id}"), + contentAlignment = Alignment.Center, + ) { + if (isLeftLoading) CircularProgressIndicator(modifier = Modifier.size(18.dp)) + else Text(leftSpec.symbol, style = MaterialTheme.typography.titleLarge) + } + + // Right Button + Box( + modifier = Modifier + .align(Alignment.CenterEnd) + .padding(end = 10.dp) + .size(54.dp) + .clip(CircleShape) + .background( + if (isLearningMode) MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.8f) + else if (isRightLearned) MaterialTheme.colorScheme.primary.copy(alpha = 0.15f) + else Color.Transparent, + ) + .clickable(enabled = !isRightLoading, onClick = onRightClick) + .testTag("remote_button_${rightSpec.id}"), + contentAlignment = Alignment.Center, + ) { + if (isRightLoading) CircularProgressIndicator(modifier = Modifier.size(18.dp)) + else Text(rightSpec.symbol, style = MaterialTheme.typography.titleLarge) + } + + // Center OK Button + RemoteCircleButton( + spec = okSpec, + isLearned = isOkLearned, + isLoading = isOkLoading, + isLearningMode = isLearningMode, + onClick = onOkClick, + size = 62.dp, + containerColor = MaterialTheme.colorScheme.primaryContainer, + contentColor = MaterialTheme.colorScheme.onPrimaryContainer, + ) + } + } +} diff --git a/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/remote/ui/TvRemotePanel.kt b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/remote/ui/TvRemotePanel.kt new file mode 100644 index 0000000..fca60ea --- /dev/null +++ b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/remote/ui/TvRemotePanel.kt @@ -0,0 +1,163 @@ +package com.flagship.abox.manager.infrared.remote.ui + +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.runtime.Composable +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.unit.dp +import com.flagship.abox.manager.domain.infrared.InfraredKeyStatus +import com.flagship.abox.manager.domain.infrared.SavedInfraredKey +import com.flagship.abox.manager.infrared.R +import com.flagship.abox.manager.infrared.remote.RemoteButtonSpec +import com.flagship.abox.manager.infrared.remote.RemoteSceneConfig + +@Composable +fun TvRemotePanel( + learnedSlotMap: Map, + activeLearningSlot: String?, + sendingKeySlot: String?, + isLearningMode: Boolean, + onButtonClick: (RemoteButtonSpec) -> Unit, + modifier: Modifier = Modifier, +) { + RemoteChassis(modifier = modifier) { + // 顶部电源与静音行 + Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.SpaceBetween, + verticalAlignment = Alignment.CenterVertically, + ) { + val powerSpec = RemoteSceneConfig.Television.POWER + RemoteCircleButton( + spec = powerSpec, + isLearned = learnedSlotMap[powerSpec.defaultSlot]?.status == InfraredKeyStatus.READY, + isLoading = activeLearningSlot == powerSpec.defaultSlot || sendingKeySlot == powerSpec.defaultSlot, + isLearningMode = isLearningMode, + onClick = { onButtonClick(powerSpec) }, + size = 56.dp, + containerColor = Color(0xFFE53935), + contentColor = Color.White, + ) + + val muteSpec = RemoteSceneConfig.Television.MUTE + RemoteCircleButton( + spec = muteSpec, + isLearned = learnedSlotMap[muteSpec.defaultSlot]?.status == InfraredKeyStatus.READY, + isLoading = activeLearningSlot == muteSpec.defaultSlot || sendingKeySlot == muteSpec.defaultSlot, + isLearningMode = isLearningMode, + onClick = { onButtonClick(muteSpec) }, + size = 56.dp, + ) + } + + // 中心圆形方向轮盘 (D-Pad Wheel) + val upSpec = RemoteSceneConfig.Television.NAV_UP + val downSpec = RemoteSceneConfig.Television.NAV_DOWN + val leftSpec = RemoteSceneConfig.Television.NAV_LEFT + val rightSpec = RemoteSceneConfig.Television.NAV_RIGHT + val okSpec = RemoteSceneConfig.Television.OK + + RemoteDpadWheel( + upSpec = upSpec, + downSpec = downSpec, + leftSpec = leftSpec, + rightSpec = rightSpec, + okSpec = okSpec, + isUpLearned = learnedSlotMap[upSpec.defaultSlot]?.status == InfraredKeyStatus.READY, + isDownLearned = learnedSlotMap[downSpec.defaultSlot]?.status == InfraredKeyStatus.READY, + isLeftLearned = learnedSlotMap[leftSpec.defaultSlot]?.status == InfraredKeyStatus.READY, + isRightLearned = learnedSlotMap[rightSpec.defaultSlot]?.status == InfraredKeyStatus.READY, + isOkLearned = learnedSlotMap[okSpec.defaultSlot]?.status == InfraredKeyStatus.READY, + isUpLoading = activeLearningSlot == upSpec.defaultSlot || sendingKeySlot == upSpec.defaultSlot, + isDownLoading = activeLearningSlot == downSpec.defaultSlot || sendingKeySlot == downSpec.defaultSlot, + isLeftLoading = activeLearningSlot == leftSpec.defaultSlot || sendingKeySlot == leftSpec.defaultSlot, + isRightLoading = activeLearningSlot == rightSpec.defaultSlot || sendingKeySlot == rightSpec.defaultSlot, + isOkLoading = activeLearningSlot == okSpec.defaultSlot || sendingKeySlot == okSpec.defaultSlot, + isLearningMode = isLearningMode, + onUpClick = { onButtonClick(upSpec) }, + onDownClick = { onButtonClick(downSpec) }, + onLeftClick = { onButtonClick(leftSpec) }, + onRightClick = { onButtonClick(rightSpec) }, + onOkClick = { onButtonClick(okSpec) }, + ) + + // 系统功能按键行 (返回 / 主页 / 菜单) + Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.SpaceEvenly, + verticalAlignment = Alignment.CenterVertically, + ) { + TvActionButton(RemoteSceneConfig.Television.BACK, learnedSlotMap, activeLearningSlot, sendingKeySlot, isLearningMode, onButtonClick) + TvActionButton(RemoteSceneConfig.Television.HOME, learnedSlotMap, activeLearningSlot, sendingKeySlot, isLearningMode, onButtonClick) + TvActionButton(RemoteSceneConfig.Television.MENU, learnedSlotMap, activeLearningSlot, sendingKeySlot, isLearningMode, onButtonClick) + } + + Spacer(modifier = Modifier.height(4.dp)) + + // 音量与频道双摇杆胶囊 + Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.SpaceEvenly, + verticalAlignment = Alignment.CenterVertically, + ) { + // 音量控制 + val volUp = RemoteSceneConfig.Television.VOL_UP + val volDown = RemoteSceneConfig.Television.VOL_DOWN + VerticalCapsuleRocker( + upSpec = volUp, + downSpec = volDown, + isUpLearned = learnedSlotMap[volUp.defaultSlot]?.status == InfraredKeyStatus.READY, + isDownLearned = learnedSlotMap[volDown.defaultSlot]?.status == InfraredKeyStatus.READY, + isUpLoading = activeLearningSlot == volUp.defaultSlot || sendingKeySlot == volUp.defaultSlot, + isDownLoading = activeLearningSlot == volDown.defaultSlot || sendingKeySlot == volDown.defaultSlot, + isLearningMode = isLearningMode, + onUpClick = { onButtonClick(volUp) }, + onDownClick = { onButtonClick(volDown) }, + label = stringResource(R.string.infrared_label_vol), + ) + + // 频道控制 + val chUp = RemoteSceneConfig.Television.CH_UP + val chDown = RemoteSceneConfig.Television.CH_DOWN + VerticalCapsuleRocker( + upSpec = chUp, + downSpec = chDown, + isUpLearned = learnedSlotMap[chUp.defaultSlot]?.status == InfraredKeyStatus.READY, + isDownLearned = learnedSlotMap[chDown.defaultSlot]?.status == InfraredKeyStatus.READY, + isUpLoading = activeLearningSlot == chUp.defaultSlot || sendingKeySlot == chUp.defaultSlot, + isDownLoading = activeLearningSlot == chDown.defaultSlot || sendingKeySlot == chDown.defaultSlot, + isLearningMode = isLearningMode, + onUpClick = { onButtonClick(chUp) }, + onDownClick = { onButtonClick(chDown) }, + label = stringResource(R.string.infrared_label_ch), + ) + } + } +} + +@Composable +private fun TvActionButton( + spec: RemoteButtonSpec, + learnedSlotMap: Map, + activeLearningSlot: String?, + sendingKeySlot: String?, + isLearningMode: Boolean, + onButtonClick: (RemoteButtonSpec) -> Unit, +) { + RemoteRectButton( + spec = spec, + isLearned = learnedSlotMap[spec.defaultSlot]?.status == InfraredKeyStatus.READY, + isLoading = activeLearningSlot == spec.defaultSlot || sendingKeySlot == spec.defaultSlot, + isLearningMode = isLearningMode, + onClick = { onButtonClick(spec) }, + width = 84.dp, + height = 44.dp, + ) +} diff --git a/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/ui/InfraredControlScreen.kt b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/ui/InfraredControlScreen.kt new file mode 100644 index 0000000..c9b0674 --- /dev/null +++ b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/ui/InfraredControlScreen.kt @@ -0,0 +1,303 @@ +package com.flagship.abox.manager.infrared.ui + +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.rememberScrollState +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.foundation.verticalScroll +import androidx.compose.material3.Button +import androidx.compose.material3.Card +import androidx.compose.material3.CardDefaults +import androidx.compose.material3.CircularProgressIndicator +import androidx.compose.material3.ExperimentalMaterial3Api +import androidx.compose.material3.LinearProgressIndicator +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.OutlinedTextField +import androidx.compose.material3.Scaffold +import androidx.compose.material3.SnackbarHost +import androidx.compose.material3.SnackbarHostState +import androidx.compose.material3.Text +import androidx.compose.material3.TextButton +import androidx.compose.material3.TopAppBar +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.remember +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.clip +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.platform.testTag +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp +import androidx.hilt.navigation.compose.hiltViewModel +import androidx.lifecycle.compose.collectAsStateWithLifecycle +import com.flagship.abox.manager.designsystem.ABoxSurface +import com.flagship.abox.manager.domain.ProviderType +import com.flagship.abox.manager.domain.infrared.SlotQuotaSummary +import com.flagship.abox.manager.infrared.R +import com.flagship.abox.manager.infrared.remote.UiText + +@Composable +fun InfraredControlRoute( + onBack: () -> Unit, + onSessionInvalid: () -> Unit, + viewModel: InfraredControlViewModel = hiltViewModel(), +) { + val state by viewModel.state.collectAsStateWithLifecycle() + + InfraredControlScreen( + state = state, + onBack = onBack, + onSessionInvalid = onSessionInvalid, + onDeviceNameChanged = viewModel::onDeviceNameChanged, + onSaveDeviceName = viewModel::saveDeviceName, + onMessageShown = viewModel::clearMessage, + ) +} + +@OptIn(ExperimentalMaterial3Api::class) +@Composable +internal fun InfraredControlScreen( + state: InfraredControlUiState, + onBack: () -> Unit, + onSessionInvalid: () -> Unit, + onDeviceNameChanged: (String) -> Unit, + onSaveDeviceName: () -> Unit, + onMessageShown: () -> Unit, +) { + val snackbarHostState = remember { SnackbarHostState() } + val context = LocalContext.current + val scrollState = rememberScrollState() + + LaunchedEffect(state.message) { + state.message?.let { msg -> + when (msg) { + is InfraredUiMessage.Info -> { + val text = when (val t = msg.text) { + is UiText.DynamicString -> t.value + is UiText.StringResource -> context.getString(t.resId, *t.args.toTypedArray()) + } + snackbarHostState.showSnackbar(text) + onMessageShown() + } + is InfraredUiMessage.Error -> { + val text = when (val t = msg.text) { + is UiText.DynamicString -> t.value + is UiText.StringResource -> context.getString(t.resId, *t.args.toTypedArray()) + } + snackbarHostState.showSnackbar(text) + onMessageShown() + } + is InfraredUiMessage.SessionInvalid -> { + onSessionInvalid() + onMessageShown() + } + } + } + } + + Scaffold( + topBar = { + TopAppBar( + title = { Text(stringResource(R.string.infrared_control_title)) }, + navigationIcon = { + TextButton(onClick = onBack) { + Text(stringResource(R.string.infrared_back)) + } + }, + ) + }, + snackbarHost = { SnackbarHost(snackbarHostState) }, + ) { innerPadding -> + ABoxSurface( + modifier = Modifier + .fillMaxSize() + .padding(innerPadding), + ) { + if (state.loading) { + Box(modifier = Modifier.fillMaxSize(), contentAlignment = Alignment.Center) { + CircularProgressIndicator() + } + } else { + Column( + modifier = Modifier + .fillMaxSize() + .verticalScroll(scrollState) + .padding(16.dp), + verticalArrangement = Arrangement.spacedBy(16.dp), + ) { + // 1. 当前环境卡片 + Card(modifier = Modifier.fillMaxWidth()) { + Column( + modifier = Modifier + .fillMaxWidth() + .padding(16.dp), + verticalArrangement = Arrangement.spacedBy(8.dp), + ) { + Text( + text = "运行环境与连接信息", + style = MaterialTheme.typography.titleMedium.copy(fontWeight = FontWeight.Bold), + ) + + val envText = when (state.providerType) { + ProviderType.LOCAL_EXPERIENCE -> stringResource(R.string.infrared_mode_local_simulation) + ProviderType.ABOX -> stringResource(R.string.infrared_mode_abox_real) + null -> state.profileId?.value ?: "未知环境" + } + Text( + text = stringResource(R.string.infrared_mode_label, envText), + style = MaterialTheme.typography.bodyMedium, + color = MaterialTheme.colorScheme.primary, + fontWeight = FontWeight.Medium, + ) + + state.providerDisplayName?.let { + Text( + text = "当前 Profile: $it", + fontSize = 13.sp, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + } + } + + // 2. ABSDK 硬件设备名称配置（修改当前设备名） + Card( + modifier = Modifier.fillMaxWidth(), + colors = CardDefaults.cardColors( + containerColor = MaterialTheme.colorScheme.surfaceVariant, + ), + ) { + Column( + modifier = Modifier + .fillMaxWidth() + .padding(16.dp), + verticalArrangement = Arrangement.spacedBy(12.dp), + ) { + Text( + text = stringResource(R.string.infrared_device_config_section), + style = MaterialTheme.typography.titleMedium.copy(fontWeight = FontWeight.Bold), + ) + + Text( + text = stringResource(R.string.infrared_device_config_desc), + fontSize = 12.sp, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + + Text( + text = stringResource(R.string.infrared_device_name_current, state.savedDeviceName.value), + fontWeight = FontWeight.Bold, + color = MaterialTheme.colorScheme.primary, + fontSize = 14.sp, + ) + + Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.spacedBy(8.dp), + verticalAlignment = Alignment.CenterVertically, + ) { + OutlinedTextField( + value = state.deviceNameInput, + onValueChange = onDeviceNameChanged, + label = { Text("修改设备名（如：红外控制器）") }, + singleLine = true, + modifier = Modifier + .weight(1f) + .testTag("infrared_device_name_input"), + ) + + Button( + onClick = onSaveDeviceName, + enabled = state.deviceNameInput.isNotBlank() && state.deviceNameInput != state.savedDeviceName.value, + modifier = Modifier.testTag("infrared_save_device_button"), + ) { + Text(stringResource(R.string.infrared_device_save_changes)) + } + } + } + } + + // 3. 硬件槽位与遥控器概览 + Card(modifier = Modifier.fillMaxWidth()) { + Column( + modifier = Modifier + .fillMaxWidth() + .padding(16.dp), + verticalArrangement = Arrangement.spacedBy(12.dp), + ) { + Text( + text = stringResource(R.string.infrared_device_stats_section), + style = MaterialTheme.typography.titleMedium.copy(fontWeight = FontWeight.Bold), + ) + + Text( + text = "已配置的虚拟遥控器：${state.totalRemotesCount} 个", + style = MaterialTheme.typography.bodyMedium, + ) + + QuotaDetailProgress(quota = state.slotQuota) + + Card( + colors = CardDefaults.cardColors( + containerColor = MaterialTheme.colorScheme.background, + ), + modifier = Modifier.fillMaxWidth(), + ) { + Column( + modifier = Modifier.padding(12.dp), + verticalArrangement = Arrangement.spacedBy(4.dp), + ) { + Text("💡 槽位工作原理：", fontWeight = FontWeight.Bold, fontSize = 12.sp) + Text("• 静态独占槽位 (Slot 1..99)：用于物理学习录制的按键或预设静态按键，硬件直发低延迟（~20ms）。", fontSize = 11.sp, color = MaterialTheme.colorScheme.onSurfaceVariant) + Text("• 动态共享缓冲 (Slot 100)：用于空调全状态算法写码与动态模式遥控器，按需现场写入发射，不消耗独占槽位。", fontSize = 11.sp, color = MaterialTheme.colorScheme.onSurfaceVariant) + } + } + } + } + } + } + } + } +} + +@Composable +private fun QuotaDetailProgress(quota: SlotQuotaSummary) { + Column(verticalArrangement = Arrangement.spacedBy(6.dp)) { + Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.SpaceBetween, + verticalAlignment = Alignment.CenterVertically, + ) { + Text( + text = "槽位总容量占用: ${quota.usedCount} / ${quota.totalCapacity}", + fontWeight = FontWeight.Medium, + fontSize = 13.sp, + ) + Text( + text = "剩余可用静态槽位: ${quota.remainingStaticCount}", + fontSize = 12.sp, + color = if (quota.isStaticFull) MaterialTheme.colorScheme.error else MaterialTheme.colorScheme.primary, + fontWeight = FontWeight.Bold, + ) + } + + LinearProgressIndicator( + progress = { quota.usedCount.toFloat() / quota.totalCapacity.toFloat() }, + modifier = Modifier + .fillMaxWidth() + .height(8.dp) + .clip(RoundedCornerShape(4.dp)), + ) + } +} diff --git a/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/ui/InfraredControlUiState.kt b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/ui/InfraredControlUiState.kt new file mode 100644 index 0000000..92602dc --- /dev/null +++ b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/ui/InfraredControlUiState.kt @@ -0,0 +1,25 @@ +package com.flagship.abox.manager.infrared.ui + +import com.flagship.abox.manager.domain.DeviceName +import com.flagship.abox.manager.domain.ProviderProfileId +import com.flagship.abox.manager.domain.ProviderType +import com.flagship.abox.manager.domain.infrared.SlotQuotaSummary +import com.flagship.abox.manager.infrared.remote.UiText + +sealed interface InfraredUiMessage { + data class Info(val text: UiText) : InfraredUiMessage + data class Error(val text: UiText) : InfraredUiMessage + data object SessionInvalid : InfraredUiMessage +} + +data class InfraredControlUiState( + val profileId: ProviderProfileId? = null, + val providerType: ProviderType? = null, + val providerDisplayName: String? = null, + val deviceNameInput: String = "", + val savedDeviceName: DeviceName = DeviceName("红外控制器"), + val slotQuota: SlotQuotaSummary = SlotQuotaSummary(), + val totalRemotesCount: Int = 0, + val loading: Boolean = true, + val message: InfraredUiMessage? = null, +) diff --git a/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/ui/InfraredControlViewModel.kt b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/ui/InfraredControlViewModel.kt new file mode 100644 index 0000000..2d494ac --- /dev/null +++ b/android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/ui/InfraredControlViewModel.kt @@ -0,0 +1,184 @@ +package com.flagship.abox.manager.infrared.ui + +import androidx.lifecycle.SavedStateHandle +import androidx.lifecycle.ViewModel +import androidx.lifecycle.viewModelScope +import com.flagship.abox.manager.domain.DeviceName +import com.flagship.abox.manager.domain.DomainError +import com.flagship.abox.manager.domain.DomainResult +import com.flagship.abox.manager.domain.ProviderProfileId +import com.flagship.abox.manager.domain.ProviderProfileStore +import com.flagship.abox.manager.domain.infrared.InfraredDeviceConfigurationRepository +import com.flagship.abox.manager.domain.infrared.SlotQuotaSummary +import com.flagship.abox.manager.domain.infrared.VirtualRemoteRepository +import com.flagship.abox.manager.infrared.R +import com.flagship.abox.manager.infrared.remote.UiText +import dagger.hilt.android.lifecycle.HiltViewModel +import kotlinx.coroutines.ExperimentalCoroutinesApi +import kotlinx.coroutines.flow.Flow +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.SharingStarted +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.combine +import kotlinx.coroutines.flow.flatMapLatest +import kotlinx.coroutines.flow.flowOf +import kotlinx.coroutines.flow.stateIn +import kotlinx.coroutines.launch +import javax.inject.Inject + +@OptIn(ExperimentalCoroutinesApi::class) +@HiltViewModel +class InfraredControlViewModel @Inject constructor( + savedStateHandle: SavedStateHandle, + private val deviceConfigurationRepository: InfraredDeviceConfigurationRepository, + private val virtualRemoteRepository: VirtualRemoteRepository, + private val providerProfileStore: ProviderProfileStore, +) : ViewModel() { + + private val rawProfileId: String? = savedStateHandle["profileId"] + val profileId: ProviderProfileId? = rawProfileId?.takeIf { it.isNotBlank() }?.let { ProviderProfileId(it) } + + private val deviceNameInputFlow = MutableStateFlow(null) + private val messageFlow = MutableStateFlow(null) + + private data class ServerState( + val providerProfile: com.flagship.abox.manager.domain.ProviderProfile? = null, + val savedDevice: DeviceName = DEFAULT_DEVICE_NAME, + val slotQuota: SlotQuotaSummary = SlotQuotaSummary(), + val remotesCount: Int = 0, + val loading: Boolean = false, + val configError: DomainError? = null, + ) + + private val serverStateFlow: Flow = + if (profileId == null) { + flowOf(ServerState(loading = false)) + } else { + providerProfileStore.observeProfiles().flatMapLatest { profiles -> + val active = profiles.find { it.id == profileId } + deviceConfigurationRepository.observeDeviceName(profileId).flatMapLatest { deviceResult -> + when (deviceResult) { + is DomainResult.Failure -> flowOf( + ServerState( + providerProfile = active, + configError = deviceResult.error, + ), + ) + is DomainResult.Success -> { + val deviceName = deviceResult.value ?: DEFAULT_DEVICE_NAME + combine( + virtualRemoteRepository.observeRemotes(profileId, deviceName), + virtualRemoteRepository.observeSlotQuota(profileId, deviceName), + ) { remotesResult, quotaResult -> + val remotes = (remotesResult as? DomainResult.Success)?.value ?: emptyList() + val quota = (quotaResult as? DomainResult.Success)?.value + ?: SlotQuotaSummary() + ServerState( + providerProfile = active, + savedDevice = deviceName, + slotQuota = quota, + remotesCount = remotes.size, + loading = false, + ) + } + } + } + } + } + } + + val state: StateFlow = combine( + serverStateFlow, + deviceNameInputFlow, + messageFlow, + ) { serverState, input, msg -> + val resolvedMessage = msg ?: serverState.configError?.let { error -> + when (error) { + is DomainError.TokenInvalid, is DomainError.Authentication -> InfraredUiMessage.SessionInvalid + is DomainError.DeviceOffline -> InfraredUiMessage.Error( + UiText.StringResource(R.string.infrared_msg_device_offline, listOf(error.externalCode ?: "20206")), + ) + else -> InfraredUiMessage.Error( + error.detail?.let { UiText.DynamicString(it) } + ?: UiText.StringResource(R.string.infrared_msg_load_failed), + ) + } + } + + val effectiveInput = input ?: serverState.savedDevice.value + + InfraredControlUiState( + profileId = profileId, + providerType = serverState.providerProfile?.type, + providerDisplayName = serverState.providerProfile?.displayName, + deviceNameInput = effectiveInput, + savedDeviceName = serverState.savedDevice, + slotQuota = serverState.slotQuota, + totalRemotesCount = serverState.remotesCount, + loading = serverState.loading, + message = resolvedMessage, + ) + }.stateIn( + scope = viewModelScope, + started = SharingStarted.WhileSubscribed(5_000), + initialValue = InfraredControlUiState(profileId = profileId, loading = true), + ) + + fun onDeviceNameChanged(value: String) { + deviceNameInputFlow.value = value + } + + fun saveDeviceName() { + val currentProfile = profileId ?: return + val input = deviceNameInputFlow.value ?: state.value.savedDeviceName.value + val trimmed = input.trim() + if (trimmed.isBlank()) { + messageFlow.value = InfraredUiMessage.Error( + UiText.StringResource(R.string.infrared_msg_device_name_blank), + ) + return + } + viewModelScope.launch { + when (val result = deviceConfigurationRepository.setDeviceName(currentProfile, DeviceName(trimmed))) { + is DomainResult.Success -> { + messageFlow.value = InfraredUiMessage.Info( + UiText.StringResource(R.string.infrared_msg_device_name_saved), + ) + } + is DomainResult.Failure -> { + handleDomainError(result.error) + } + } + } + } + + fun clearMessage() { + messageFlow.value = null + } + + private fun handleDomainError(error: DomainError) { + when (error) { + is DomainError.TokenInvalid, is DomainError.Authentication -> { + messageFlow.value = InfraredUiMessage.SessionInvalid + } + is DomainError.DeviceOffline -> { + messageFlow.value = InfraredUiMessage.Error( + UiText.StringResource( + R.string.infrared_msg_device_offline, + listOf(error.externalCode ?: "20206"), + ), + ) + } + else -> { + messageFlow.value = InfraredUiMessage.Error( + error.detail?.let { UiText.DynamicString(it) } + ?: UiText.StringResource(R.string.infrared_msg_operation_failed), + ) + } + } + } + + companion object { + val DEFAULT_DEVICE_NAME = DeviceName("红外控制器") + } +} diff --git a/android/feature/infrared/src/main/res/values-zh-rCN/strings.xml b/android/feature/infrared/src/main/res/values-zh-rCN/strings.xml new file mode 100644 index 0000000..4382170 --- /dev/null +++ b/android/feature/infrared/src/main/res/values-zh-rCN/strings.xml @@ -0,0 +1,116 @@ + + 红外遥控 + 模式：模拟体验 + 模式：ABBox 真实硬件 + 切换模式 + 红外设备名称 + 例如：ir-living + 已配置设备：%1$s + 未配置红外设备 + 保存设备 + 已学习按键 + 暂无已保存按键 + 学习新按键 + 学习中… + 已就绪 + 学习失败 + 发射 + 发射中… + 重试 + 重命名 + 删除 + 学习红外按键 + 请准备好实体遥控器，点击开始后将遥控器对准红外转发器并按下目标按键。 + 按键名称（如：电源） + 按键槽位（1-100） + 按键编号：%1$s + 开始学习 + 重命名按键 + 新按键名称 + 删除按键 + 仅从本机删除该按键记录，ABox 主机上可能仍保留已录制码值。 + 取消 + 确认 + 返回 + 红外遥控器 + 录制中 + 学习模式 + 🔴 学习模式已开启：点击任意按键开始录制实体遥控器信号 + ❄️ 空调面板 + 📺 电视面板 + 设置 + + 🔴 学习模式已开启：点击任意按键开始录制 + 正在录制【%1$s】（槽位 %2$s），请按下实体遥控器按键… + 【%1$s】录制成功 + 按键【%1$s】尚未学习，开启右上角学习模式即可录制 + 已发射信号：%1$s + 红外设备离线（错误码：%1$s） + 加载数据失败 + 操作失败 + 温度调节 + 音量 + 频道 + ❄️ 制冷模式 + 💨 自动风速 | ↔ 自动扫风 + + 空调-电源 + 空调-升温 + 空调-降温 + 空调-模式 + 空调-风速 + 空调-扫风 + 空调-定时 + + 电视-电源 + 电视-静音 + 电视-向上 + 电视-向下 + 电视-向左 + 电视-向右 + 电视-确定 + 电视-音量+ + 电视-音量- + 电视-频道+ + 电视-频道- + 电视-主页 + 电视-返回 + 红外设备与环境配置 + ABSDK 设备名称配置 + ABSDK 依靠此设备名称（默认为 红外控制器）寻址具体的硬件转发器，请确保名称与主机端保持一致。 + 当前绑定设备：%1$s + 保存修改 + 硬件槽位与遥控器概览 + 运行环境：%1$s + 本地体验（模拟） + ABox（真实硬件） + 设备名称已成功保存 + 设备名称不能为空 + 按键名称不能为空 + 按键编号必须在 1 到 100 之间 + 按键已重命名 + 按键已从本机删除 + 按键尚未就绪，无法发射 + 红外中枢 + 我的遥控器 + 硬件槽位：%1$d / %2$d 已占用（剩余 %3$d） + 静态占用：%1$d + 动态缓冲：Slot %1$s + 虚拟遥控器 + 暂无虚拟遥控器，点击右上角或下方 ➕ 添加 + 添加遥控器 + 🚀 静态独占（%1$s 槽位） + 📦 动态缓冲（共用 Slot %1$s） + 添加虚拟遥控器 + 设备类型 + 预设码库 / 品牌 + 传输模式 + 超低延迟（~20ms），极速响应，占用 ~15 个硬件槽位 + 节省槽位（0 额外槽位），现场写码发射（~80ms） + 硬件槽位不足，请选择动态写码模式 + 硬件槽位与底层按键管理 + 📺 电视机 / 电视盒子 + ❄️ 空调设备 + 🌀 电风扇 / 空气净化器 + 🎛️ 自定义面板 + diff --git a/android/feature/infrared/src/main/res/values/strings.xml b/android/feature/infrared/src/main/res/values/strings.xml new file mode 100644 index 0000000..e9a5a6f --- /dev/null +++ b/android/feature/infrared/src/main/res/values/strings.xml @@ -0,0 +1,117 @@ + + Infrared Control + Mode: Fake / Simulated + Mode: Real ABSDK + Switch Mode + Infrared Device Name + e.g. ir-living + Saved Device: %1$s + No infrared device configured + Save Device + Learned Keys + No infrared keys saved + Learn New Key + Learning… + Ready + Failed + Send + Sending… + Retry + Rename + Delete + Learn Infrared Key + Prepare the physical remote. After starting, point it at the infrared controller and press the target button. + Key Name (e.g. Power) + Key Slot (1-100) + Key Slot: %1$s + Start Learning + Rename Key + New Display Name + Delete Key + Only removes the key locally from this app. ABox server may retain the learned key. + Cancel + Confirm + Back + Infrared Remote + Recording + My Remotes + Learn Mode + 🔴 Learn mode active: tap any button to record + ❄️ Air Conditioner + 📺 Television + Settings + + 🔴 Learn mode active: tap any button to record + Recording [%1$s] (Slot %2$s), press remote button… + [%1$s] recorded successfully + Button [%1$s] is not learned. Enable learn mode to record. + Sent: %1$s + Infrared controller offline (code: %1$s) + Failed to load data + Operation failed + Temp Control + VOL + CH + ❄️ Cool Mode + 💨 Auto Fan | ↔ Swing + + AC Power + AC Temp + + AC Temp - + AC Mode + AC Fan Speed + AC Swing + AC Timer + + TV Power + TV Mute + TV Up + TV Down + TV Left + TV Right + TV OK + TV Vol + + TV Vol - + TV CH + + TV CH - + TV Home + TV Back + TV Menu + Device Configuration + ABSDK Device Name + ABSDK matches hardware devices by device name (default: 红外控制器). Commands will be dispatched to this target device. + Current Bound Device: %1$s + Save Changes + Hardware Slot Budget + Environment: %1$s + Local Experience (Simulation) + ABox (Real Hardware) + Device name saved successfully + Device name cannot be blank + Key name cannot be blank + Key slot must be between 1 and 100 + Key renamed + Key removed locally + Key is not ready to send + Infrared Hub + Hardware Slots: %1$d / %2$d allocated (%3$d free) + Static: %1$d + Dynamic Buffer: Slot %1$s + Virtual Remotes + No virtual remotes added yet. Tap + to add one. + Add Remote + 🚀 Static Mode (%1$s slots) + 📦 Dynamic Mode (Scratch Slot %1$s) + Add Virtual Remote + Device Type + Brand / Preset Library + Transmission Mode + Low latency (~20ms), instant response, occupies ~15 slots + Saves slots (0 extra slots), writes code on-the-fly (~80ms) + Slot quota exceeded. Please choose Dynamic mode. + Hardware Slot / Raw Key Management + 📺 Television (TV) + ❄️ Air Conditioner (AC) + 🌀 Fan / Air Purifier + 🎛️ Custom Panel + diff --git a/android/feature/infrared/src/test/kotlin/com/flagship/abox/manager/infrared/application/InfraredLearningCoordinatorTest.kt b/android/feature/infrared/src/test/kotlin/com/flagship/abox/manager/infrared/application/InfraredLearningCoordinatorTest.kt new file mode 100644 index 0000000..3d4bee1 --- /dev/null +++ b/android/feature/infrared/src/test/kotlin/com/flagship/abox/manager/infrared/application/InfraredLearningCoordinatorTest.kt @@ -0,0 +1,156 @@ +package com.flagship.abox.manager.infrared.application + +import com.flagship.abox.manager.domain.DeviceName +import com.flagship.abox.manager.domain.DomainResult +import com.flagship.abox.manager.domain.ProviderProfileId +import com.flagship.abox.manager.domain.infrared.EpochMillisClock +import com.flagship.abox.manager.domain.infrared.InfraredKeyFactory +import com.flagship.abox.manager.domain.infrared.InfraredKeyId +import com.flagship.abox.manager.domain.infrared.InfraredKeyRef +import com.flagship.abox.manager.domain.infrared.InfraredKeyStatus +import com.flagship.abox.manager.domain.infrared.LearnInfraredKey +import com.flagship.abox.manager.domain.infrared.RelearnInfraredKey +import com.flagship.abox.manager.domain.infrared.RetryInfraredKeyLearning +import com.flagship.abox.manager.domain.infrared.SavedInfraredKey +import com.flagship.abox.manager.testing.fakes.FakeInfraredGateway +import com.flagship.abox.manager.testing.fakes.FakeInfraredKeyRepository +import kotlinx.coroutines.ExperimentalCoroutinesApi +import kotlinx.coroutines.flow.first +import kotlinx.coroutines.test.TestScope +import kotlinx.coroutines.test.advanceUntilIdle +import kotlinx.coroutines.test.runTest +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Test + +@OptIn(ExperimentalCoroutinesApi::class) +class InfraredLearningCoordinatorTest { + + private val profile = ProviderProfileId("profile1") + private val device = DeviceName("ir-1") + private val clock = EpochMillisClock { 1_000L } + private val repository = FakeInfraredKeyRepository() + private val gateway = FakeInfraredGateway() + private val factory = InfraredKeyFactory({ InfraredKeyId("key1") }, clock) + + private val learn = LearnInfraredKey(repository, gateway, factory, clock) + private val retry = RetryInfraredKeyLearning(repository, gateway, clock) + private val relearn = RelearnInfraredKey(repository, gateway, clock) + + @Test + fun learnRunsAsynchronouslyInExternalScope() = runTest { + val coordinator = InfraredLearningCoordinator(learn, retry, relearn, repository, this) + + coordinator.learn(profile, device, "Power") + advanceUntilIdle() + + val keysResult = repository.observeKeys(profile, device).first() + assertTrue(keysResult is DomainResult.Success) + val keys = (keysResult as DomainResult.Success).value + assertEquals(1, keys.size) + assertEquals(InfraredKeyStatus.READY, keys.single().status) + } + + @Test + fun retryRunsAsynchronouslyInExternalScope() = runTest { + val failedKey = SavedInfraredKey( + id = InfraredKeyId("key1"), + profileId = profile, + deviceName = device, + displayName = "Power", + sdkKey = "app_ir_key1", + status = InfraredKeyStatus.FAILED, + lastErrorCode = "20206", + lastErrorDetail = "offline", + createdAtEpochMillis = 500L, + updatedAtEpochMillis = 500L, + ) + repository.insert(failedKey) + + val coordinator = InfraredLearningCoordinator(learn, retry, relearn, repository, this) + + coordinator.retry(InfraredKeyRef(profile, InfraredKeyId("key1"))) + advanceUntilIdle() + + val updated = (repository.getKey(InfraredKeyRef(profile, InfraredKeyId("key1"))) as DomainResult.Success).value!! + assertEquals(InfraredKeyStatus.READY, updated.status) + } + + @Test + fun relearnRunsAsynchronouslyInExternalScope() = runTest { + val readyKey = SavedInfraredKey( + id = InfraredKeyId("key1"), + profileId = profile, + deviceName = device, + displayName = "Power", + sdkKey = "app_ir_key1", + status = InfraredKeyStatus.READY, + lastErrorCode = null, + lastErrorDetail = null, + createdAtEpochMillis = 500L, + updatedAtEpochMillis = 500L, + ) + repository.insert(readyKey) + + val coordinator = InfraredLearningCoordinator(learn, retry, relearn, repository, this) + + coordinator.relearn(InfraredKeyRef(profile, InfraredKeyId("key1"))) + advanceUntilIdle() + + val updated = (repository.getKey(InfraredKeyRef(profile, InfraredKeyId("key1"))) as DomainResult.Success).value!! + assertEquals(InfraredKeyStatus.READY, updated.status) + } + + @Test + fun failInterruptedLearningFailsLearningKeys() = runTest { + val learningKey = SavedInfraredKey( + id = InfraredKeyId("key1"), + profileId = profile, + deviceName = device, + displayName = "Power", + sdkKey = "app_ir_key1", + status = InfraredKeyStatus.LEARNING, + lastErrorCode = null, + lastErrorDetail = null, + createdAtEpochMillis = 500L, + updatedAtEpochMillis = 500L, + ) + repository.insert(learningKey) + + val coordinator = InfraredLearningCoordinator(learn, retry, relearn, repository, this) + + coordinator.failInterruptedLearning(profile, 2_000L) + advanceUntilIdle() + + val updated = (repository.getKey(InfraredKeyRef(profile, InfraredKeyId("key1"))) as DomainResult.Success).value!! + assertEquals(InfraredKeyStatus.FAILED, updated.status) + } + + @Test + fun subsequentLearnWaitsForCleanupCompletion() = runTest { + val learningKey = SavedInfraredKey( + id = InfraredKeyId("key1"), + profileId = profile, + deviceName = device, + displayName = "Power", + sdkKey = "1", + status = InfraredKeyStatus.READY, + lastErrorCode = null, + lastErrorDetail = null, + createdAtEpochMillis = 500L, + updatedAtEpochMillis = 500L, + ) + repository.insert(learningKey) + + val coordinator = InfraredLearningCoordinator(learn, retry, relearn, repository, this) + + coordinator.failInterruptedLearning(profile, cutoffEpochMillis = 1000L) + val relearnJob = coordinator.relearn(InfraredKeyRef(profile, InfraredKeyId("key1"))) + advanceUntilIdle() + + val relearnResult = relearnJob.await() + assertTrue(relearnResult is DomainResult.Success) + val updated = (repository.getKey(InfraredKeyRef(profile, InfraredKeyId("key1"))) as DomainResult.Success).value!! + assertEquals(InfraredKeyStatus.READY, updated.status) + } +} diff --git a/android/feature/infrared/src/test/kotlin/com/flagship/abox/manager/infrared/hub/InfraredHubViewModelTest.kt b/android/feature/infrared/src/test/kotlin/com/flagship/abox/manager/infrared/hub/InfraredHubViewModelTest.kt new file mode 100644 index 0000000..2c5428a --- /dev/null +++ b/android/feature/infrared/src/test/kotlin/com/flagship/abox/manager/infrared/hub/InfraredHubViewModelTest.kt @@ -0,0 +1,163 @@ +package com.flagship.abox.manager.infrared.hub + +import androidx.lifecycle.SavedStateHandle +import com.flagship.abox.manager.domain.DeviceName +import com.flagship.abox.manager.domain.DomainResult +import com.flagship.abox.manager.domain.ProviderProfile +import com.flagship.abox.manager.domain.ProviderProfileId +import com.flagship.abox.manager.domain.ProviderType +import com.flagship.abox.manager.domain.infrared.CreateVirtualRemote +import com.flagship.abox.manager.domain.infrared.DeleteVirtualRemote +import com.flagship.abox.manager.domain.infrared.EpochMillisClock +import com.flagship.abox.manager.domain.infrared.RemoteDeviceType +import com.flagship.abox.manager.domain.infrared.TransmissionMode +import com.flagship.abox.manager.testing.fakes.FakeInfraredDeviceConfigurationRepository +import com.flagship.abox.manager.testing.fakes.FakeInfraredGateway +import com.flagship.abox.manager.testing.fakes.FakeProviderProfileStore +import com.flagship.abox.manager.testing.fakes.FakeVirtualRemoteRepository +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.ExperimentalCoroutinesApi +import kotlinx.coroutines.launch +import kotlinx.coroutines.test.StandardTestDispatcher +import kotlinx.coroutines.test.TestScope +import kotlinx.coroutines.test.advanceUntilIdle +import kotlinx.coroutines.test.resetMain +import kotlinx.coroutines.test.runTest +import kotlinx.coroutines.test.setMain +import org.junit.After +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Before +import org.junit.Test + +@OptIn(ExperimentalCoroutinesApi::class) +class InfraredHubViewModelTest { + + private val testDispatcher = StandardTestDispatcher() + private val testScope = TestScope(testDispatcher) + + private val profileId = ProviderProfileId("profile1") + private val providerProfile = ProviderProfile(profileId, ProviderType.LOCAL_EXPERIENCE, "Local Simulation") + private val device = DeviceName("ir-1") + private val clock = EpochMillisClock { 10_000L } + + private val profileStore = FakeProviderProfileStore() + private val deviceRepo = FakeInfraredDeviceConfigurationRepository() + private val remoteRepo = FakeVirtualRemoteRepository() + private val gateway = FakeInfraredGateway() + + private val createRemote = CreateVirtualRemote(remoteRepo, gateway, clock) + private val deleteRemote = DeleteVirtualRemote(remoteRepo) + + @Before + fun setup() { + Dispatchers.setMain(testDispatcher) + } + + @After + fun teardown() { + Dispatchers.resetMain() + } + + private fun createViewModel(): InfraredHubViewModel = InfraredHubViewModel( + savedStateHandle = SavedStateHandle(mapOf("profileId" to "profile1")), + providerProfileStore = profileStore, + deviceConfigurationRepository = deviceRepo, + virtualRemoteRepository = remoteRepo, + createVirtualRemote = createRemote, + deleteVirtualRemote = deleteRemote, + ) + + @Test + fun initialStateLoadsRemotesAndSlotQuota() = testScope.runTest { + profileStore.saveProfile(providerProfile) + deviceRepo.setDeviceName(profileId, device) + + val vm = createViewModel() + val job = launch { vm.state.collect {} } + advanceUntilIdle() + + assertEquals(ProviderType.LOCAL_EXPERIENCE, vm.state.value.providerType) + assertEquals(device, vm.state.value.savedDeviceName) + assertEquals(0, vm.state.value.remotes.size) + assertEquals(99, vm.state.value.slotQuota.remainingStaticCount) + + job.cancel() + } + + @Test + fun createRemoteAddsToRepositoryAndUpdatesState() = testScope.runTest { + profileStore.saveProfile(providerProfile) + deviceRepo.setDeviceName(profileId, device) + + val vm = createViewModel() + val job = launch { vm.state.collect {} } + advanceUntilIdle() + + vm.createRemote( + name = "Living Room TV", + type = RemoteDeviceType.TV, + brandModel = "generic_tv", + transmissionMode = TransmissionMode.STATIC_SLOTS, + ) + advanceUntilIdle() + + assertEquals(1, vm.state.value.remotes.size) + assertEquals("Living Room TV", vm.state.value.remotes.first().displayName) + assertEquals(TransmissionMode.STATIC_SLOTS, vm.state.value.remotes.first().transmissionMode) + + job.cancel() + } + + @Test + fun deleteRemoteRemovesFromRepository() = testScope.runTest { + profileStore.saveProfile(providerProfile) + deviceRepo.setDeviceName(profileId, device) + + val vm = createViewModel() + val job = launch { vm.state.collect {} } + advanceUntilIdle() + + vm.createRemote( + name = "Fan", + type = RemoteDeviceType.FAN, + transmissionMode = TransmissionMode.DYNAMIC_SCRATCH, + ) + advanceUntilIdle() + + val remoteId = vm.state.value.remotes.first().id + vm.deleteRemote(remoteId) + advanceUntilIdle() + + assertEquals(0, vm.state.value.remotes.size) + + job.cancel() + } + + @Test + fun createCustomRemoteWithTvLayoutAssignsLayoutAndStaticSlots() = testScope.runTest { + profileStore.saveProfile(providerProfile) + deviceRepo.setDeviceName(profileId, device) + + val vm = createViewModel() + val job = launch { vm.state.collect {} } + advanceUntilIdle() + + vm.createRemote( + name = "Custom TV Remote", + type = RemoteDeviceType.CUSTOM, + brandModel = null, + transmissionMode = TransmissionMode.STATIC_SLOTS, + layoutStyle = com.flagship.abox.manager.domain.infrared.PanelLayoutStyle.TV_NAV, + ) + advanceUntilIdle() + + assertEquals(1, vm.state.value.remotes.size) + val created = vm.state.value.remotes.first() + assertEquals("Custom TV Remote", created.displayName) + assertEquals(com.flagship.abox.manager.domain.infrared.PanelLayoutStyle.TV_NAV, created.layoutStyle) + assertEquals(TransmissionMode.STATIC_SLOTS, created.transmissionMode) + + job.cancel() + } +} diff --git a/android/feature/infrared/src/test/kotlin/com/flagship/abox/manager/infrared/panel/RemotePanelViewModelTest.kt b/android/feature/infrared/src/test/kotlin/com/flagship/abox/manager/infrared/panel/RemotePanelViewModelTest.kt new file mode 100644 index 0000000..8db53e1 --- /dev/null +++ b/android/feature/infrared/src/test/kotlin/com/flagship/abox/manager/infrared/panel/RemotePanelViewModelTest.kt @@ -0,0 +1,229 @@ +package com.flagship.abox.manager.infrared.panel + +import androidx.lifecycle.SavedStateHandle +import com.flagship.abox.manager.domain.DeviceName +import com.flagship.abox.manager.domain.ProviderProfileId +import com.flagship.abox.manager.domain.infrared.AcFanSpeed +import com.flagship.abox.manager.domain.infrared.AcMode +import com.flagship.abox.manager.domain.infrared.AddVirtualRemoteKey +import com.flagship.abox.manager.domain.infrared.CreateVirtualRemote +import com.flagship.abox.manager.domain.infrared.DeleteVirtualRemoteKey +import com.flagship.abox.manager.domain.infrared.EpochMillisClock +import com.flagship.abox.manager.domain.infrared.LearnVirtualRemoteKey +import com.flagship.abox.manager.domain.infrared.PanelLayoutStyle +import com.flagship.abox.manager.domain.infrared.RemoteDeviceType +import com.flagship.abox.manager.domain.infrared.SendVirtualRemoteAction +import com.flagship.abox.manager.domain.infrared.TransmissionMode +import com.flagship.abox.manager.domain.infrared.UpdateVirtualRemoteLayout +import com.flagship.abox.manager.domain.infrared.VirtualRemoteId +import com.flagship.abox.manager.testing.fakes.FakeInfraredGateway +import com.flagship.abox.manager.testing.fakes.FakeVirtualRemoteRepository +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.ExperimentalCoroutinesApi +import kotlinx.coroutines.launch +import kotlinx.coroutines.test.StandardTestDispatcher +import kotlinx.coroutines.test.TestScope +import kotlinx.coroutines.test.advanceTimeBy +import kotlinx.coroutines.test.advanceUntilIdle +import kotlinx.coroutines.test.resetMain +import kotlinx.coroutines.test.runCurrent +import kotlinx.coroutines.test.runTest +import kotlinx.coroutines.test.setMain +import org.junit.After +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNotNull +import org.junit.Assert.assertTrue +import org.junit.Before +import org.junit.Test + +@OptIn(ExperimentalCoroutinesApi::class) +class RemotePanelViewModelTest { + + private val testDispatcher = StandardTestDispatcher() + private val testScope = TestScope(testDispatcher) + + private val profileId = ProviderProfileId("profile1") + private val device = DeviceName("ir-1") + private val clock = EpochMillisClock { 10_000L } + + private val remoteRepo = FakeVirtualRemoteRepository() + private val gateway = FakeInfraredGateway() + private val createRemote = CreateVirtualRemote(remoteRepo, gateway, clock) + private val sendAction = SendVirtualRemoteAction(remoteRepo, gateway) + private val learnKey = LearnVirtualRemoteKey(remoteRepo, gateway) + private val addKey = AddVirtualRemoteKey(remoteRepo) + private val deleteKey = DeleteVirtualRemoteKey(remoteRepo) + private val updateLayout = UpdateVirtualRemoteLayout(remoteRepo) + + @Before + fun setup() { + Dispatchers.setMain(testDispatcher) + } + + @After + fun teardown() { + Dispatchers.resetMain() + } + + private fun createViewModel(remoteId: String): RemotePanelViewModel = RemotePanelViewModel( + savedStateHandle = SavedStateHandle(mapOf("profileId" to "profile1", "remoteId" to remoteId)), + virtualRemoteRepository = remoteRepo, + sendVirtualRemoteAction = sendAction, + learnVirtualRemoteKey = learnKey, + addVirtualRemoteKey = addKey, + deleteVirtualRemoteKey = deleteKey, + updateVirtualRemoteLayout = updateLayout, + ) + + @Test + fun tvButtonTriggersInstantTransmissionInNormalMode() = testScope.runTest { + val res = createRemote( + profileId = profileId, + deviceName = device, + displayName = "TV", + type = RemoteDeviceType.TV, + brandModel = "generic_tv", + transmissionMode = TransmissionMode.STATIC_SLOTS, + ) + val remoteId = (res as com.flagship.abox.manager.domain.DomainResult.Success).value + + val vm = createViewModel(remoteId.value) + val job = launch { vm.state.collect {} } + advanceUntilIdle() + + vm.onButtonClick("TV_POWER") + advanceUntilIdle() + + assertEquals(1, gateway.sentKeys.size) + assertEquals("1", gateway.sentKeys.first().key) + + job.cancel() + } + + @Test + fun learnModeToggledTriggersLearningWhenButtonIsClicked() = testScope.runTest { + val res = createRemote( + profileId = profileId, + deviceName = device, + displayName = "TV", + type = RemoteDeviceType.TV, + brandModel = "generic_tv", + transmissionMode = TransmissionMode.STATIC_SLOTS, + ) + val remoteId = (res as com.flagship.abox.manager.domain.DomainResult.Success).value + + val vm = createViewModel(remoteId.value) + val job = launch { vm.state.collect {} } + advanceUntilIdle() + + // 1. Toggle learn mode ON + vm.toggleLearnMode() + runCurrent() + assertTrue(vm.state.value.isLearnMode) + + // 2. Click button -> triggers learn instead of send + vm.onButtonClick("TV_POWER") + advanceUntilIdle() + + assertEquals(1, gateway.learnedKeys.size) + assertEquals("1", gateway.learnedKeys.first().key) + assertEquals(0, gateway.sentKeys.size) + + job.cancel() + } + + @Test + fun addAndRemoveCustomButtonUpdatesBindings() = testScope.runTest { + val res = createRemote( + profileId = profileId, + deviceName = device, + displayName = "Custom", + type = RemoteDeviceType.CUSTOM, + transmissionMode = TransmissionMode.DYNAMIC_SCRATCH, + ) + val remoteId = (res as com.flagship.abox.manager.domain.DomainResult.Success).value + + val vm = createViewModel(remoteId.value) + val job = launch { vm.state.collect {} } + advanceUntilIdle() + + // Add button + vm.addCustomButton("Sound Effect") + advanceUntilIdle() + + val added = vm.state.value.bindings.find { it.displayName == "Sound Effect" } + assertNotNull(added) + + // Delete button + vm.deleteButton(added!!.buttonId) + advanceUntilIdle() + + val afterDelete = vm.state.value.bindings.find { it.displayName == "Sound Effect" } + assertEquals(null, afterDelete) + + job.cancel() + } + + @Test + fun switchLayoutUpdatesRemoteLayoutStyle() = testScope.runTest { + val res = createRemote( + profileId = profileId, + deviceName = device, + displayName = "Custom Box", + type = RemoteDeviceType.CUSTOM, + transmissionMode = TransmissionMode.DYNAMIC_SCRATCH, + ) + val remoteId = (res as com.flagship.abox.manager.domain.DomainResult.Success).value + + val vm = createViewModel(remoteId.value) + val job = launch { vm.state.collect {} } + advanceUntilIdle() + + vm.switchLayout(PanelLayoutStyle.TV_NAV) + advanceUntilIdle() + + assertEquals(PanelLayoutStyle.TV_NAV, vm.state.value.remote?.layoutStyle) + + job.cancel() + } + + @Test + fun acTemperatureAdjustmentTriggersDebouncedTransmissionAndUpdatesState() = testScope.runTest { + val res = createRemote( + profileId = profileId, + deviceName = device, + displayName = "AC", + type = RemoteDeviceType.AIR_CONDITIONER, + brandModel = "gree_ac", + transmissionMode = TransmissionMode.DYNAMIC_SCRATCH, + ) + val remoteId = (res as com.flagship.abox.manager.domain.DomainResult.Success).value + + val vm = createViewModel(remoteId.value) + val job = launch { vm.state.collect {} } + advanceUntilIdle() + + // 1. Click +1 temp (optimistic update to 27) + vm.adjustAcTemperature(1) + runCurrent() + assertEquals(27, vm.state.value.acState.temperature) + + // 2. Click +1 temp again within debounce window (optimistic update to 28) + advanceTimeBy(100L) + vm.adjustAcTemperature(1) + runCurrent() + assertEquals(28, vm.state.value.acState.temperature) + + // Advance debounce window to fire (300ms) + advanceTimeBy(400L) + advanceUntilIdle() + + // Only 1 download and 1 transmission fired for final state 28 + assertEquals(1, gateway.downloadedCodes.size) + assertEquals("100", gateway.downloadedCodes.first().key) + assertEquals(1, gateway.sentKeys.size) + assertEquals("100", gateway.sentKeys.first().key) + + job.cancel() + } +} diff --git a/android/feature/infrared/src/test/kotlin/com/flagship/abox/manager/infrared/remote/InfraredRemoteViewModelTest.kt b/android/feature/infrared/src/test/kotlin/com/flagship/abox/manager/infrared/remote/InfraredRemoteViewModelTest.kt new file mode 100644 index 0000000..2f0fe96 --- /dev/null +++ b/android/feature/infrared/src/test/kotlin/com/flagship/abox/manager/infrared/remote/InfraredRemoteViewModelTest.kt @@ -0,0 +1,350 @@ +package com.flagship.abox.manager.infrared.remote + +import androidx.lifecycle.SavedStateHandle +import com.flagship.abox.manager.domain.DeviceName +import com.flagship.abox.manager.domain.DomainResult +import com.flagship.abox.manager.domain.ProviderProfileId +import com.flagship.abox.manager.domain.infrared.EpochMillisClock +import com.flagship.abox.manager.domain.infrared.InfraredKeyFactory +import com.flagship.abox.manager.domain.infrared.InfraredKeyId +import com.flagship.abox.manager.domain.infrared.InfraredKeyStatus +import com.flagship.abox.manager.domain.infrared.LearnInfraredKey +import com.flagship.abox.manager.domain.infrared.RetryInfraredKeyLearning +import com.flagship.abox.manager.domain.infrared.SavedInfraredKey +import com.flagship.abox.manager.domain.infrared.SendInfraredKey +import com.flagship.abox.manager.infrared.R +import com.flagship.abox.manager.infrared.application.InfraredLearningCoordinator +import com.flagship.abox.manager.testing.fakes.FakeInfraredDeviceConfigurationRepository +import com.flagship.abox.manager.testing.fakes.FakeInfraredGateway +import com.flagship.abox.manager.testing.fakes.FakeInfraredKeyRepository +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.ExperimentalCoroutinesApi +import kotlinx.coroutines.launch +import kotlinx.coroutines.test.StandardTestDispatcher +import kotlinx.coroutines.test.TestScope +import kotlinx.coroutines.test.advanceUntilIdle +import kotlinx.coroutines.test.resetMain +import kotlinx.coroutines.test.runTest +import kotlinx.coroutines.test.setMain +import org.junit.After +import org.junit.Assert.assertEquals +import org.junit.Before +import org.junit.Test + +@OptIn(ExperimentalCoroutinesApi::class) +class InfraredRemoteViewModelTest { + private val testDispatcher = StandardTestDispatcher() + private val testScope = TestScope(testDispatcher) + + private val profile = ProviderProfileId("abox") + private val device = DeviceName("ir-living") + private val clock = EpochMillisClock { 10_000L } + + private val keyRepo = FakeInfraredKeyRepository() + private val deviceRepo = FakeInfraredDeviceConfigurationRepository() + private val profileStore = com.flagship.abox.manager.testing.fakes.FakeProviderProfileStore() + private val gateway = FakeInfraredGateway() + private val factory = InfraredKeyFactory({ InfraredKeyId("01J5MOLERABC123") }, clock) + + private val learn = LearnInfraredKey(keyRepo, gateway, factory, clock) + private val retry = RetryInfraredKeyLearning(keyRepo, gateway, clock) + private val relearn = com.flagship.abox.manager.domain.infrared.RelearnInfraredKey(keyRepo, gateway, clock) + private val send = SendInfraredKey(keyRepo, gateway) + private lateinit var coordinator: InfraredLearningCoordinator + + @Before + fun setup() { + Dispatchers.setMain(testDispatcher) + coordinator = InfraredLearningCoordinator(learn, retry, relearn, keyRepo, testScope) + } + + @After + fun teardown() { + Dispatchers.resetMain() + } + + private fun createViewModel(): InfraredRemoteViewModel { + return InfraredRemoteViewModel( + savedStateHandle = SavedStateHandle(mapOf("profileId" to "abox")), + keyRepository = keyRepo, + deviceConfigurationRepository = deviceRepo, + providerProfileStore = profileStore, + learningCoordinator = coordinator, + sendInfraredKey = send, + ) + } + + @Test + fun controlModeSendsSignalWhenKeyIsReady() = testScope.runTest { + deviceRepo.setDeviceName(profile, device) + val readyKey = SavedInfraredKey( + id = InfraredKeyId("k1"), + profileId = profile, + deviceName = device, + displayName = "空调-电源", + sdkKey = "1", + status = InfraredKeyStatus.READY, + lastErrorCode = null, + lastErrorDetail = null, + createdAtEpochMillis = 100L, + updatedAtEpochMillis = 100L, + ) + keyRepo.insert(readyKey) + + val vm = createViewModel() + val job = launch { vm.state.collect {} } + advanceUntilIdle() + + vm.onButtonClick(RemoteSceneConfig.AirConditioner.POWER) + advanceUntilIdle() + + assertEquals(1, gateway.sentKeys.size) + assertEquals("1", gateway.sentKeys.first().key) + + job.cancel() + } + + @Test + fun learningModeTriggersLearnOnButtonClick() = testScope.runTest { + deviceRepo.setDeviceName(profile, device) + val vm = createViewModel() + val job = launch { vm.state.collect {} } + advanceUntilIdle() + + vm.toggleLearningMode(true) + vm.onButtonClick(RemoteSceneConfig.AirConditioner.POWER) + advanceUntilIdle() + + assertEquals(1, gateway.learnedKeys.size) + assertEquals("1", gateway.learnedKeys.first().key) + assertEquals(null, vm.state.value.activeLearningSlot) + + job.cancel() + } + + @Test + fun disablingLearningModeClearsActiveLearningSlot() = testScope.runTest { + deviceRepo.setDeviceName(profile, device) + val vm = createViewModel() + val job = launch { vm.state.collect {} } + advanceUntilIdle() + + vm.toggleLearningMode(true) + vm.onButtonClick(RemoteSceneConfig.AirConditioner.POWER) + vm.toggleLearningMode(false) + + assertEquals(null, vm.state.value.activeLearningSlot) + + job.cancel() + } + + @Test + fun duplicateSendButtonClickIsIgnoredWhileSending() = testScope.runTest { + deviceRepo.setDeviceName(profile, device) + val readyKey = SavedInfraredKey( + id = InfraredKeyId("k1"), + profileId = profile, + deviceName = device, + displayName = "空调-电源", + sdkKey = "1", + status = InfraredKeyStatus.READY, + lastErrorCode = null, + lastErrorDetail = null, + createdAtEpochMillis = 100L, + updatedAtEpochMillis = 100L, + ) + keyRepo.insert(readyKey) + + val vm = createViewModel() + val job = launch { vm.state.collect {} } + advanceUntilIdle() + + vm.onButtonClick(RemoteSceneConfig.AirConditioner.POWER) + vm.onButtonClick(RemoteSceneConfig.AirConditioner.POWER) + advanceUntilIdle() + + assertEquals(1, gateway.sentKeys.size) + + job.cancel() + } + + @Test + fun learningExistingKeyRetriesExistingKey() = testScope.runTest { + deviceRepo.setDeviceName(profile, device) + val failedKey = SavedInfraredKey( + id = InfraredKeyId("k1"), + profileId = profile, + deviceName = device, + displayName = "空调-电源", + sdkKey = "1", + status = InfraredKeyStatus.FAILED, + lastErrorCode = "20206", + lastErrorDetail = "offline", + createdAtEpochMillis = 100L, + updatedAtEpochMillis = 100L, + ) + keyRepo.insert(failedKey) + + val vm = createViewModel() + val job = launch { vm.state.collect {} } + advanceUntilIdle() + + vm.toggleLearningMode(true) + vm.onButtonClick(RemoteSceneConfig.AirConditioner.POWER) + advanceUntilIdle() + + assertEquals(1, gateway.learnedKeys.size) + assertEquals("1", gateway.learnedKeys.first().key) + val updated = (keyRepo.getKey(com.flagship.abox.manager.domain.infrared.InfraredKeyRef(profile, InfraredKeyId("k1"))) as DomainResult.Success).value!! + assertEquals(InfraredKeyStatus.READY, updated.status) + assertEquals( + RemoteUiMessage.Info(UiText.StringResource(R.string.infrared_msg_learned_success, listOf("空调-电源"))), + vm.state.value.message, + ) + + job.cancel() + } + + @Test + fun learningFailurePropagatesErrorMessage() = testScope.runTest { + deviceRepo.setDeviceName(profile, device) + gateway.learnResult = DomainResult.Failure(com.flagship.abox.manager.domain.DomainError.DeviceOffline(externalCode = "20206")) + + val vm = createViewModel() + val job = launch { vm.state.collect {} } + advanceUntilIdle() + + vm.toggleLearningMode(true) + vm.onButtonClick(RemoteSceneConfig.AirConditioner.POWER) + advanceUntilIdle() + + assertEquals( + RemoteUiMessage.Error(UiText.StringResource(R.string.infrared_msg_device_offline, listOf("20206"))), + vm.state.value.message, + ) + + job.cancel() + } + + @Test + fun learningSessionInvalidPropagatesSessionInvalidMessage() = testScope.runTest { + deviceRepo.setDeviceName(profile, device) + gateway.learnResult = DomainResult.Failure(com.flagship.abox.manager.domain.DomainError.TokenInvalid(detail = "Session expired")) + + val vm = createViewModel() + val job = launch { vm.state.collect {} } + advanceUntilIdle() + + vm.toggleLearningMode(true) + vm.onButtonClick(RemoteSceneConfig.AirConditioner.POWER) + advanceUntilIdle() + + assertEquals(RemoteUiMessage.SessionInvalid, vm.state.value.message) + + job.cancel() + } + + @Test + fun disablingLearningModeCleansUpAndFailsInterruptedLearning() = testScope.runTest { + deviceRepo.setDeviceName(profile, device) + val vm = createViewModel() + val job = launch { vm.state.collect {} } + advanceUntilIdle() + + vm.toggleLearningMode(true) + vm.onButtonClick(RemoteSceneConfig.AirConditioner.POWER) + vm.toggleLearningMode(false) + advanceUntilIdle() + + assertEquals(null, vm.state.value.activeLearningSlot) + + job.cancel() + } + + @Test + fun relearningExistingReadyKeyOverwritesKey() = testScope.runTest { + deviceRepo.setDeviceName(profile, device) + val readyKey = SavedInfraredKey( + id = InfraredKeyId("k1"), + profileId = profile, + deviceName = device, + displayName = "空调-电源", + sdkKey = "1", + status = InfraredKeyStatus.READY, + lastErrorCode = null, + lastErrorDetail = null, + createdAtEpochMillis = 100L, + updatedAtEpochMillis = 100L, + ) + keyRepo.insert(readyKey) + + val vm = createViewModel() + val job = launch { vm.state.collect {} } + advanceUntilIdle() + + vm.toggleLearningMode(true) + vm.onButtonClick(RemoteSceneConfig.AirConditioner.POWER) + advanceUntilIdle() + + assertEquals(1, gateway.learnedKeys.size) + assertEquals("1", gateway.learnedKeys.first().key) + val updated = (keyRepo.getKey(com.flagship.abox.manager.domain.infrared.InfraredKeyRef(profile, InfraredKeyId("k1"))) as DomainResult.Success).value!! + assertEquals(InfraredKeyStatus.READY, updated.status) + assertEquals( + RemoteUiMessage.Info(UiText.StringResource(R.string.infrared_msg_learned_success, listOf("空调-电源"))), + vm.state.value.message, + ) + + job.cancel() + } + + @Test + fun relearningKeyInLearningStatusSucceeds() = testScope.runTest { + deviceRepo.setDeviceName(profile, device) + val learningKey = SavedInfraredKey( + id = InfraredKeyId("k1"), + profileId = profile, + deviceName = device, + displayName = "空调-电源", + sdkKey = "1", + status = InfraredKeyStatus.LEARNING, + lastErrorCode = null, + lastErrorDetail = null, + createdAtEpochMillis = 100L, + updatedAtEpochMillis = 100L, + ) + keyRepo.insert(learningKey) + + val vm = createViewModel() + val job = launch { vm.state.collect {} } + advanceUntilIdle() + + vm.toggleLearningMode(true) + vm.onButtonClick(RemoteSceneConfig.AirConditioner.POWER) + advanceUntilIdle() + + assertEquals(1, gateway.learnedKeys.size) + assertEquals("1", gateway.learnedKeys.first().key) + val updated = (keyRepo.getKey(com.flagship.abox.manager.domain.infrared.InfraredKeyRef(profile, InfraredKeyId("k1"))) as DomainResult.Success).value!! + assertEquals(InfraredKeyStatus.READY, updated.status) + assertEquals( + RemoteUiMessage.Info(UiText.StringResource(R.string.infrared_msg_learned_success, listOf("空调-电源"))), + vm.state.value.message, + ) + + job.cancel() + } + + @Test + fun configSnapshotStorageErrorPropagatesToUiStateMessage() = testScope.runTest { + deviceRepo.observeError = com.flagship.abox.manager.domain.DomainError.Unknown(detail = "Disk failure") + + val vm = createViewModel() + val job = launch { vm.state.collect {} } + advanceUntilIdle() + + assertEquals(RemoteUiMessage.Error(UiText.DynamicString("Disk failure")), vm.state.value.message) + + job.cancel() + } +} diff --git a/android/feature/infrared/src/test/kotlin/com/flagship/abox/manager/infrared/remote/RemoteModelsTest.kt b/android/feature/infrared/src/test/kotlin/com/flagship/abox/manager/infrared/remote/RemoteModelsTest.kt new file mode 100644 index 0000000..b10d25a --- /dev/null +++ b/android/feature/infrared/src/test/kotlin/com/flagship/abox/manager/infrared/remote/RemoteModelsTest.kt @@ -0,0 +1,21 @@ +package com.flagship.abox.manager.infrared.remote + +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Test + +class RemoteModelsTest { + @Test + fun acSpecsHaveUniqueSlotsBetween1And20() { + val slots = RemoteSceneConfig.AirConditioner.buttons.map { it.defaultSlot } + assertEquals(slots.size, slots.distinct().size) + assertTrue(slots.all { it.toInt() in 1..20 }) + } + + @Test + fun tvSpecsHaveUniqueSlotsBetween21And50() { + val slots = RemoteSceneConfig.Television.buttons.map { it.defaultSlot } + assertEquals(slots.size, slots.distinct().size) + assertTrue(slots.all { it.toInt() in 21..50 }) + } +} diff --git a/android/feature/infrared/src/test/kotlin/com/flagship/abox/manager/infrared/ui/InfraredControlViewModelTest.kt b/android/feature/infrared/src/test/kotlin/com/flagship/abox/manager/infrared/ui/InfraredControlViewModelTest.kt new file mode 100644 index 0000000..b9b1485 --- /dev/null +++ b/android/feature/infrared/src/test/kotlin/com/flagship/abox/manager/infrared/ui/InfraredControlViewModelTest.kt @@ -0,0 +1,149 @@ +package com.flagship.abox.manager.infrared.ui + +import androidx.lifecycle.SavedStateHandle +import com.flagship.abox.manager.domain.DeviceName +import com.flagship.abox.manager.domain.ProviderProfile +import com.flagship.abox.manager.domain.ProviderProfileId +import com.flagship.abox.manager.domain.ProviderType +import com.flagship.abox.manager.domain.infrared.CreateVirtualRemote +import com.flagship.abox.manager.domain.infrared.EpochMillisClock +import com.flagship.abox.manager.domain.infrared.RemoteDeviceType +import com.flagship.abox.manager.domain.infrared.TransmissionMode +import com.flagship.abox.manager.infrared.R +import com.flagship.abox.manager.infrared.remote.UiText +import com.flagship.abox.manager.testing.fakes.FakeInfraredDeviceConfigurationRepository +import com.flagship.abox.manager.testing.fakes.FakeInfraredGateway +import com.flagship.abox.manager.testing.fakes.FakeProviderProfileStore +import com.flagship.abox.manager.testing.fakes.FakeVirtualRemoteRepository +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.ExperimentalCoroutinesApi +import kotlinx.coroutines.launch +import kotlinx.coroutines.test.StandardTestDispatcher +import kotlinx.coroutines.test.TestScope +import kotlinx.coroutines.test.advanceUntilIdle +import kotlinx.coroutines.test.resetMain +import kotlinx.coroutines.test.runTest +import kotlinx.coroutines.test.setMain +import org.junit.After +import org.junit.Assert.assertEquals +import org.junit.Before +import org.junit.Test + +@OptIn(ExperimentalCoroutinesApi::class) +class InfraredControlViewModelTest { + private val testDispatcher = StandardTestDispatcher() + private val testScope = TestScope(testDispatcher) + + private val profileId = ProviderProfileId("profile1") + private val providerProfile = ProviderProfile( + id = profileId, + type = ProviderType.LOCAL_EXPERIENCE, + displayName = "Local Simulation", + ) + private val device = DeviceName("ir-living") + private val clock = EpochMillisClock { 10_000L } + + private val deviceRepo = FakeInfraredDeviceConfigurationRepository() + private val remoteRepo = FakeVirtualRemoteRepository() + private val profileStore = FakeProviderProfileStore() + private val gateway = FakeInfraredGateway() + private val createRemote = CreateVirtualRemote(remoteRepo, gateway, clock) + + @Before + fun setup() { + Dispatchers.setMain(testDispatcher) + } + + @After + fun teardown() { + Dispatchers.resetMain() + } + + private fun createViewModel(): InfraredControlViewModel { + return InfraredControlViewModel( + savedStateHandle = SavedStateHandle(mapOf("profileId" to "profile1")), + deviceConfigurationRepository = deviceRepo, + virtualRemoteRepository = remoteRepo, + providerProfileStore = profileStore, + ) + } + + @Test + fun initialStateLoadsEnvironmentAndDeviceNameForProfile() = testScope.runTest { + profileStore.saveProfile(providerProfile) + deviceRepo.setDeviceName(profileId, device) + + val vm = createViewModel() + val job = launch { vm.state.collect {} } + advanceUntilIdle() + + assertEquals(ProviderType.LOCAL_EXPERIENCE, vm.state.value.providerType) + assertEquals(device, vm.state.value.savedDeviceName) + assertEquals("ir-living", vm.state.value.deviceNameInput) + assertEquals(0, vm.state.value.totalRemotesCount) + + job.cancel() + } + + @Test + fun saveDeviceNameUpdatesDeviceConfiguration() = testScope.runTest { + profileStore.saveProfile(providerProfile) + val vm = createViewModel() + val job = launch { vm.state.collect {} } + advanceUntilIdle() + + vm.onDeviceNameChanged("ir-bedroom") + vm.saveDeviceName() + advanceUntilIdle() + + assertEquals(DeviceName("ir-bedroom"), vm.state.value.savedDeviceName) + assertEquals( + InfraredUiMessage.Info(UiText.StringResource(R.string.infrared_msg_device_name_saved)), + vm.state.value.message, + ) + + job.cancel() + } + + @Test + fun blankDeviceNameEmitsErrorMessage() = testScope.runTest { + profileStore.saveProfile(providerProfile) + val vm = createViewModel() + val job = launch { vm.state.collect {} } + advanceUntilIdle() + + vm.onDeviceNameChanged(" ") + vm.saveDeviceName() + advanceUntilIdle() + + assertEquals( + InfraredUiMessage.Error(UiText.StringResource(R.string.infrared_msg_device_name_blank)), + vm.state.value.message, + ) + + job.cancel() + } + + @Test + fun stateReflectsConfiguredRemotesAndQuota() = testScope.runTest { + profileStore.saveProfile(providerProfile) + deviceRepo.setDeviceName(profileId, device) + createRemote( + profileId = profileId, + deviceName = device, + displayName = "Living TV", + type = RemoteDeviceType.TV, + transmissionMode = TransmissionMode.STATIC_SLOTS, + ) + + val vm = createViewModel() + val job = launch { vm.state.collect {} } + advanceUntilIdle() + + assertEquals(1, vm.state.value.totalRemotesCount) + assertEquals(15, vm.state.value.slotQuota.assignedStaticSlots.size) + assertEquals(16, vm.state.value.slotQuota.usedCount) + + job.cancel() + } +} diff --git a/build.gradle.kts b/build.gradle.kts index 9b1f2d2..46c8d89 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -6,3 +6,4 @@ plugins { alias(libs.plugins.kotlin.kapt) apply false alias(libs.plugins.hilt.android) apply false } + diff --git a/docs/superpowers/plans/2026-08-24-infrared-control.md b/docs/superpowers/plans/2026-08-24-infrared-control.md new file mode 100644 index 0000000..b088ee8 --- /dev/null +++ b/docs/superpowers/plans/2026-08-24-infrared-control.md @@ -0,0 +1,1300 @@ +# Infrared Learning and Sending Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Build a testable end-to-end infrared feature that stores named key bindings, invokes ABSDK learning and sending through the existing gateway, exposes a simple Compose screen, and supports explicit Fake/Real debug routing. + +**Architecture:** Keep `InfraredGateway` as the hardware-only boundary. Add infrared key models, repositories, and application use cases to the pure Kotlin `:domain` module; add Room, runtime state, ViewModel, and Compose UI to a focused `:android:feature:infrared` module; wire the feature into `:android:app` with build-variant-specific gateway bindings. Learning writes `LEARNING` before calling hardware and records `READY` or `FAILED` afterward, while sending resolves a stable local key reference to the stored `DeviceName + sdkKey` binding. + +**Tech Stack:** Kotlin 1.9.24, JVM 17, Android Gradle Plugin 8.7.3, Android API 26–34, coroutines 1.8.1, Room 2.6.1 with KAPT, DataStore Preferences 1.1.1, Hilt 2.51.1, Navigation Compose 2.7.7, Compose BOM 2024.06.00, JUnit 4, AndroidX instrumentation tests. + +**Spec:** `docs/superpowers/specs/2026-08-24-infrared-control-design.md` + +## Global Constraints + +- Do not modify the signatures of `InfraredGateway.learnKey()`, `sendKey()`, or `downloadCodes()`. +- Do not claim that ABSDK returns a learned raw infrared code; `learnKey()` remains `DomainResult`. +- Do not implement or label any action as “stop hardware learning”; ABSDK 0630 exposes no stop-learning API. +- Store `displayName` separately from immutable `sdkKey`; renaming must never change the ABSDK key. +- Store no password, token, raw SDK map, raw infrared payload, or replayable secret in Room, logs, analytics, errors, or Compose semantics. +- A key is sendable only when its local status is `READY`; a send failure does not demote it. +- Learning persists `LEARNING` before hardware invocation; success becomes `READY`, failure becomes `FAILED`. +- Retry learning reuses the same `InfraredKeyId` and `sdkKey`. +- Interrupted `LEARNING` records recover conservatively to `FAILED`; never infer hardware success. +- Fake and Real data are isolated by effective `ProviderProfileId`. +- Debug UI always displays the selected runtime mode; mode cannot change while learning is active. +- Real ABSDK is debug-only and requires explicit `CleartextAbsdkTransport` opt-in plus debug-only cleartext network configuration. +- Release must compile without enabling real ABSDK or requesting cleartext transport. +- All real hardware interfaces must share the single process-level `AbsdkBridge.create()` instance. +- The current `main` branch has no implemented login screen despite the product wording “post-login page.” Use the existing `FoundationScreen` as the temporary navigation host. Real hardware calls will return `TokenInvalid` until a login implementation authenticates the same `AbsdkBridge` instance; do not add credential collection to the infrared feature. +- Work only on a dedicated branch based on updated `main`; submit through a PR targeting `main`. +- Follow TDD for every behavior: failing test, minimal implementation, passing test, focused commit. + +--- + +## File Structure + +### Pure Kotlin domain and application layer + +- `domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/InfraredKeyModels.kt` — stable IDs, status, saved key model, command inputs. +- `domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/InfraredKeyRepository.kt` — key persistence and device-name configuration ports. +- `domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/InfraredKeyFactory.kt` — ID, clock, and deterministic SDK-key construction boundaries. +- `domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/LearnInfraredKey.kt` — create and retry learning orchestration. +- `domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/ManageInfraredKey.kt` — send, rename, delete, and interrupted-learning recovery use cases. +- Matching files under `domain/src/test/.../infrared/` — pure unit tests. + +### Test doubles + +- `testing/fakes/src/main/kotlin/com/flagship/abox/manager/testing/fakes/FakeDeviceGateways.kt` — scriptable per-call infrared outcomes. +- `testing/fakes/src/main/kotlin/com/flagship/abox/manager/testing/fakes/FakeInfraredKeyRepository.kt` — in-memory repository/configuration port implementation. +- Matching files under `testing/fakes/src/test/...` — fake contract tests. + +### Android infrared feature + +- `android/feature/infrared/build.gradle.kts` and `src/main/AndroidManifest.xml` — focused Android library. +- `data/local/InfraredEntities.kt`, `InfraredDao.kt`, `InfraredDatabase.kt`, `InfraredMappers.kt`, `RoomInfraredKeyRepository.kt` — Room persistence. +- `runtime/InfraredRuntimeMode.kt`, `DataStoreInfraredRuntimeModeStore.kt`, `InfraredRuntimeProfileResolver.kt` — explicit Fake/Real mode and data isolation. +- `application/InfraredLearningCoordinator.kt` — application-scope learning jobs that outlive a ViewModel. +- `ui/InfraredControlUiState.kt`, `InfraredControlViewModel.kt`, `InfraredControlScreen.kt` — state holder and simple functional Compose UI. +- `di/InfraredFeatureModule.kt` — Room, repository, mode store, scope, clock, and ID generator bindings. +- Unit and instrumentation tests under the same module. + +### App integration + +- `android/app/src/debug/.../di/FoundationModule.kt` — debug router, Fake gateway, and shared real `AbsdkBridge` binding. +- `android/app/src/debug/.../di/DebugRoutingInfraredGateway.kt` — runtime delegation. +- `android/app/src/release/.../di/InfraredReleaseModule.kt` — disabled release gateway binding. +- `android/app/src/debug/AndroidManifest.xml` — debug-only Internet permission and cleartext opt-in. +- `android/app/src/main/.../ui/ABoxManagerApp.kt` — temporary entry and route. +- English and Chinese string resource files — functional copy only. + +--- + +### Task 1: Define Stable Infrared Key Contracts + +**Files:** +- Create: `domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/InfraredKeyModels.kt` +- Create: `domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/InfraredKeyRepository.kt` +- Create: `domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/InfraredKeyFactory.kt` +- Test: `domain/src/test/kotlin/com/flagship/abox/manager/domain/infrared/InfraredKeyFactoryTest.kt` + +**Interfaces:** +- Consumes: existing `ProviderProfileId`, `DeviceName`, `DomainResult`, and `DomainError`. +- Produces: + +```kotlin +@JvmInline value class InfraredKeyId(val value: String) + +data class InfraredKeyRef( + val profileId: ProviderProfileId, + val keyId: InfraredKeyId, +) + +enum class InfraredKeyStatus { LEARNING, READY, FAILED } + +data class SavedInfraredKey( + val id: InfraredKeyId, + val profileId: ProviderProfileId, + val deviceName: DeviceName, + val displayName: String, + val sdkKey: String, + val status: InfraredKeyStatus, + val lastErrorCode: String?, + val createdAtEpochMillis: Long, + val updatedAtEpochMillis: Long, +) + +interface InfraredKeyRepository { + fun observeKeys(profileId: ProviderProfileId, deviceName: DeviceName): Flow>> + suspend fun getKey(ref: InfraredKeyRef): DomainResult + suspend fun insert(key: SavedInfraredKey): DomainResult + suspend fun update(key: SavedInfraredKey): DomainResult + suspend fun delete(ref: InfraredKeyRef): DomainResult + suspend fun findByStatus(profileId: ProviderProfileId, status: InfraredKeyStatus): DomainResult> +} + +interface InfraredDeviceConfigurationRepository { + fun observeDeviceName(profileId: ProviderProfileId): Flow> + suspend fun setDeviceName(profileId: ProviderProfileId, deviceName: DeviceName): DomainResult +} + +fun interface InfraredKeyIdGenerator { fun nextId(): InfraredKeyId } +fun interface EpochMillisClock { fun now(): Long } + +class InfraredKeyFactory( + private val idGenerator: InfraredKeyIdGenerator, + private val clock: EpochMillisClock, +) { + fun create(profileId: ProviderProfileId, deviceName: DeviceName, displayName: String): DomainResult +} +``` + +- [ ] **Step 1: Write failing SDK-key factory tests** + +```kotlin +class InfraredKeyFactoryTest { + private val id = InfraredKeyId("01J5MOLERABC123") + private val factory = InfraredKeyFactory( + idGenerator = InfraredKeyIdGenerator { id }, + clock = EpochMillisClock { 1_724_435_200_000L }, + ) + + @Test + fun createsLearningKeyWithStableAsciiSdkKey() { + val result = factory.create( + ProviderProfileId("abox"), + DeviceName("ir-1"), + "空调开关", + ) as DomainResult.Success + + assertEquals(id, result.value.id) + assertEquals("app_ir_01j5molerabc123", result.value.sdkKey) + assertEquals(InfraredKeyStatus.LEARNING, result.value.status) + assertEquals("空调开关", result.value.displayName) + assertEquals(1_724_435_200_000L, result.value.createdAtEpochMillis) + assertEquals(result.value.createdAtEpochMillis, result.value.updatedAtEpochMillis) + } + + @Test + fun rejectsBlankDeviceOrDisplayName() { + assertTrue(factory.create(ProviderProfileId("abox"), DeviceName(""), "Power") is DomainResult.Failure) + assertTrue(factory.create(ProviderProfileId("abox"), DeviceName("ir-1"), " ") is DomainResult.Failure) + } +} +``` + +- [ ] **Step 2: Run the focused domain test and verify failure** + +Run: + +```bash +./gradlew :domain:test --tests "*.InfraredKeyFactoryTest" +``` + +Expected: compilation failure because the infrared key types and factory do not exist. + +- [ ] **Step 3: Add the models and repository interfaces exactly as listed above** + +Keep them in package `com.flagship.abox.manager.domain.infrared`. Import shared domain types rather than duplicating them. + +- [ ] **Step 4: Implement conservative factory validation** + +```kotlin +class InfraredKeyFactory( + private val idGenerator: InfraredKeyIdGenerator, + private val clock: EpochMillisClock, +) { + fun create( + profileId: ProviderProfileId, + deviceName: DeviceName, + displayName: String, + ): DomainResult { + val normalizedName = displayName.trim() + if (profileId.value.isBlank() || deviceName.value.isBlank() || normalizedName.isBlank()) { + return DomainResult.Failure( + DomainError.InvalidRequest(detail = "Profile, device name, and display name are required"), + ) + } + val id = idGenerator.nextId() + val normalizedId = id.value.lowercase().filter { it in 'a'..'z' || it in '0'..'9' } + if (normalizedId.isBlank()) { + return DomainResult.Failure(DomainError.InvalidRequest(detail = "Infrared key id is invalid")) + } + val now = clock.now() + return DomainResult.Success( + SavedInfraredKey( + id = id, + profileId = profileId, + deviceName = deviceName, + displayName = normalizedName, + sdkKey = "app_ir_${normalizedId.take(40)}", + status = InfraredKeyStatus.LEARNING, + lastErrorCode = null, + createdAtEpochMillis = now, + updatedAtEpochMillis = now, + ), + ) + } +} +``` + +The conservative `take(40)` keeps the generated key bounded pending real-hardware length verification. + +- [ ] **Step 5: Run all domain tests** + +```bash +./gradlew :domain:test +``` + +Expected: all tests pass. + +- [ ] **Step 6: Commit the contracts** + +```bash +git add domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared domain/src/test/kotlin/com/flagship/abox/manager/domain/infrared +git commit -m "feat: define infrared key contracts" +``` + +--- + +### Task 2: Implement Learning and Retry Orchestration + +**Files:** +- Create: `domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/LearnInfraredKey.kt` +- Test: `domain/src/test/kotlin/com/flagship/abox/manager/domain/infrared/LearnInfraredKeyTest.kt` +- Test helper: `domain/src/test/kotlin/com/flagship/abox/manager/domain/infrared/InMemoryInfraredTestDoubles.kt` + +**Interfaces:** +- Consumes: `InfraredGateway`, `InfraredKeyRepository`, `InfraredKeyFactory`, `EpochMillisClock`. +- Produces: + +```kotlin +class LearnInfraredKey( + private val repository: InfraredKeyRepository, + private val gateway: InfraredGateway, + private val factory: InfraredKeyFactory, + private val clock: EpochMillisClock, +) { + suspend operator fun invoke( + profileId: ProviderProfileId, + deviceName: DeviceName, + displayName: String, + ): DomainResult +} + +class RetryInfraredKeyLearning( + private val repository: InfraredKeyRepository, + private val gateway: InfraredGateway, + private val clock: EpochMillisClock, +) { + suspend operator fun invoke(ref: InfraredKeyRef): DomainResult +} +``` + +- [ ] **Step 1: Add an in-memory repository and recording gateway for domain tests** + +Implement only the interface behavior needed by these tests: a map keyed by `InfraredKeyRef`, a `MutableStateFlow`, configurable insert/update failures, and recorded gateway calls. + +- [ ] **Step 2: Write failing tests for persistence ordering and status updates** + +```kotlin +@Test +fun persistsLearningBeforeCallingHardwareThenMarksReady() = runTest { + val events = mutableListOf() + repository.onInsert = { events += "insert:${it.status}" } + gateway.onLearn = { _, _, _ -> + events += "hardware" + DomainResult.Success(Unit) + } + repository.onUpdate = { events += "update:${it.status}" } + + val result = learn(profile, device, "Power") + + assertTrue(result is DomainResult.Success) + assertEquals(listOf("insert:LEARNING", "hardware", "update:READY"), events) + assertEquals(InfraredKeyStatus.READY, repository.onlyKey().status) +} + +@Test +fun hardwareFailureMarksFailedAndReturnsOriginalError() = runTest { + gateway.learnResult = DomainResult.Failure(DomainError.DeviceOffline("20206")) + + val result = learn(profile, device, "Power") + + assertEquals(DomainError.DeviceOffline("20206"), (result as DomainResult.Failure).error) + assertEquals(InfraredKeyStatus.FAILED, repository.onlyKey().status) + assertEquals("20206", repository.onlyKey().lastErrorCode) +} + +@Test +fun insertFailureNeverCallsHardware() = runTest { + repository.insertError = DomainError.Unknown(detail = "database unavailable") + + assertTrue(learn(profile, device, "Power") is DomainResult.Failure) + assertTrue(gateway.learnedKeys.isEmpty()) +} +``` + +- [ ] **Step 3: Run tests and verify they fail** + +```bash +./gradlew :domain:test --tests "*.LearnInfraredKeyTest" +``` + +Expected: compilation failure because the learning use cases do not exist. + +- [ ] **Step 4: Implement `LearnInfraredKey` with explicit ordering** + +Use this exact decision table: + +```text +factory failure → return failure, no repository or gateway call +insert failure → return failure, no gateway call +gateway success → update READY; return key ID only if update succeeds +gateway failure → attempt update FAILED with externalCode; return original gateway failure +``` + +When creating READY/FAILED copies, preserve `id`, `profileId`, `deviceName`, `displayName`, `sdkKey`, and `createdAtEpochMillis`; only status, error, and updated time change. + +- [ ] **Step 5: Write failing retry tests** + +```kotlin +@Test +fun retryReusesStableIdAndSdkKey() = runTest { + val original = failedKey(id = InfraredKeyId("key-1"), sdkKey = "app_ir_key1") + repository.seed(original) + + val result = retry(original.ref()) + + assertEquals(DomainResult.Success(Unit), result) + assertEquals("app_ir_key1", gateway.learnedKeys.single().key) + assertEquals(InfraredKeyId("key-1"), repository.onlyKey().id) + assertEquals(InfraredKeyStatus.READY, repository.onlyKey().status) +} + +@Test +fun retryRejectsAlreadyLearningKey() = runTest { + repository.seed(learningKey()) + val result = retry(repository.onlyKey().ref()) + assertTrue((result as DomainResult.Failure).error is DomainError.InvalidRequest) + assertTrue(gateway.learnedKeys.isEmpty()) +} +``` + +- [ ] **Step 6: Implement retry without creating a new record** + +Required sequence: + +```text +get existing → reject null/LEARNING → update same record to LEARNING +→ call gateway with stored profile/device/sdkKey +→ update same record to READY or FAILED +``` + +- [ ] **Step 7: Run domain tests** + +```bash +./gradlew :domain:test +``` + +Expected: all domain tests pass. + +- [ ] **Step 8: Commit learning orchestration** + +```bash +git add domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/LearnInfraredKey.kt domain/src/test/kotlin/com/flagship/abox/manager/domain/infrared +git commit -m "feat: orchestrate infrared key learning" +``` + +--- + +### Task 3: Implement Send, Rename, Delete, and Recovery Use Cases + +**Files:** +- Create: `domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/ManageInfraredKey.kt` +- Test: `domain/src/test/kotlin/com/flagship/abox/manager/domain/infrared/ManageInfraredKeyTest.kt` + +**Interfaces:** +- Consumes: contracts from Tasks 1–2. +- Produces: + +```kotlin +class SendInfraredKey(repository: InfraredKeyRepository, gateway: InfraredGateway) +class RenameInfraredKey(repository: InfraredKeyRepository, clock: EpochMillisClock) +class DeleteInfraredKey(repository: InfraredKeyRepository) +class RecoverInterruptedInfraredLearning(repository: InfraredKeyRepository, clock: EpochMillisClock) +``` + +Each exposes a suspending `operator fun invoke(...)` returning `DomainResult`. + +- [ ] **Step 1: Write failing send tests** + +```kotlin +@Test +fun sendsReadyKeyUsingStoredDeviceAndSdkKey() = runTest { + repository.seed(readyKey(deviceName = DeviceName("ir-living"), sdkKey = "app_ir_power")) + + assertEquals(DomainResult.Success(Unit), send(repository.onlyKey().ref())) + assertEquals( + InfraredCall(profile, DeviceName("ir-living"), "app_ir_power"), + gateway.sentKeys.single(), + ) +} + +@Test +fun sendFailureDoesNotDemoteReadyKey() = runTest { + repository.seed(readyKey()) + gateway.sendResult = DomainResult.Failure(DomainError.OperationFailed("20205")) + + assertTrue(send(repository.onlyKey().ref()) is DomainResult.Failure) + assertEquals(InfraredKeyStatus.READY, repository.onlyKey().status) +} + +@Test +fun rejectsSendingFailedOrMissingKey() = runTest { + repository.seed(failedKey()) + assertTrue(send(repository.onlyKey().ref()) is DomainResult.Failure) + assertTrue(send(InfraredKeyRef(profile, InfraredKeyId("missing"))) is DomainResult.Failure) + assertTrue(gateway.sentKeys.isEmpty()) +} +``` + +- [ ] **Step 2: Run the focused tests and verify failure** + +```bash +./gradlew :domain:test --tests "*.ManageInfraredKeyTest" +``` + +- [ ] **Step 3: Implement `SendInfraredKey` minimally** + +Missing keys return `DomainError.NoData`; non-READY keys return `DomainError.InvalidRequest`; READY keys delegate exactly once and do not write the repository. + +- [ ] **Step 4: Add failing rename, delete, and recovery tests** + +```kotlin +@Test +fun renameChangesOnlyDisplayNameAndTimestamp() = runTest { + val before = readyKey(displayName = "Power", sdkKey = "app_ir_power") + repository.seed(before) + + assertEquals(DomainResult.Success(Unit), rename(before.ref(), "空调开关")) + val after = repository.onlyKey() + assertEquals("空调开关", after.displayName) + assertEquals(before.sdkKey, after.sdkKey) + assertEquals(before.id, after.id) +} + +@Test +fun deleteRejectsLearningButDeletesReady() = runTest { + repository.seed(learningKey()) + assertTrue(delete(repository.onlyKey().ref()) is DomainResult.Failure) + repository.seed(readyKey()) + assertEquals(DomainResult.Success(Unit), delete(repository.onlyKey().ref())) +} + +@Test +fun recoveryMarksAllInterruptedKeysFailedWithoutHardwareCalls() = runTest { + repository.seed(learningKey(id = InfraredKeyId("one"))) + repository.seed(learningKey(id = InfraredKeyId("two"))) + + assertEquals(DomainResult.Success(2), recover(profile)) + assertTrue(repository.allKeys().all { it.status == InfraredKeyStatus.FAILED }) + assertTrue(gateway.learnedKeys.isEmpty()) +} +``` + +- [ ] **Step 5: Implement management and recovery rules** + +Use error detail `"Interrupted learning result is unknown; retry required"` for recovered rows and set `lastErrorCode = null` because no vendor response exists. + +- [ ] **Step 6: Run all domain tests** + +```bash +./gradlew :domain:test +``` + +- [ ] **Step 7: Commit key management** + +```bash +git add domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/ManageInfraredKey.kt domain/src/test/kotlin/com/flagship/abox/manager/domain/infrared/ManageInfraredKeyTest.kt +git commit -m "feat: manage saved infrared keys" +``` + +--- + +### Task 4: Strengthen Infrared Test Fakes + +**Files:** +- Modify: `testing/fakes/src/main/kotlin/com/flagship/abox/manager/testing/fakes/FakeDeviceGateways.kt:80-137` +- Create: `testing/fakes/src/main/kotlin/com/flagship/abox/manager/testing/fakes/FakeInfraredKeyRepository.kt` +- Modify: `testing/fakes/src/test/kotlin/com/flagship/abox/manager/testing/fakes/FakeDeviceGatewaysTest.kt` +- Create: `testing/fakes/src/test/kotlin/com/flagship/abox/manager/testing/fakes/FakeInfraredKeyRepositoryTest.kt` + +**Interfaces:** +- Consumes: `InfraredKeyRepository` and `InfraredDeviceConfigurationRepository`. +- Produces: per-call scripted `FakeInfraredGateway` plus in-memory repositories for ViewModel and use-case tests. + +- [ ] **Step 1: Write failing per-key scripting tests** + +```kotlin +@Test +fun infraredResultsCanDifferByProfileDeviceAndKey() = runTest { + val gateway = FakeInfraredGateway() + gateway.setLearnResult( + profileOne, + DeviceName("ir-1"), + "power", + DomainResult.Failure(DomainError.DeviceOffline("20206")), + ) + + assertTrue(gateway.learnKey(profileOne, DeviceName("ir-1"), "power") is DomainResult.Failure) + assertEquals( + DomainResult.Success(Unit), + gateway.learnKey(profileTwo, DeviceName("ir-1"), "power"), + ) +} +``` + +- [ ] **Step 2: Run the focused fake test and verify failure** + +```bash +./gradlew :testing:fakes:test --tests "*.FakeDeviceGatewaysTest" +``` + +- [ ] **Step 3: Add keyed result maps while retaining existing defaults** + +Use a private key: + +```kotlin +private data class InfraredOperationKey( + val profileId: ProviderProfileId, + val deviceName: DeviceName, + val key: String, +) +``` + +Add `setSendResult(...)`, `setLearnResult(...)`, and optional queued result helpers. Existing `sendResult` and `learnResult` remain defaults so current consumers do not break. + +- [ ] **Step 4: Write failing repository fake tests** + +Test Flow emission, profile/device filtering, status filtering, update/delete, duplicate insert failure, and device-name configuration isolation. + +- [ ] **Step 5: Implement `FakeInfraredKeyRepository` and `FakeInfraredDeviceConfigurationRepository`** + +Use `MutableStateFlow>`, synchronize mutations, and return `DomainError.InvalidRequest` for duplicate IDs or duplicate `(profileId, deviceName, sdkKey)` bindings. + +- [ ] **Step 6: Run all fake tests** + +```bash +./gradlew :testing:fakes:test +``` + +- [ ] **Step 7: Commit fake improvements** + +```bash +git add testing/fakes/src/main testing/fakes/src/test +git commit -m "test: add scriptable infrared fakes" +``` + +--- + +### Task 5: Add the Android Infrared Feature Module and Room Persistence + +**Files:** +- Modify: `settings.gradle.kts:25-29` +- Modify: `gradle/libs.versions.toml:17-46` +- Modify: `build.gradle.kts:1-8` +- Create: `android/feature/infrared/build.gradle.kts` +- Create: `android/feature/infrared/src/main/AndroidManifest.xml` +- Create: `android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/data/local/InfraredEntities.kt` +- Create: `android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/data/local/InfraredDao.kt` +- Create: `android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/data/local/InfraredDatabase.kt` +- Create: `android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/data/local/InfraredMappers.kt` +- Create: `android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/data/local/RoomInfraredKeyRepository.kt` +- Test: `android/feature/infrared/src/androidTest/kotlin/com/flagship/abox/manager/infrared/data/local/RoomInfraredKeyRepositoryTest.kt` + +**Interfaces:** +- Consumes: Task 1 repository ports. +- Produces: Room implementation for keys and device-name configuration. + +- [ ] **Step 1: Add missing dependency aliases and module registration** + +Add these aliases: + +```toml +androidx-lifecycle-viewmodel-ktx = { module = "androidx.lifecycle:lifecycle-viewmodel-ktx", version.ref = "lifecycle" } +room-compiler = { module = "androidx.room:room-compiler", version.ref = "room" } +room-testing = { module = "androidx.room:room-testing", version.ref = "room" } +``` + +Add `include(":android:feature:infrared")` and apply the existing Android library, Kotlin Android, KAPT, and Hilt plugins in the feature module. + +- [ ] **Step 2: Create the module build file** + +Use namespace `com.flagship.abox.manager.infrared`, API levels 26/34, JVM 17, Compose enabled, and dependencies on `:domain`, `:android:core:designsystem`, Room runtime/ktx, DataStore, lifecycle, navigation, Hilt, Compose, JUnit, coroutines-test, AndroidX JUnit, Room testing, and Compose UI test. + +- [ ] **Step 3: Write failing Room instrumentation tests** + +```kotlin +@RunWith(AndroidJUnit4::class) +class RoomInfraredKeyRepositoryTest { + @Test + fun observesOnlyRequestedProfileAndDevice() = runTest { + repository.insert(key(profile = "one", device = "ir-1", id = "a")) + repository.insert(key(profile = "one", device = "ir-2", id = "b")) + repository.insert(key(profile = "two", device = "ir-1", id = "c")) + + val result = repository.observeKeys( + ProviderProfileId("one"), + DeviceName("ir-1"), + ).first() as DomainResult.Success + + assertEquals(listOf(InfraredKeyId("a")), result.value.map { it.id }) + } + + @Test + fun rejectsDuplicateSdkBinding() = runTest { + repository.insert(key(id = "a", sdkKey = "app_ir_power")) + val duplicate = repository.insert(key(id = "b", sdkKey = "app_ir_power")) + assertTrue(duplicate is DomainResult.Failure) + } +} +``` + +Also test update, delete, status query, configuration persistence, and stable ID after rename. + +- [ ] **Step 4: Run instrumentation compilation and verify failure** + +```bash +./gradlew :android:feature:infrared:compileDebugAndroidTestKotlin +``` + +Expected: failure because Room types and repository do not exist. + +- [ ] **Step 5: Implement Room entities and constraints** + +```kotlin +@Entity( + tableName = "infrared_keys", + indices = [ + Index(value = ["profileId", "deviceName"]), + Index(value = ["profileId", "deviceName", "sdkKey"], unique = true), + ], +) +data class InfraredKeyEntity(...) + +@Entity(tableName = "infrared_device_configuration") +data class InfraredDeviceConfigurationEntity( + @PrimaryKey val profileId: String, + val deviceName: String, +) +``` + +Use `@Database(..., version = 1, exportSchema = true)` and set Room schema output through KAPT arguments in the module build file. + +- [ ] **Step 6: Implement DAO, mappers, and repository error containment** + +Catch `SQLiteConstraintException` as `DomainError.InvalidRequest`, other database exceptions as `DomainError.Unknown`, and never include full entity dumps in error details. + +- [ ] **Step 7: Run Room tests on an available emulator/device** + +```bash +./gradlew :android:feature:infrared:connectedDebugAndroidTest +``` + +Expected: Room repository tests pass. If no emulator is available, record that instrumentation execution is pending but still require `compileDebugAndroidTestKotlin` to pass; do not report the tests as executed. + +- [ ] **Step 8: Commit persistence** + +```bash +git add settings.gradle.kts gradle/libs.versions.toml build.gradle.kts android/feature/infrared +git commit -m "feat: persist infrared key bindings" +``` + +--- + +### Task 6: Add Runtime Mode, Profile Isolation, and Application-Scope Learning + +**Files:** +- Create: `android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/runtime/InfraredRuntimeMode.kt` +- Create: `android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/runtime/DataStoreInfraredRuntimeModeStore.kt` +- Create: `android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/runtime/InfraredRuntimeProfileResolver.kt` +- Create: `android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/application/InfraredLearningCoordinator.kt` +- Create: `android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/di/InfraredFeatureModule.kt` +- Test: `android/feature/infrared/src/test/kotlin/com/flagship/abox/manager/infrared/runtime/InfraredRuntimeProfileResolverTest.kt` +- Test: `android/feature/infrared/src/test/kotlin/com/flagship/abox/manager/infrared/application/InfraredLearningCoordinatorTest.kt` + +**Interfaces:** +- Produces: + +```kotlin +enum class InfraredRuntimeMode { FAKE, REAL_ABSDK } + +interface InfraredRuntimeModeStore { + val mode: Flow + suspend fun currentMode(): InfraredRuntimeMode + suspend fun setMode(mode: InfraredRuntimeMode): DomainResult +} + +class InfraredRuntimeProfileResolver { + fun resolve(realProfileId: ProviderProfileId, mode: InfraredRuntimeMode): ProviderProfileId +} + +class InfraredLearningCoordinator { + fun learn(profileId: ProviderProfileId, deviceName: DeviceName, displayName: String) + fun retry(ref: InfraredKeyRef) +} +``` + +- [ ] **Step 1: Write profile-isolation tests** + +```kotlin +@Test +fun realModeUsesAuthenticatedProfileAndFakeModeUsesIsolatedProfile() { + val resolver = InfraredRuntimeProfileResolver() + assertEquals(ProviderProfileId("abox"), resolver.resolve(ProviderProfileId("abox"), REAL_ABSDK)) + assertEquals(ProviderProfileId("abox:infrared-fake"), resolver.resolve(ProviderProfileId("abox"), FAKE)) +} +``` + +- [ ] **Step 2: Implement mode storage and profile resolver** + +DataStore defaults to `FAKE`. Store only the enum name under `infrared_runtime_mode`; an unknown stored value falls back to `FAKE`. + +- [ ] **Step 3: Write failing coordinator lifetime tests** + +Use a `TestScope` injected through a qualifier and verify that calling `coordinator.learn(...)` returns immediately, then `advanceUntilIdle()` runs the use case and updates the repository even after the test drops its ViewModel reference. + +- [ ] **Step 4: Implement an application coroutine scope and coordinator** + +```kotlin +@Qualifier +@Retention(AnnotationRetention.BINARY) +annotation class InfraredApplicationScope + +@Provides +@Singleton +@InfraredApplicationScope +fun provideInfraredApplicationScope(): CoroutineScope = + CoroutineScope(SupervisorJob() + Dispatchers.IO) +``` + +The coordinator launches only the learning and retry use cases. It does not own UI state and does not expose a fake cancellation method. + +- [ ] **Step 5: Bind Room repositories, factory, clock, ID generator, use cases, DataStore, and coordinator in Hilt** + +Use `UUID.randomUUID().toString()` only in the Android ID-generator binding. Use `System.currentTimeMillis()` only in the clock binding; tests inject deterministic implementations. + +- [ ] **Step 6: Run feature unit tests and compile instrumentation tests** + +```bash +./gradlew :android:feature:infrared:testDebugUnitTest :android:feature:infrared:compileDebugAndroidTestKotlin +``` + +- [ ] **Step 7: Commit runtime orchestration** + +```bash +git add android/feature/infrared/src/main android/feature/infrared/src/test +git commit -m "feat: coordinate infrared runtime state" +``` + +--- + +### Task 7: Implement the Infrared ViewModel State Machine + +**Files:** +- Create: `android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/ui/InfraredControlUiState.kt` +- Create: `android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/ui/InfraredControlViewModel.kt` +- Test: `android/feature/infrared/src/test/kotlin/com/flagship/abox/manager/infrared/ui/InfraredControlViewModelTest.kt` + +**Interfaces:** +- Consumes: route argument `profileId`, repositories, mode store, resolver, coordinator, send/rename/delete/recovery use cases. +- Produces a `StateFlow` plus intent methods. + +```kotlin +data class InfraredControlUiState( + val runtimeMode: InfraredRuntimeMode = InfraredRuntimeMode.FAKE, + val effectiveProfileId: ProviderProfileId? = null, + val deviceNameInput: String = "", + val savedDeviceName: DeviceName? = null, + val keys: List = emptyList(), + val loading: Boolean = true, + val sendingKeyIds: Set = emptySet(), + val message: InfraredUiMessage? = null, +) { + val hasActiveLearning: Boolean get() = keys.any { it.status == InfraredKeyStatus.LEARNING } +} +``` + +Intent methods: + +```kotlin +fun onDeviceNameChanged(value: String) +fun saveDeviceName() +fun learnKey(displayName: String) +fun retryLearning(keyId: InfraredKeyId) +fun sendKey(keyId: InfraredKeyId) +fun renameKey(keyId: InfraredKeyId, displayName: String) +fun deleteKey(keyId: InfraredKeyId) +fun setRuntimeMode(mode: InfraredRuntimeMode) +fun clearMessage() +``` + +- [ ] **Step 1: Write failing state-combination tests** + +Test that the ViewModel combines route profile, mode, saved device name, and observed key Flow; Fake mode must use `abox:infrared-fake`, Real mode must use `abox`. + +- [ ] **Step 2: Write failing intent tests** + +Required cases: + +```text +blank device name → validation message; repository not called +save device name → trim and persist +learn without saved device → validation message +learn with saved device → coordinator called once +send READY key → sending set contains ID during call, then clears +send failure → error message, key remains READY +set mode while LEARNING → rejected with message +set mode when idle → store updated and effective profile changes +TokenInvalid → session-expired message suitable for app navigation +``` + +- [ ] **Step 3: Run ViewModel tests and verify failure** + +```bash +./gradlew :android:feature:infrared:testDebugUnitTest --tests "*.InfraredControlViewModelTest" +``` + +- [ ] **Step 4: Implement Flow composition and SavedStateHandle profile parsing** + +The navigation argument is named `profileId`. Blank/missing values produce `DomainError.InvalidRequest` UI state rather than defaulting silently. + +- [ ] **Step 5: Implement intents with per-key send suppression** + +If a key ID is already in `sendingKeyIds`, ignore duplicate send taps. Mode changes are rejected while `hasActiveLearning` is true. + +- [ ] **Step 6: Run feature unit tests** + +```bash +./gradlew :android:feature:infrared:testDebugUnitTest +``` + +- [ ] **Step 7: Commit ViewModel** + +```bash +git add android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/ui android/feature/infrared/src/test/kotlin/com/flagship/abox/manager/infrared/ui +git commit -m "feat: add infrared control state machine" +``` + +--- + +### Task 8: Build the Simple Functional Compose Screen + +**Files:** +- Create: `android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/ui/InfraredControlScreen.kt` +- Create: `android/feature/infrared/src/main/res/values/strings.xml` +- Create: `android/feature/infrared/src/main/res/values-zh-rCN/strings.xml` +- Test: `android/feature/infrared/src/androidTest/kotlin/com/flagship/abox/manager/infrared/ui/InfraredControlScreenTest.kt` + +**Interfaces:** +- Consumes: `InfraredControlUiState` and callbacks from Task 7. +- Produces: + +```kotlin +@Composable +fun InfraredControlRoute(onBack: () -> Unit, onSessionInvalid: () -> Unit) + +@Composable +internal fun InfraredControlScreen( + state: InfraredControlUiState, + onBack: () -> Unit, + onDeviceNameChanged: (String) -> Unit, + onSaveDeviceName: () -> Unit, + onLearn: (String) -> Unit, + onRetry: (InfraredKeyId) -> Unit, + onSend: (InfraredKeyId) -> Unit, + onRename: (InfraredKeyId, String) -> Unit, + onDelete: (InfraredKeyId) -> Unit, + onModeChanged: (InfraredRuntimeMode) -> Unit, + onMessageShown: () -> Unit, +) +``` + +- [ ] **Step 1: Write failing Compose tests for the functional surface** + +Use stable test tags: + +```text +infrared_mode_label +infrared_device_name_input +infrared_save_device +infrared_learn_new_key +infrared_key_ +infrared_send_ +infrared_retry_ +``` + +Test the empty state, mode label, device-name save action, READY send button, FAILED retry button, LEARNING progress text, and delete confirmation copy. + +- [ ] **Step 2: Compile instrumentation tests and verify failure** + +```bash +./gradlew :android:feature:infrared:compileDebugAndroidTestKotlin +``` + +- [ ] **Step 3: Implement a deliberately simple layout** + +Use existing `ABoxSurface`, `ABoxButton`, Material 3 `OutlinedTextField`, `LazyColumn`, `AlertDialog`, `CircularProgressIndicator`, and text styles. Do not add new brand colors, custom animation systems, or reusable design-system components. + +- [ ] **Step 4: Implement the learn dialog** + +The dialog contains a display-name field and this functional guidance: + +```text +Prepare the physical remote. After starting, point it at the infrared controller and press the target button. +``` + +The Chinese resource communicates the same meaning. No Stop button is rendered after learning begins. + +- [ ] **Step 5: Implement delete and rename dialogs** + +Delete copy explicitly states that only the local entry is removed and ABox may retain the server-side key. Rename only sends a new display name. + +- [ ] **Step 6: Run feature tests** + +```bash +./gradlew :android:feature:infrared:testDebugUnitTest :android:feature:infrared:connectedDebugAndroidTest +``` + +If no emulator is available, run the compile task and report instrumentation execution as pending. + +- [ ] **Step 7: Commit UI** + +```bash +git add android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/ui/InfraredControlScreen.kt android/feature/infrared/src/main/res android/feature/infrared/src/androidTest +git commit -m "feat: add infrared control screen" +``` + +--- + +### Task 9: Wire Debug Fake/Real Routing and Safe Release Binding + +**Files:** +- Modify: `android/app/build.gradle.kts:54-77` +- Modify: `android/app/src/debug/kotlin/com/flagship/abox/manager/di/FoundationModule.kt:1-42` +- Create: `android/app/src/debug/kotlin/com/flagship/abox/manager/di/DebugRoutingInfraredGateway.kt` +- Create: `android/app/src/debug/AndroidManifest.xml` +- Create: `android/app/src/release/kotlin/com/flagship/abox/manager/di/InfraredReleaseModule.kt` +- Test: `android/app/src/test/kotlin/com/flagship/abox/manager/di/DebugRoutingInfraredGatewayTest.kt` + +**Interfaces:** +- Consumes: `InfraredRuntimeModeStore`, `FakeInfraredGateway`, and the shared `AbsdkBridge`. +- Produces: one injected `InfraredGateway` that delegates by current runtime mode. + +- [ ] **Step 1: Add app dependencies** + +```kotlin +implementation(project(":android:feature:infrared")) +debugImplementation(project(":testing:fakes")) +debugImplementation(project(":absdk-bridge")) +``` + +Do not add `:absdk-bridge` to release implementation. + +- [ ] **Step 2: Write failing router tests** + +Construct the router with a fake mode store and two recording gateways. Verify FAKE delegates only to Fake, REAL_ABSDK delegates only to Real, and all parameters/results pass through unchanged for send, learn, and download. + +- [ ] **Step 3: Implement `DebugRoutingInfraredGateway`** + +For each suspending operation call `modeStore.currentMode()` once, choose a delegate, and invoke it once. Do not cache the mode across calls. + +- [ ] **Step 4: Replace the direct Fake gateway binding** + +In `FoundationModule` provide: + +```kotlin +@Provides @Singleton fun provideFakeInfraredGateway(): FakeInfraredGateway + +@Provides +@Singleton +@OptIn(CleartextAbsdkTransport::class) +fun provideRealAbsdkBridge(): AbsdkBridge = AbsdkBridge.create() + +@Provides +@Singleton +fun provideInfraredGateway( + modeStore: InfraredRuntimeModeStore, + fake: FakeInfraredGateway, + real: AbsdkBridge, +): InfraredGateway = DebugRoutingInfraredGateway(modeStore, fake, real) +``` + +Keep the existing Fake session and other device gateways for current foundation behavior. Document in code that Real infrared mode requires another feature to authenticate this same concrete `AbsdkBridge` instance; do not create a second bridge. + +- [ ] **Step 5: Add debug-only network manifest configuration** + +```xml + + + + +``` + +This file exists only under `src/debug`. + +- [ ] **Step 6: Add a release-disabled gateway** + +`InfraredReleaseModule` provides an `InfraredGateway` whose three methods return: + +```kotlin +DomainResult.Failure( + DomainError.OperationFailed( + externalCode = "REAL_ABSDK_DISABLED", + detail = "Infrared hardware transport is disabled in release builds", + ), +) +``` + +The release implementation does not import ABSDK types or request Internet/cleartext permissions. + +- [ ] **Step 7: Run router tests and both build variants** + +```bash +./gradlew :android:app:testDebugUnitTest :android:app:assembleDebug :android:app:assembleRelease +``` + +Expected: tests pass; both APK variants compile; release has no dependency on `:absdk-bridge`. + +- [ ] **Step 8: Commit runtime wiring** + +```bash +git add android/app/build.gradle.kts android/app/src/debug android/app/src/release android/app/src/test +git commit -m "feat: route infrared debug hardware modes" +``` + +--- + +### Task 10: Add the Temporary Navigation Entry + +**Files:** +- Modify: `android/app/src/main/kotlin/com/flagship/abox/manager/ui/ABoxManagerApp.kt:23-71` +- Modify: `android/app/src/main/res/values/strings.xml:1-8` +- Modify: `android/app/src/main/res/values-zh-rCN/strings.xml:1-8` +- Test: `android/app/src/androidTest/kotlin/com/flagship/abox/manager/ui/ABoxManagerAppTest.kt` + +**Interfaces:** +- Consumes: `InfraredControlRoute`. +- Produces route `infrared/{profileId}` with navigation argument `profileId`. + +- [ ] **Step 1: Write a failing navigation test** + +Launch the app, click the button with text “Infrared control”/“红外控制”, and assert the infrared title and Fake mode label are displayed. + +- [ ] **Step 2: Compile the app instrumentation test and verify failure** + +```bash +./gradlew :android:app:compileDebugAndroidTestKotlin +``` + +- [ ] **Step 3: Add the route and temporary entry** + +Use: + +```kotlin +private const val INFRARED_ROUTE = "infrared/{profileId}" +private const val TEMPORARY_ABOX_PROFILE_ID = "abox" +``` + +Add a second button to the existing `FoundationScreen`. Navigate with `infrared/abox`. Do not rename `FoundationScreen` to “Login” because it is not a login implementation. + +- [ ] **Step 4: Wire session-invalid handling honestly** + +Until a login screen exists, `onSessionInvalid` navigates back to the foundation route and shows a functional message explaining that the ABox session is not authenticated. Do not add username/password fields to the infrared screen. + +- [ ] **Step 5: Run navigation tests and assemble** + +```bash +./gradlew :android:app:connectedDebugAndroidTest :android:app:assembleDebug +``` + +If no emulator is available, require test compilation and APK assembly, and report the unexecuted instrumentation test. + +- [ ] **Step 6: Commit app navigation** + +```bash +git add android/app/src/main android/app/src/androidTest +git commit -m "feat: add temporary infrared navigation" +``` + +--- + +### Task 11: Complete ABSDK Infrared Contract and Error Tests + +**Files:** +- Modify: `absdk-bridge/src/test/kotlin/com/flagship/abox/manager/absdk/bridge/AbsdkDeviceBridgeTest.kt:86-168` +- Modify: `absdk-bridge/src/test/kotlin/com/flagship/abox/manager/absdk/bridge/AbsdkSerializationTest.kt` +- Modify: `absdk-bridge/src/test/kotlin/com/flagship/abox/manager/absdk/bridge/ScriptedAbsdkClient.kt:6-73` +- Modify only if a test exposes a real defect: `absdk-bridge/src/main/kotlin/com/flagship/abox/manager/absdk/bridge/AbsdkBridge.kt` +- Modify only if a mapping test exposes a real defect: `absdk-bridge/src/main/kotlin/com/flagship/abox/manager/absdk/bridge/AbsdkErrorMapper.kt` + +**Interfaces:** +- Consumes: unchanged `InfraredGateway` contract. +- Produces: verified parameter forwarding, error mapping, and serialization guarantees. + +- [ ] **Step 1: Split the broad infrared test into focused tests** + +Add exact assertions: + +```kotlin +@Test +fun infraredSendForwardsDeviceAndStableKey() = runTest { + val client = ScriptedAbsdkClient() + val bridge = authenticatedBridge(client) + assertEquals(DomainResult.Success(Unit), bridge.sendKey(profile, DeviceName("ir-room"), "app_ir_power")) + assertEquals(listOf("login:demo", "ir-send:ir-room:app_ir_power"), client.calls) +} + +@Test +fun infraredLearnForwardsDeviceAndStableKey() = runTest { + val client = ScriptedAbsdkClient() + val bridge = authenticatedBridge(client) + assertEquals(DomainResult.Success(Unit), bridge.learnKey(profile, DeviceName("ir-room"), "app_ir_power")) + assertEquals(listOf("login:demo", "ir-learn:ir-room:app_ir_power"), client.calls) +} +``` + +- [ ] **Step 2: Add table-driven red/green mapping tests for codes 20201–20206** + +Expected classes: + +```text +20201, 20202 → DomainError.InvalidRequest +20203 → DomainError.DeviceNotFound +20204, 20205 → DomainError.OperationFailed +20206 → DomainError.DeviceOffline +``` + +Test send and learn paths, not only download. + +- [ ] **Step 3: Add null response and cross-device serialization tests** + +Verify a null response becomes a contained `DomainError.Unknown`/existing mapped failure rather than crashing, and concurrent infrared learning plus socket/temperature operations never exceed one active SDK call. + +- [ ] **Step 4: Run bridge tests** + +```bash +./gradlew :absdk-bridge:test +``` + +- [ ] **Step 5: Make only minimal production fixes exposed by failing tests** + +Do not refactor public APIs or parse undocumented learning data. Preserve `downloadCodes()` partial-success behavior for `20204`. + +- [ ] **Step 6: Run the full JVM suite** + +```bash +./gradlew :domain:test :testing:fakes:test :absdk-bridge:test +``` + +- [ ] **Step 7: Commit bridge verification** + +```bash +git add absdk-bridge/src/test absdk-bridge/src/main +git commit -m "test: verify ABSDK infrared contracts" +``` + +--- + +### Task 12: Verify the Complete Feature and Record Hardware Procedure + +**Files:** +- Create: `docs/testing/infrared-hardware-validation.md` +- Modify if observations require documentation updates: `docs/protocol/absdk-0630.md` +- No production code changes unless a preceding test demonstrates a defect. + +**Interfaces:** +- Consumes: complete feature. +- Produces: reproducible automated verification and a truthful hardware checklist. + +- [ ] **Step 1: Write the hardware validation document before running hardware tests** + +Include a table with these columns: + +```text +Date | App commit | Runtime mode | Profile ID | Device name | sdkKey +Operation | Duration ms | ABSDK code | Sanitized message | Physical response | Result +``` + +Include exact procedures for: + +1. authenticate the shared `AbsdkBridge` through the login feature; +2. enter the real `irDevName`; +3. learn a unique key; +4. immediately send the same key; +5. repeat send; +6. relearn the same SDK key; +7. test controller offline; +8. test no remote signal/timeout; +9. leave the page during learning; +10. kill/restart the process with LEARNING persisted; +11. expire the token; +12. record whether undocumented `dicDatas` exists without logging its contents in production. + +- [ ] **Step 2: Run static and JVM verification** + +```bash +./gradlew clean :domain:test :testing:fakes:test :absdk-bridge:test :android:feature:infrared:testDebugUnitTest :android:app:testDebugUnitTest :android:app:lintDebug +``` + +Expected: all tasks pass with no test failures or lint errors. + +- [ ] **Step 3: Run Android compilation and packaging** + +```bash +./gradlew :android:feature:infrared:compileDebugAndroidTestKotlin :android:app:compileDebugAndroidTestKotlin :android:app:assembleDebug :android:app:assembleRelease +``` + +Expected: all tasks pass. + +- [ ] **Step 4: Run instrumentation tests when a device is available** + +```bash +./gradlew :android:feature:infrared:connectedDebugAndroidTest :android:app:connectedDebugAndroidTest +``` + +Record exact passed/failed/skipped counts. Never describe unexecuted tests as passing. + +- [ ] **Step 5: Run Fake-mode manual acceptance** + +Verify: + +```text +open temporary entry +save irDevName +create key → LEARNING → READY +send READY key +script failure → FAILED and retry +rename without sdkKey change +delete with local-only warning +attempt mode switch during learning → blocked +restart app → saved device and keys remain +``` + +- [ ] **Step 6: Run Real-mode hardware acceptance only when login is available** + +Precondition: the login implementation must authenticate the same `AbsdkBridge.create()` singleton. If current `main` still lacks login, mark Real hardware acceptance as blocked by login integration; do not add credentials to the infrared feature and do not claim the real loop works. + +Minimum passing result: + +```text +learnKey(realDeviceName, sdkKey) returns success +sendKey(realDeviceName, sameSdkKey) returns success +physical appliance performs the expected action +``` + +- [ ] **Step 7: Update protocol documentation with observed facts** + +Only add confirmed observations: blocking duration, timeout behavior, same-key relearn behavior, exact sanitized code/message, whether sending after learning works, and any undocumented response-field names. Label environment-specific observations with date and hardware context. + +- [ ] **Step 8: Commit verification documentation** + +```bash +git add docs/testing/infrared-hardware-validation.md docs/protocol/absdk-0630.md +git commit -m "docs: add infrared hardware validation" +``` + +- [ ] **Step 9: Perform final branch review** + +```bash +git status --short +git log --oneline origin/main..HEAD +git diff --check origin/main...HEAD +``` + +Expected: clean working tree, focused commits, no whitespace errors. + +- [ ] **Step 10: Request code review and open a PR** + +Invoke `superpowers:requesting-code-review`, address verified findings, rerun affected tests, then use `superpowers:finishing-a-development-branch` to create a Pull Request targeting `main`. Never merge directly to `main`. diff --git a/docs/superpowers/plans/2026-08-24-infrared-remote-ui.md b/docs/superpowers/plans/2026-08-24-infrared-remote-ui.md new file mode 100644 index 0000000..942c7f7 --- /dev/null +++ b/docs/superpowers/plans/2026-08-24-infrared-remote-ui.md @@ -0,0 +1,589 @@ +# Infrared Remote Control UI & Multi-Scene Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Build a realistic, multi-scene infrared remote control UI (Air Conditioner & Television) with learning/control mode toggle, fixed slot key bindings (1-100), graphic component modeling (circles, capsules, D-pad wheels), and settings navigation. + +**Architecture:** Add scene models and predefined key specs in `:android:feature:infrared`. Implement `InfraredRemoteViewModel` to observe Room keys and coordinator actions. Build Compose panels for AC and TV remotes, and integrate the navigation route `infrared_remote/{profileId}` alongside `infrared_settings/{profileId}`. + +**Tech Stack:** Kotlin 1.9.24, Jetpack Compose Material 3, Android Gradle Plugin 8.7.3, Room, StateFlow, Hilt, Coroutines. + +**Spec:** `docs/superpowers/specs/2026-08-24-infrared-remote-ui-design.md` + +## Global Constraints + +- Remote buttons display clean symbols/icons, never raw Chinese long names on the button faces. +- Every button maps to a dedicated 1-100 integer slot (AC: 1–20, TV: 21–50). +- Learning mode toggle activates visual indicator and switches button clicks from `sendKey` to `learnKey`. +- Settings navigation allows jumping to the existing `InfraredControlScreen` (renamed to Settings) to view raw entries and device names. +- Follow TDD with unit and Compose UI tests. + +--- + +### Task 1: Define Remote Scenes and Key Specs + +**Files:** +- Create: `android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/remote/RemoteModels.kt` +- Test: `android/feature/infrared/src/test/kotlin/com/flagship/abox/manager/infrared/remote/RemoteModelsTest.kt` + +**Interfaces:** +- Produces: `RemoteScene`, `RemoteButtonId`, `RemoteButtonSpec`, and `RemoteSceneConfig`. + +- [ ] **Step 1: Write test for predefined AC and TV remote button specifications** + +```kotlin +package com.flagship.abox.manager.infrared.remote + +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNotNull +import org.junit.Test + +class RemoteModelsTest { + @Test + fun acSpecsHaveUniqueSlotsBetween1And20() { + val slots = RemoteSceneConfig.AirConditioner.buttons.map { it.defaultSlot } + assertEquals(slots.size, slots.distinct().size) + assert(slots.all { it.toInt() in 1..20 }) + } + + @Test + fun tvSpecsHaveUniqueSlotsBetween21And50() { + val slots = RemoteSceneConfig.Television.buttons.map { it.defaultSlot } + assertEquals(slots.size, slots.distinct().size) + assert(slots.all { it.toInt() in 21..50 }) + } +} +``` + +- [ ] **Step 2: Run test to verify failure** + +Run: `./gradlew :android:feature:infrared:testDebugUnitTest --tests "*.RemoteModelsTest"` +Expected: Compilation failure. + +- [ ] **Step 3: Implement `RemoteModels.kt`** + +```kotlin +package com.flagship.abox.manager.infrared.remote + +enum class RemoteScene { + AIR_CONDITIONER, + TELEVISION, +} + +data class RemoteButtonSpec( + val id: String, + val defaultSlot: String, + val displayName: String, + val symbol: String, +) + +object RemoteSceneConfig { + object AirConditioner { + val POWER = RemoteButtonSpec("AC_POWER", "1", "空调-电源", "⏻") + val TEMP_UP = RemoteButtonSpec("AC_TEMP_UP", "2", "空调-温度+", "▲") + val TEMP_DOWN = RemoteButtonSpec("AC_TEMP_DOWN", "3", "空调-温度-", "▼") + val MODE = RemoteButtonSpec("AC_MODE", "4", "空调-模式", "模式 ❄/☀") + val FAN = RemoteButtonSpec("AC_FAN", "5", "空调-风速", "风速 💨") + val SWING = RemoteButtonSpec("AC_SWING", "6", "空调-扫风", "扫风 ↔") + val TIMER = RemoteButtonSpec("AC_TIMER", "7", "空调-定时", "定时 ⏱") + + val buttons = listOf(POWER, TEMP_UP, TEMP_DOWN, MODE, FAN, SWING, TIMER) + } + + object Television { + val POWER = RemoteButtonSpec("TV_POWER", "21", "电视-电源", "⏻") + val MUTE = RemoteButtonSpec("TV_MUTE", "22", "电视-静音", "🔇") + val NAV_UP = RemoteButtonSpec("TV_NAV_UP", "23", "电视-上", "▲") + val NAV_DOWN = RemoteButtonSpec("TV_NAV_DOWN", "24", "电视-下", "▼") + val NAV_LEFT = RemoteButtonSpec("TV_NAV_LEFT", "25", "电视-左", "◀") + val NAV_RIGHT = RemoteButtonSpec("TV_NAV_RIGHT", "26", "电视-右", "▶") + val OK = RemoteButtonSpec("TV_OK", "27", "电视-确定", "OK") + val VOL_UP = RemoteButtonSpec("TV_VOL_UP", "28", "电视-音量+", "VOL +") + val VOL_DOWN = RemoteButtonSpec("TV_VOL_DOWN", "29", "电视-音量-", "VOL -") + val CH_UP = RemoteButtonSpec("TV_CH_UP", "30", "电视-频道+", "CH +") + val CH_DOWN = RemoteButtonSpec("TV_CH_DOWN", "31", "电视-频道-", "CH -") + val HOME = RemoteButtonSpec("TV_HOME", "32", "电视-主页", "🏠") + val BACK = RemoteButtonSpec("TV_BACK", "33", "电视-返回", "↩") + val MENU = RemoteButtonSpec("TV_MENU", "34", "电视-菜单", "☰") + + val buttons = listOf( + POWER, MUTE, NAV_UP, NAV_DOWN, NAV_LEFT, NAV_RIGHT, OK, + VOL_UP, VOL_DOWN, CH_UP, CH_DOWN, HOME, BACK, MENU + ) + } +} +``` + +- [ ] **Step 4: Run test to verify it passes** + +Run: `./gradlew :android:feature:infrared:testDebugUnitTest --tests "*.RemoteModelsTest"` +Expected: PASS. + +- [ ] **Step 5: Commit** + +```bash +git add android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/remote/RemoteModels.kt android/feature/infrared/src/test/kotlin/com/flagship/abox/manager/infrared/remote/RemoteModelsTest.kt +git commit -m "feat: define infrared remote scenes and button specifications" +``` + +--- + +### Task 2: Implement Infrared Remote ViewModel + +**Files:** +- Create: `android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/remote/InfraredRemoteViewModel.kt` +- Create: `android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/remote/InfraredRemoteUiState.kt` +- Test: `android/feature/infrared/src/test/kotlin/com/flagship/abox/manager/infrared/remote/InfraredRemoteViewModelTest.kt` + +**Interfaces:** +- Consumes: `InfraredKeyRepository`, `InfraredDeviceConfigurationRepository`, `InfraredLearningCoordinator`, `SendInfraredKey`, `InfraredRuntimeModeStore`. +- Produces: `StateFlow` with `onButtonClick`, `toggleLearningMode`, `switchScene`. + +- [ ] **Step 1: Write failing ViewModel test** + +```kotlin +package com.flagship.abox.manager.infrared.remote + +import androidx.lifecycle.SavedStateHandle +import com.flagship.abox.manager.domain.DeviceName +import com.flagship.abox.manager.domain.DomainResult +import com.flagship.abox.manager.domain.ProviderProfileId +import com.flagship.abox.manager.domain.infrared.* +import com.flagship.abox.manager.infrared.application.InfraredLearningCoordinator +import com.flagship.abox.manager.infrared.runtime.InfraredRuntimeMode +import com.flagship.abox.manager.infrared.runtime.InfraredRuntimeModeStore +import com.flagship.abox.manager.infrared.runtime.InfraredRuntimeProfileResolver +import com.flagship.abox.manager.testing.fakes.FakeInfraredDeviceConfigurationRepository +import com.flagship.abox.manager.testing.fakes.FakeInfraredGateway +import com.flagship.abox.manager.testing.fakes.FakeInfraredKeyRepository +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.ExperimentalCoroutinesApi +import kotlinx.coroutines.flow.Flow +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.launch +import kotlinx.coroutines.test.* +import org.junit.After +import org.junit.Assert.* +import org.junit.Before +import org.junit.Test + +private class TestModeStore : InfraredRuntimeModeStore { + private val modeFlow = MutableStateFlow(InfraredRuntimeMode.FAKE) + override val mode: Flow = modeFlow + override suspend fun currentMode(): InfraredRuntimeMode = modeFlow.value + override suspend fun setMode(mode: InfraredRuntimeMode): DomainResult { + modeFlow.value = mode + return DomainResult.Success(Unit) + } +} + +@OptIn(ExperimentalCoroutinesApi::class) +class InfraredRemoteViewModelTest { + private val testDispatcher = StandardTestDispatcher() + private val testScope = TestScope(testDispatcher) + + private val profile = ProviderProfileId("abox") + private val fakeProfile = ProviderProfileId("abox:infrared-fake") + private val device = DeviceName("ir-living") + private val clock = EpochMillisClock { 10_000L } + + private val keyRepo = FakeInfraredKeyRepository() + private val deviceRepo = FakeInfraredDeviceConfigurationRepository() + private val modeStore = TestModeStore() + private val resolver = InfraredRuntimeProfileResolver() + private val gateway = FakeInfraredGateway() + private val factory = InfraredKeyFactory({ InfraredKeyId("id-1") }, clock) + + private val learn = LearnInfraredKey(keyRepo, gateway, factory, clock) + private val retry = RetryInfraredKeyLearning(keyRepo, gateway, clock) + private val send = SendInfraredKey(keyRepo, gateway) + private lateinit var coordinator: InfraredLearningCoordinator + + @Before + fun setup() { + Dispatchers.setMain(testDispatcher) + coordinator = InfraredLearningCoordinator(learn, retry, testScope) + } + + @After + fun teardown() { + Dispatchers.resetMain() + } + + private fun createViewModel(): InfraredRemoteViewModel { + return InfraredRemoteViewModel( + savedStateHandle = SavedStateHandle(mapOf("profileId" to "abox")), + keyRepository = keyRepo, + deviceConfigurationRepository = deviceRepo, + runtimeModeStore = modeStore, + profileResolver = resolver, + learningCoordinator = coordinator, + sendInfraredKey = send, + ) + } + + @Test + fun controlModeSendsSignalWhenKeyIsReady() = testScope.runTest { + deviceRepo.setDeviceName(fakeProfile, device) + val readyKey = SavedInfraredKey( + id = InfraredKeyId("k1"), + profileId = fakeProfile, + deviceName = device, + displayName = "空调-电源", + sdkKey = "1", + status = InfraredKeyStatus.READY, + lastErrorCode = null, + lastErrorDetail = null, + createdAtEpochMillis = 100L, + updatedAtEpochMillis = 100L, + ) + keyRepo.insert(readyKey) + + val vm = createViewModel() + val job = launch { vm.state.collect {} } + advanceUntilIdle() + + vm.onButtonClick(RemoteSceneConfig.AirConditioner.POWER) + advanceUntilIdle() + + assertEquals(1, gateway.sentKeys.size) + assertEquals("1", gateway.sentKeys.first().key) + + job.cancel() + } + + @Test + fun learningModeTriggersLearnOnButtonClick() = testScope.runTest { + deviceRepo.setDeviceName(fakeProfile, device) + val vm = createViewModel() + val job = launch { vm.state.collect {} } + advanceUntilIdle() + + vm.toggleLearningMode(true) + vm.onButtonClick(RemoteSceneConfig.AirConditioner.POWER) + advanceUntilIdle() + + assertEquals(1, gateway.learnedKeys.size) + assertEquals("1", gateway.learnedKeys.first().key) + + job.cancel() + } +} +``` + +- [ ] **Step 2: Run test to verify failure** + +Run: `./gradlew :android:feature:infrared:testDebugUnitTest --tests "*.InfraredRemoteViewModelTest"` +Expected: Compilation failure. + +- [ ] **Step 3: Implement `InfraredRemoteUiState` and `InfraredRemoteViewModel`** + +```kotlin +package com.flagship.abox.manager.infrared.remote + +import androidx.lifecycle.SavedStateHandle +import androidx.lifecycle.ViewModel +import androidx.lifecycle.viewModelScope +import com.flagship.abox.manager.domain.DeviceName +import com.flagship.abox.manager.domain.DomainError +import com.flagship.abox.manager.domain.DomainResult +import com.flagship.abox.manager.domain.ProviderProfileId +import com.flagship.abox.manager.domain.infrared.* +import com.flagship.abox.manager.infrared.application.InfraredLearningCoordinator +import com.flagship.abox.manager.infrared.runtime.InfraredRuntimeMode +import com.flagship.abox.manager.infrared.runtime.InfraredRuntimeModeStore +import com.flagship.abox.manager.infrared.runtime.InfraredRuntimeProfileResolver +import dagger.hilt.android.lifecycle.HiltViewModel +import kotlinx.coroutines.ExperimentalCoroutinesApi +import kotlinx.coroutines.flow.* +import kotlinx.coroutines.launch +import javax.inject.Inject + +sealed interface RemoteUiMessage { + data class Info(val text: String) : RemoteUiMessage + data class Error(val text: String) : RemoteUiMessage + data object SessionInvalid : RemoteUiMessage +} + +data class InfraredRemoteUiState( + val selectedScene: RemoteScene = RemoteScene.AIR_CONDITIONER, + val isLearningMode: Boolean = false, + val runtimeMode: InfraredRuntimeMode = InfraredRuntimeMode.FAKE, + val effectiveProfileId: ProviderProfileId? = null, + val savedDeviceName: DeviceName? = null, + val learnedSlotMap: Map = emptyMap(), + val sendingKeySlot: String? = null, + val activeLearningSlot: String? = null, + val message: RemoteUiMessage? = null, +) + +@OptIn(ExperimentalCoroutinesApi::class) +@HiltViewModel +class InfraredRemoteViewModel @Inject constructor( + savedStateHandle: SavedStateHandle, + private val keyRepository: InfraredKeyRepository, + private val deviceConfigurationRepository: InfraredDeviceConfigurationRepository, + private val runtimeModeStore: InfraredRuntimeModeStore, + private val profileResolver: InfraredRuntimeProfileResolver, + private val learningCoordinator: InfraredLearningCoordinator, + private val sendInfraredKey: SendInfraredKey, +) : ViewModel() { + + private val rawProfileId: String? = savedStateHandle["profileId"] + private val authenticatedProfileId: ProviderProfileId? = rawProfileId?.takeIf { it.isNotBlank() }?.let { ProviderProfileId(it) } + + private val sceneFlow = MutableStateFlow(RemoteScene.AIR_CONDITIONER) + private val isLearningModeFlow = MutableStateFlow(false) + private val sendingKeySlotFlow = MutableStateFlow(null) + private val activeLearningSlotFlow = MutableStateFlow(null) + private val messageFlow = MutableStateFlow(null) + + private val effectiveProfileAndMode = runtimeModeStore.mode.flatMapLatest { mode -> + if (authenticatedProfileId == null) { + flowOf(Pair(null, mode)) + } else { + flowOf(Pair(profileResolver.resolve(authenticatedProfileId, mode), mode)) + } + } + + private val deviceNameFlow = effectiveProfileAndMode.flatMapLatest { (profile, _) -> + if (profile == null) flowOf(DomainResult.Success(null)) + else deviceConfigurationRepository.observeDeviceName(profile) + } + + private val keysFlow = effectiveProfileAndMode.flatMapLatest { (profile, _) -> + if (profile == null) flowOf(DomainResult.Success(emptyList())) + else { + deviceConfigurationRepository.observeDeviceName(profile).flatMapLatest { deviceResult -> + when (deviceResult) { + is DomainResult.Success -> { + val device = deviceResult.value + if (device == null) flowOf(DomainResult.Success(emptyList())) + else keyRepository.observeKeys(profile, device) + } + is DomainResult.Failure -> flowOf(DomainResult.Failure(deviceResult.error)) + } + } + } + } + + val state: StateFlow = combine( + sceneFlow, + isLearningModeFlow, + effectiveProfileAndMode, + deviceNameFlow, + keysFlow, + sendingKeySlotFlow, + activeLearningSlotFlow, + messageFlow, + ) { scene, isLearning, profileAndMode, deviceResult, keysResult, sendingSlot, learningSlot, msg -> + val (profile, mode) = profileAndMode + val savedDevice = (deviceResult as? DomainResult.Success)?.value + val keys = (keysResult as? DomainResult.Success>)?.value ?: emptyList() + val slotMap = keys.associateBy { it.sdkKey } + + InfraredRemoteUiState( + selectedScene = scene, + isLearningMode = isLearning, + runtimeMode = mode, + effectiveProfileId = profile, + savedDeviceName = savedDevice, + learnedSlotMap = slotMap, + sendingKeySlot = sendingSlot, + activeLearningSlot = learningSlot, + message = msg, + ) + }.stateIn( + scope = viewModelScope, + started = SharingStarted.WhileSubscribed(5_000), + initialValue = InfraredRemoteUiState(), + ) + + fun switchScene(scene: RemoteScene) { + sceneFlow.value = scene + } + + fun toggleLearningMode(enabled: Boolean) { + isLearningModeFlow.value = enabled + if (enabled) { + messageFlow.value = RemoteUiMessage.Info("🔴 学习录制模式已开启：点击任意按键即可开始录制") + } + } + + fun onButtonClick(spec: RemoteButtonSpec) { + val currentProfile = state.value.effectiveProfileId ?: return + val savedDevice = state.value.savedDeviceName + if (savedDevice == null) { + messageFlow.value = RemoteUiMessage.Error("未配置红外设备名，请点击右上角设置配置") + return + } + + if (state.value.isLearningMode) { + activeLearningSlotFlow.value = spec.defaultSlot + learningCoordinator.learn( + profileId = currentProfile, + deviceName = savedDevice, + displayName = spec.displayName, + sdkKey = spec.defaultSlot, + ) + messageFlow.value = RemoteUiMessage.Info("正在录制【${spec.displayName}】(Slot ${spec.defaultSlot})，请按物理遥控器按键...") + } else { + val key = state.value.learnedSlotMap[spec.defaultSlot] + if (key == null || key.status != InfraredKeyStatus.READY) { + messageFlow.value = RemoteUiMessage.Error("按键【${spec.displayName}】尚未学习，请开启右上角学习模式进行录制") + return + } + sendingKeySlotFlow.value = spec.defaultSlot + viewModelScope.launch { + try { + when (val result = sendInfraredKey(InfraredKeyRef(currentProfile, key.id))) { + is DomainResult.Success -> { + messageFlow.value = RemoteUiMessage.Info("已发射: ${spec.symbol}") + } + is DomainResult.Failure -> { + handleDomainError(result.error) + } + } + } finally { + sendingKeySlotFlow.value = null + } + } + } + } + + fun clearMessage() { + messageFlow.value = null + } + + private fun handleDomainError(error: DomainError) { + when (error) { + is DomainError.TokenInvalid, is DomainError.Authentication -> { + messageFlow.value = RemoteUiMessage.SessionInvalid + } + is DomainError.DeviceOffline -> { + messageFlow.value = RemoteUiMessage.Error("红外控制器离线 (错误码: ${error.externalCode ?: "20206"})") + } + else -> { + messageFlow.value = RemoteUiMessage.Error(error.detail ?: "操作失败") + } + } + } +} +``` + +- [ ] **Step 4: Run tests to verify they pass** + +Run: `./gradlew :android:feature:infrared:testDebugUnitTest --tests "*.InfraredRemoteViewModelTest"` +Expected: PASS. + +- [ ] **Step 5: Commit** + +```bash +git add android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/remote android/feature/infrared/src/test/kotlin/com/flagship/abox/manager/infrared/remote +git commit -m "feat: implement infrared remote control viewmodel" +``` + +--- + +### Task 3: Build Custom Remote Visual Components + +**Files:** +- Create: `android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/remote/ui/RemoteComponents.kt` +- Create: `android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/remote/ui/AcRemotePanel.kt` +- Create: `android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/remote/ui/TvRemotePanel.kt` +- Create: `android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/remote/ui/InfraredRemoteScreen.kt` +- Test: `android/feature/infrared/src/androidTest/kotlin/com/flagship/abox/manager/infrared/remote/InfraredRemoteScreenTest.kt` + +- [ ] **Step 1: Implement Compose visual elements** + - `RemoteCircleButton`, `VerticalCapsuleRocker`, `RemoteDpadWheel`, `AcLcdDisplay`. + - Compose panels for `AcRemotePanel` and `TvRemotePanel`. + - Assemble `InfraredRemoteScreen` with top learning switch and settings action. + +- [ ] **Step 2: Write Compose UI Test** + +```kotlin +package com.flagship.abox.manager.infrared.remote + +import androidx.compose.ui.test.assertIsDisplayed +import androidx.compose.ui.test.junit4.createComposeRule +import androidx.compose.ui.test.onNodeWithTag +import androidx.compose.ui.test.performClick +import androidx.test.ext.junit.runners.AndroidJUnit4 +import com.flagship.abox.manager.domain.DeviceName +import com.flagship.abox.manager.domain.ProviderProfileId +import com.flagship.abox.manager.infrared.remote.ui.InfraredRemoteScreen +import org.junit.Assert.assertEquals +import org.junit.Rule +import org.junit.Test +import org.junit.runner.RunWith + +@RunWith(AndroidJUnit4::class) +class InfraredRemoteScreenTest { + @get:Rule + val composeTestRule = createComposeRule() + + @Test + fun rendersAcPanelAndTvPanelCorrectly() { + val state = InfraredRemoteUiState( + selectedScene = RemoteScene.AIR_CONDITIONER, + savedDeviceName = DeviceName("ir-1"), + ) + var clickedSpec: RemoteButtonSpec? = null + + composeTestRule.setContent { + InfraredRemoteScreen( + state = state, + onBack = {}, + onOpenSettings = {}, + onSessionInvalid = {}, + onSceneSelected = {}, + onToggleLearningMode = {}, + onButtonClick = { clickedSpec = it }, + onMessageShown = {}, + ) + } + + composeTestRule.onNodeWithTag("remote_button_AC_POWER").assertIsDisplayed().performClick() + assertEquals("AC_POWER", clickedSpec?.id) + } +} +``` + +- [ ] **Step 3: Run compilation and tests** + +Run: `./gradlew :android:feature:infrared:compileDebugAndroidTestKotlin :android:feature:infrared:testDebugUnitTest` +Expected: PASS. + +- [ ] **Step 4: Commit** + +```bash +git add android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/remote/ui android/feature/infrared/src/androidTest/kotlin/com/flagship/abox/manager/infrared/remote +git commit -m "feat: add infrared remote control Compose screen and panels" +``` + +--- + +### Task 4: Integrate Navigation and App Flow + +**Files:** +- Modify: `android/app/src/main/kotlin/com/flagship/abox/manager/ui/ABoxManagerApp.kt` +- Modify: `android/app/src/main/res/values/strings.xml` +- Modify: `android/app/src/main/res/values-zh-rCN/strings.xml` + +- [ ] **Step 1: Wire Navigation** + - Route `infrared/{profileId}` now loads `InfraredRemoteRoute`. + - Add Route `infrared_settings/{profileId}` that loads `InfraredControlRoute` (the settings & raw list view). + - Top bar of `InfraredRemoteScreen` has ⚙️ button navigating to `infrared_settings/{profileId}`. + +- [ ] **Step 2: Run Full Verification Suite & Build APK** + +Run: `./gradlew :domain:test :testing:fakes:test :absdk-bridge:test :android:feature:infrared:testDebugUnitTest :android:app:testDebugUnitTest :android:app:assembleDebug` +Expected: BUILD SUCCESSFUL. + +- [ ] **Step 3: Commit and Push** + +```bash +git add android/app android/feature/infrared +git commit -m "feat: wire infrared remote screen and settings navigation" +git push origin feat/moler-infrared-control +``` diff --git a/docs/superpowers/specs/2026-08-24-infrared-control-design.md b/docs/superpowers/specs/2026-08-24-infrared-control-design.md new file mode 100644 index 0000000..fde4e17 --- /dev/null +++ b/docs/superpowers/specs/2026-08-24-infrared-control-design.md @@ -0,0 +1,606 @@ +# 红外学习与发射控制设计 + +## 1. 背景与目标 + +本项目当前可用于真实验证的设备包括 ABox 主机、红外控制器、智能插座和温湿度计。本阶段由 moler 负责红外能力，范围聚焦于红外控制器的基础闭环： + +1. 在登录成功后的现有页面提供一个临时入口； +2. 手动配置并记住一个 ABSDK 红外设备名； +3. 创建并命名多个红外按键； +4. 通过 ABSDK 发起红外学习； +5. 保存可重复使用的按键绑定； +6. 通过 ABSDK 发射已学习按键； +7. 支持 Fake 和真实 ABSDK 调试模式； +8. 为后续生活场景保留稳定按键引用。 + +首版前端只用于功能验证，沿用现有 Compose 和设计系统基础组件，不定义最终产品视觉风格。后续统一视觉改版只替换展示层，不改变红外领域、持久化、应用用例或硬件接口。 + +## 2. 已确认的 ABSDK 能力边界 + +ABSDK 0630 提供以下红外公开方法： + +```java +ABRet sendIr(String irDevName, String irKey) +ABRet studyIrByIrDevName(String irDevName, String irKey) +ABRet downloadIrCodes(List irInfos) +``` + +现有领域层已将其隔离为 `InfraredGateway`： + +```kotlin +interface InfraredGateway { + suspend fun sendKey( + profileId: ProviderProfileId, + deviceName: DeviceName, + key: String, + ): DomainResult + + suspend fun learnKey( + profileId: ProviderProfileId, + deviceName: DeviceName, + key: String, + ): DomainResult + + suspend fun downloadCodes( + profileId: ProviderProfileId, + codes: List, + ): DomainResult> +} +``` + +本设计必须遵守以下事实： + +- 学习接口只确认返回成功码和消息，没有已确认的原始红外码返回值； +- ABSDK 没有公开停止学习方法； +- ABSDK 没有公开获取学习结果或读取已学习原始码的方法； +- `downloadIrCodes()` 是把调用方已经拥有的红外码写入主机，不是读取学习结果； +- ABSDK 没有设备扫描或设备列表接口； +- 红外方法按 `irDevName + irKey` 寻址； +- SDK 调用为同步阻塞调用，现有 Bridge 在 `Dispatchers.IO` 上通过全局 `Mutex` 串行执行； +- SDK 使用固定明文 HTTP 目标，真实接入存在已知传输安全风险。 + +因此首版保存的是本地按键绑定，而不是原始红外波形或码值： + +```text +ProviderProfileId + DeviceName + sdkKey + displayName + learning status +``` + +真实硬件闭环成立的判据是： + +```text +learnKey(deviceName, sdkKey) 成功 + ↓ +sendKey(deviceName, sdkKey) + ↓ +实体被控设备产生正确响应 +``` + +## 3. 范围 + +### 3.1 本阶段包含 + +- 红外功能的领域模型和本地持久化端口； +- Room 数据库、DAO 和 Repository； +- 学习、重试、发射、删除和恢复应用用例； +- 红外 ViewModel 和简单 Compose 页面； +- 登录成功页面的临时红外入口； +- 手动输入并记住一个 `irDevName`； +- 单红外控制器、多按键； +- Fake/Real ABSDK 显式调试模式； +- 自动化测试； +- 真机验收清单； +- 面向未来生活场景的稳定按键引用。 + +### 3.2 本阶段不包含 + +- 最终 UI 视觉规范或复杂遥控器布局； +- 多个遥控器管理界面； +- ABSDK 不存在的设备扫描； +- 原始红外码读取或持久化； +- 红外码库导入 UI； +- 硬件停止学习； +- 完整生活场景模型、规则引擎或场景执行器； +- Release 中默认启用真实 ABSDK； +- 绕过或隐藏厂商明文 HTTP 风险； +- 删除 ABox 服务端已学习按键。 + +## 4. 架构 + +采用独立应用编排层，保持现有 `InfraredGateway` 作为纯硬件能力端口： + +```text +登录成功页面 + └─ 临时入口：红外控制 + ↓ +InfraredControlScreen + ↓ +InfraredControlViewModel + ↓ +应用用例 + ├─ LearnInfraredKey + ├─ RetryInfraredKeyLearning + ├─ SendInfraredKey + ├─ DeleteInfraredKey + ├─ RecoverInterruptedInfraredLearning + └─ ObserveInfraredKeys + ↙ ↘ +InfraredKeyRepository InfraredGateway + ↓ ├─ FakeInfraredGateway +RoomInfraredKeyRepository └─ AbsdkBridge + ↓ + ABSDK 0630 +``` + +### 4.1 边界原则 + +- `InfraredGateway` 只负责学习、发射和码库下载，不负责 Room、页面状态或遥控器管理； +- 不修改 `learnKey()` 返回类型，不虚构 ABSDK 原始码结果； +- 不把 `ABSDK`、`ABRet`、`IrInfo` 或原始 Map 暴露给上层； +- ViewModel 不直接编排数据库和硬件之间的一致性，统一通过应用用例； +- Room Entity 不作为领域或 UI 公共模型； +- Fake 和真实 Bridge 必须共用相同的领域接口和用例； +- 所有真实 Gateway 接口必须指向同一个进程级 `AbsdkBridge` 实例，保持全局会话和互斥锁一致。 + +## 5. 数据模型 + +### 5.1 稳定标识 + +```kotlin +@JvmInline +value class InfraredKeyId(val value: String) + +data class InfraredKeyRef( + val profileId: ProviderProfileId, + val keyId: InfraredKeyId, +) +``` + +`InfraredKeyRef` 是未来生活场景使用的最小稳定引用。场景不应保存显示名、设备名或厂商 Key。 + +### 5.2 学习状态 + +```kotlin +enum class InfraredKeyStatus { + LEARNING, + READY, + FAILED, +} +``` + +状态表示 App 对最近一次学习调用结果的本地记录，不代表设备主动上报的实时状态。 + +### 5.3 领域模型 + +```kotlin +data class SavedInfraredKey( + val id: InfraredKeyId, + val profileId: ProviderProfileId, + val deviceName: DeviceName, + val displayName: String, + val sdkKey: String, + val status: InfraredKeyStatus, + val lastErrorCode: String?, + val createdAtEpochMillis: Long, + val updatedAtEpochMillis: Long, +) +``` + +字段约束： + +- `id` 在 App 内稳定，供页面、删除和未来生活场景引用； +- `profileId` 用于不同登录配置的数据隔离； +- `deviceName` 是传给 ABSDK 的真实红外设备名； +- `displayName` 是用户可见名称，可以修改； +- `sdkKey` 是传给 ABSDK 的稳定 Key，学习后不随显示名改变； +- `lastErrorCode` 仅保存脱敏厂商错误码，不保存密码、Token、原始 Map 或红外载荷； +- 时间字段由应用层时钟提供，测试中使用可控时钟。 + +### 5.4 SDK Key + +App 自动生成 SDK Key，不允许用户直接编辑。格式应： + +- 仅包含安全 ASCII 字符； +- 在同一 Provider 和红外设备下唯一； +- 重试学习时复用； +- 修改显示名时保持不变； +- 不直接使用中文、空格或特殊字符。 + +建议格式： + +```text +app_ir_ +``` + +实际长度上限尚未由 ABSDK 文档确认，实现前需选择保守长度，并列入真机验证。 + +## 6. 本地持久化 + +采用 Room。Repository 边界至少支持： + +```kotlin +interface InfraredKeyRepository { + fun observeKeys( + profileId: ProviderProfileId, + deviceName: DeviceName, + ): Flow>> + + suspend fun getKey( + ref: InfraredKeyRef, + ): DomainResult + + suspend fun insertLearningKey( + key: SavedInfraredKey, + ): DomainResult + + suspend fun updateStatus( + ref: InfraredKeyRef, + status: InfraredKeyStatus, + lastErrorCode: String?, + updatedAtEpochMillis: Long, + ): DomainResult + + suspend fun renameKey( + ref: InfraredKeyRef, + displayName: String, + updatedAtEpochMillis: Long, + ): DomainResult + + suspend fun deleteKey( + ref: InfraredKeyRef, + ): DomainResult + + suspend fun findInterruptedLearning( + profileId: ProviderProfileId, + ): DomainResult> +} +``` + +具体签名可在实施计划中按项目既有风格调整，但必须保持职责和语义。 + +### 6.1 数据库约束 + +- 主键：`InfraredKeyId`； +- 索引：`ProviderProfileId + DeviceName`； +- 唯一约束：`ProviderProfileId + DeviceName + sdkKey`； +- 查询和删除必须包含 Provider 隔离； +- 不保存原始红外码； +- 不把 Room Entity 暴露给领域层； +- 首版预留 schema version 和迁移测试基础。 + +### 6.2 单设备策略 + +页面记住一个当前 `irDevName`，并只展示该设备下的按键。切换当前设备名不会迁移或重写旧按键；旧按键仍绑定学习时使用的设备名。 + +设备名可以保存到 Room 配置表或 DataStore。若采用 DataStore，只用于当前设备名和 debug 模式等轻量配置，不承载红外按键集合。 + +## 7. 学习流程 + +`LearnInfraredKey` 的流程： + +1. 验证用户已登录且存在有效 `ProviderProfileId`； +2. 验证 `deviceName` 和 `displayName` 非空； +3. 生成稳定 `InfraredKeyId` 和 `sdkKey`； +4. 先写入状态为 `LEARNING` 的记录； +5. 在应用级协程作用域调用 `InfraredGateway.learnKey()`； +6. 成功时更新为 `READY` 并清空错误码； +7. 失败时更新为 `FAILED` 并保存脱敏错误码； +8. 如果状态更新失败，记录可恢复的本地数据错误，但不重新生成 SDK Key； +9. 页面通过 Room Flow 观察最终状态。 + +### 7.1 重试 + +重试必须： + +- 使用原 `InfraredKeyId`； +- 使用原 `sdkKey`； +- 先将状态更新为 `LEARNING`； +- 再调用 ABSDK； +- 不创建重复按键记录。 + +### 7.2 页面离开 + +学习调用开始后，页面可以退出。任务继续在应用级作用域等待 SDK 返回，并更新 Room。ViewModel 销毁不应直接取消已经提交的学习编排。 + +这不是后台系统任务保证：如果进程被系统杀死，底层同步网络请求及设备状态无法可靠恢复。 + +### 7.3 进程恢复 + +App 启动或登录恢复后，查找遗留的 `LEARNING` 记录： + +```text +LEARNING → FAILED +错误提示：上次学习结果未确认，请重新学习 +``` + +不得自动标记为 `READY`，也不得自动发射来试探设备状态。 + +### 7.4 取消语义 + +ABSDK 没有停止学习 API。首版 UI 不提供或宣称“停止硬件学习”。用户可以离开页面，但学习调用仍等待成功、失败或 SDK 超时。 + +## 8. 发射流程 + +`SendInfraredKey` 的流程： + +1. 使用 `InfraredKeyRef` 查询本地记录； +2. 记录不存在时返回领域错误； +3. 仅允许 `READY` 状态发射； +4. 取得记录中的 `profileId + deviceName + sdkKey`； +5. 调用 `InfraredGateway.sendKey()`； +6. 成功时向 UI 返回一次性成功事件； +7. 失败时保留按键 `READY` 状态，仅报告本次错误； +8. 不自动重试，避免重复操作电视、空调等实体设备。 + +未来生活场景通过稳定 `InfraredKeyRef` 调用同一发送用例或薄执行器： + +```kotlin +interface InfraredActionExecutor { + suspend fun execute(ref: InfraredKeyRef): DomainResult +} +``` + +本阶段只定义或保证稳定引用边界，不实现 Scene 模型、规则引擎或场景执行顺序。 + +## 9. 删除与重命名 + +### 9.1 删除 + +- `FAILED` 和 `READY` 记录可以删除； +- `LEARNING` 中不允许删除，避免后台结果写入已不存在的记录； +- 删除只移除本地引用； +- ABSDK 没有删除服务端红外 Key 的公开接口； +- UI 必须提示“ABox 服务端可能仍保留该按键”； +- 删除后未来场景引用解析失败，不再发射。 + +### 9.2 重命名 + +- 只修改 `displayName`； +- 不修改 `id`、`deviceName` 或 `sdkKey`； +- 重命名后学习和发射能力保持不变； +- 场景引用保持有效。 + +## 10. Android 前端 + +### 10.1 临时入口 + +在当前登录成功后的页面添加“红外控制”按钮，导航到独立 `InfraredControlScreen`。未来正式信息架构完成后只迁移入口。 + +### 10.2 页面内容 + +首版页面只包含： + +- 返回按钮和标题； +- 当前数据源标识：Fake 或真实 ABox； +- 红外控制器设备名输入和保存； +- 已学习按键列表； +- 学习新按键按钮； +- 按键状态； +- READY 按键的发射按钮； +- FAILED 按键的重试按钮； +- 删除入口和确认提示； +- 基础错误反馈。 + +不加入复杂遥控器模板、图标系统、网格布局、品牌色或动画规范。 + +### 10.3 设备名 + +- ABSDK 没有设备扫描能力； +- 首次进入时手动填写 `irDevName`； +- 保存后本地记住； +- 没有设备名时禁止学习； +- 修改设备名前提示旧按键仍绑定旧设备； +- 列表只显示当前设备名下的按键。 + +### 10.4 学习交互 + +用户输入显示名称后开始学习。页面提示： + +```text +请将实体遥控器对准红外控制器并按下目标按键。 +``` + +按键显示 `LEARNING`、`READY` 或 `FAILED`。允许离开页面，但不显示“停止硬件学习”。 + +### 10.5 发射交互 + +- 只有 `READY` 按键可发射； +- 发射期间禁用该按键，防止重复点击； +- 成功显示短暂提示； +- 失败显示具体错误； +- 不自动重试； +- 单次失败不删除或降级按键状态。 + +### 10.6 删除提示 + +删除确认文案应明确： + +```text +仅从本机列表移除，ABox 服务端可能仍保留该按键。 +``` + +## 11. Debug Fake/Real 路由 + +Debug 构建提供显式运行模式： + +- `FAKE`：页面开发、自动化测试和错误模拟； +- `REAL_ABSDK`：复用当前登录会话，调用真实 `AbsdkBridge`。 + +约束： + +- 页面持续显示当前模式； +- 不允许在学习任务进行中切换模式； +- Fake 和 Real 共用同一 ViewModel、应用用例和 Room Repository； +- 模式和 Provider 数据必须隔离，避免 Fake 按键误用于真实设备； +- Fake 支持按 `ProviderProfileId + DeviceName + sdkKey` 配置成功或失败； +- 真实模式的所有 Gateway 接口绑定同一 `AbsdkBridge` 单例； +- 真实模式必须显式 opt in `CleartextAbsdkTransport`； +- Release 暂不启用真实 Bridge，除非项目明确批准传输安全方案。 + +真实 App 接入还必须补齐： + +- `:absdk-bridge` 依赖； +- Hilt 绑定； +- `INTERNET` 权限； +- 经批准的明文网络配置； +- 登录会话与红外 Gateway 的同一 Bridge 实例； +- Token 失效后的页面返回登录流程。 + +## 12. 错误处理 + +继续使用现有 `DomainResult` 和 `DomainError`。不为首版扩充 sealed 类型，优先利用已有分类和 `externalCode`。 + +| 情况 | UI 反馈 | 本地状态 | +|---|---|---| +| Token 无效 | 登录已失效，返回登录 | 学习按键为 FAILED；发射按键仍为 READY | +| 红外设备不存在 | 检查设备名 | 学习按键为 FAILED | +| 红外设备离线 | 检查供电和网络 | 学习按键为 FAILED；发射按键仍为 READY | +| KEY/码值不存在 | 建议重新学习 | 发射按键仍为 READY，由用户决定重学 | +| 红外发射失败 | 显示失败，可手动重试 | READY | +| 网络超时 | 网络或 ABox 服务不可用 | 学习按键为 FAILED；发射按键仍为 READY | +| 本地保存失败 | 无法开始学习 | 不调用硬件学习 | +| 学习成功但最终状态写入失败 | 显示数据保存异常并保留恢复信息 | 不生成新 sdkKey | +| 未知错误 | 通用提示及脱敏错误码 | 按操作类型处理 | + +日志不得包含： + +- 用户密码； +- Token； +- 原始 SDK Map； +- 原始红外码或载荷； +- 可用于重放的敏感字段。 + +## 13. 自动化测试 + +### 13.1 应用用例 + +覆盖： + +1. 学习前先保存 `LEARNING`； +2. 学习成功更新为 `READY`； +3. 学习失败更新为 `FAILED`； +4. 重试复用原 `sdkKey`； +5. 修改显示名不改变 `sdkKey`； +6. 只有 `READY` 可以发射； +7. 发射使用保存的 `deviceName + sdkKey`； +8. 不同 Provider 数据隔离； +9. 遗留 `LEARNING` 恢复为 `FAILED`； +10. 删除后稳定引用失效； +11. ViewModel 销毁后应用级学习任务仍可落库； +12. 发射失败不改变 READY； +13. 进行中的学习阻止运行模式切换。 + +### 13.2 Room + +覆盖： + +- 新增、观察、查询、重命名和删除； +- `ProviderProfileId + DeviceName` 过滤； +- `sdkKey` 唯一约束； +- Provider 隔离； +- 状态转换； +- 稳定 ID 跨重命名不变； +- 首版 schema 和迁移测试基础； +- 不存储原始红外载荷。 + +### 13.3 Fake + +扩展现有 Fake，覆盖： + +- 按 Provider、设备和 Key 脚本化结果； +- 调用参数与顺序； +- 连续响应； +- 成功、离线、超时和通用失败； +- 不同 Provider 互不影响。 + +### 13.4 Bridge + +保留现有覆盖并补充： + +- 学习参数和调用顺序； +- 发射参数和调用顺序； +- 红外错误码 `20201` 至 `20206` 的映射； +- 学习、发射与其他设备调用的全局串行； +- Token 失效清理会话； +- SDK 空值和异常防御； +- 不改变 `downloadCodes()` 的部分成功语义。 + +### 13.5 ViewModel 与 Compose + +只验证功能，不验证最终视觉： + +- 无设备名不能学习； +- 保存和恢复设备名； +- 创建学习任务； +- 显示学习中、成功和失败； +- 重试学习； +- 点击发射并防重复点击； +- 删除确认； +- Fake/Real 模式标识； +- 登录失效引导； +- 基本中文和英文资源。 + +## 14. 真机验收 + +第一轮使用现有 ABox 主机和红外控制器： + +1. 登录真实账号； +2. 输入后台提供的准确 `irDevName`； +3. 创建唯一按键，例如“测试电源”； +4. 调用学习并记录耗时、返回码和消息； +5. 学习成功后立即发射； +6. 验证实体电器是否响应； +7. 用同一按键重复发射； +8. 重新学习同一 `sdkKey`，验证覆盖或报错行为； +9. 红外控制器断电后验证离线错误； +10. 不按实体遥控器，验证实际超时行为； +11. 页面退出后验证后台结果落库； +12. 进程被杀后验证遗留 LEARNING 恢复； +13. Token 失效后验证返回登录； +14. 记录 SDK 是否存在未文档化 `dicDatas`，但不将内容写入生产日志。 + +### 14.1 必须验证的未知项 + +- 学习调用是立即返回还是阻塞到捕获完成； +- 学习成功是否自动绑定 `sdkKey`； +- 同一 `sdkKey` 重学是否覆盖； +- 无信号时实际超时时间； +- 页面离开后底层调用是否可完成； +- 设备名格式、大小写和特殊字符规则； +- 服务端是否永久保留已学习 Key； +- SDK 是否返回未文档化数据； +- `sdkKey` 的长度限制； +- 真实模式所需初始化信息和调用顺序。 + +这些未知项不得通过业务层假设隐藏。真机结果应更新协议文档和后续设计。 + +## 15. 验收标准 + +本阶段完成需要满足： + +- 登录成功页面可以进入简单红外页面； +- 可以手动配置并恢复一个红外设备名； +- 可以创建多个命名按键； +- 学习调用前已持久化 LEARNING； +- 学习成功或失败能正确落库； +- READY 按键可以调用发射； +- 显示名修改不影响发射； +- Fake 模式可以覆盖主要状态和错误； +- Real 模式明确标识并调用真实 Bridge； +- 页面退出后学习任务仍可更新状态； +- 进程中断后遗留学习状态可以保守恢复； +- 自动化测试通过； +- 真机至少完成一次“学习成功 → 发射 → 实体响应”； +- 未确认硬件语义被记录，不伪装为已支持； +- 未来生活场景可以通过稳定 `InfraredKeyRef` 引用按键。 + +## 16. 后续工作 + +本设计完成后再分别规划： + +1. 多遥控器和房间组织； +2. 统一产品视觉和正式导航入口； +3. 红外码库导入； +4. 生活场景编排； +5. Scene 顺序执行和单项结果； +6. 厂商明文 HTTP 的正式安全方案； +7. 真机验证后对学习语义、超时和错误模型的修订。 diff --git a/docs/superpowers/specs/2026-08-24-infrared-remote-ui-design.md b/docs/superpowers/specs/2026-08-24-infrared-remote-ui-design.md new file mode 100644 index 0000000..35608ce --- /dev/null +++ b/docs/superpowers/specs/2026-08-24-infrared-remote-ui-design.md @@ -0,0 +1,115 @@ +# 红外遥控器界面与多场景控制设计规范 / Infrared Remote Control UI Specification + +## 1. 背景与目标 (Background & Goals) + +在完成了底层红外学习、发射、Room 数据库、1~100 整数 Key 槽位管理以及 Fake/Real ABSDK 路由的基础上，本项目需要提供专业且直观的前端遥控器人机交互界面。 + +### 核心目标 +1. **多场景遥控面板**：提供空调 (Air Conditioner) 与电视 (Television) 两大经典场景遥控器界面，使用圆形、圆角矩形、胶囊、圆形方向盘等拟物/现代图形组件构建真实遥控器外观。 +2. **学习模式与控制模式切换**：右上角提供“红外学习模式”开关，在控制模式下点击按键发射红外，在学习模式下点击按键录制红外。 +3. **固定槽位绑定 (Fixed Slot Binding)**：遥控器上的每一个功能按键具有预设唯一的 1~100 整数槽位编号（例如空调电源为 Slot 1，电视电源为 Slot 21）。 +4. **简洁的符号化设计**：遥控器按键表面只展示标准图标与简写符号（⏻, +, -, ∧, ∨, ❄, 🔊 等），不展示底层数据库中文长名称。 +5. **设置页面解耦与导航**：原“红外控制页面”定位为“红外学习设置页面”（Infrared Settings），通过遥控器右上角设置图标 ⚙️ 进入，用于配置红外设备名和管理全部已学按键列表。 + +--- + +## 2. 槽位与按键分配定义 (Slot & Button Mapping) + +每个按键定义为一个 `RemoteButtonSpec`，包含按键唯一标识 `id`、对应默认槽位 `defaultSlot`、默认显示名称 `displayName`、图标及在遥控器面板中的图形位置。 + +### 2.1 空调遥控器 (Air Conditioner: Slots 1–20) +| 按键 ID | 功能/符号 | 槽位 (irKey) | 默认名称 | UI 形态 | +|---|---|---|---|---| +| `AC_POWER` | 电源 ⏻ | `1` | `空调-电源` | 顶部圆形独立红色高亮按键 | +| `AC_TEMP_UP` | 温度+ 🔼 | `2` | `空调-温度+` | 垂直胶囊上半部分 | +| `AC_TEMP_DOWN` | 温度- 🔽 | `3` | `空调-温度-` | 垂直胶囊下半部分 | +| `AC_MODE` | 模式 ❄/☀ | `4` | `空调-模式` | 圆角矩形 | +| `AC_FAN` | 风速 💨 | `5` | `空调-风速` | 圆角矩形 | +| `AC_SWING` | 扫风 ↔️ | `6` | `空调-扫风` | 圆角矩形 | +| `AC_TIMER` | 定时 ⏱️ | `7` | `空调-定时` | 圆角矩形 | + +### 2.2 电视遥控器 (Television: Slots 21–50) +| 按键 ID | 功能/符号 | 槽位 (irKey) | 默认名称 | UI 形态 | +|---|---|---|---|---| +| `TV_POWER` | 电源 ⏻ | `21` | `电视-电源` | 顶部圆形红色按键 | +| `TV_MUTE` | 静音 🔇 | `22` | `电视-静音` | 顶部圆形灰色按键 | +| `TV_NAV_UP` | 方向上 🔼 | `23` | `电视-上` | 方向环形盘上弧段 | +| `TV_NAV_DOWN` | 方向下 🔽 | `24` | `电视-下` | 方向环形盘下弧段 | +| `TV_NAV_LEFT` | 方向左 ◀️ | `25` | `电视-左` | 方向环形盘左弧段 | +| `TV_NAV_RIGHT` | 方向右 ▶️ | `26` | `电视-右` | 方向环形盘右弧段 | +| `TV_OK` | 确认 🆗 | `27` | `电视-确定` | 方向盘中心圆形 | +| `TV_VOL_UP` | 音量+ 🔊+ | `28` | `电视-音量+` | 垂直胶囊上半部分 | +| `TV_VOL_DOWN` | 音量- 🔉- | `29` | `电视-音量-` | 垂直胶囊下半部分 | +| `TV_CH_UP` | 频道+ 📺+ | `30` | `电视-频道+` | 垂直胶囊上半部分 | +| `TV_CH_DOWN` | 频道- 📺- | `31` | `电视-频道-` | 垂直胶囊下半部分 | +| `TV_HOME` | 主页 🏠 | `32` | `电视-主页` | 中部圆角胶囊按键 | +| `TV_BACK` | 返回 ↩️ | `33` | `电视-返回` | 中部圆角胶囊按键 | +| `TV_MENU` | 菜单 ☰ | `34` | `电视-菜单` | 中部圆角胶囊按键 | + +--- + +## 3. 架构与组件设计 (Architecture & Component Design) + +### 3.1 导航结构 +```text +FoundationScreen (首页/网关登录) + ↓ 点击 "红外控制" (infrared/{profileId}) +InfraredRemoteScreen (遥控器主界面，默认空调/电视) + ├─ 学习模式开关 (Toggle: Learning Mode) + ├─ 场景切换器 (Tab: ❄️ 空调 | 📺 电视) + ├─ 空调遥控器面板 (AcRemotePanel) + ├─ 电视遥控器面板 (TvRemotePanel) + └─ 点击右上角 ⚙️ 设置图标 + ↓ (infrared_settings/{profileId}) + InfraredSettingsScreen (原红外设置/按键管理列表页面) +``` + +### 3.2 状态管理 (`InfraredRemoteViewModel` & `InfraredRemoteUiState`) +- `InfraredRemoteUiState`: + - `selectedScene`: `RemoteScene.AIR_CONDITIONER` 或 `RemoteScene.TELEVISION` + - `isLearningMode`: `Boolean`（是否处于学习录制模式） + - `activeLearningKeySlot`: `String?`（当前正在进行学习请求的按键槽位） + - `sendingKeySlot`: `String?`（当前正在发射信号的按键槽位） + - `learnedSlots`: `Map`（已在 Room 数据库中记录为 READY 的槽位映射） + - `savedDeviceName`: `DeviceName?`（当前配置的红外设备名，如 `红外控制器`） + - `runtimeMode`: `InfraredRuntimeMode`（Fake 或 Real ABSDK） + - `message`: `UiMessage?`（提示信息或错误） + +--- + +## 4. 交互与视觉规范 (Interaction & Visuals) + +### 4.1 视觉造型 +1. **遥控器本体外壳 (Remote Body Chassis)**： + - 居中放置的圆角卡片，具有微阴影、圆角半径 `28.dp`、外框及哑光质感。 +2. **空调 LCD 虚拟屏**： + - 顶部黑色圆角框，内部呈现液晶感绿色/白色字样（如当前目标温度 `26°C` 与工作状态）。 +3. **垂直双向胶囊摇杆 (Vertical Capsule Rockers)**： + - 上半区与下半区独立响应点击，中间由细微分割线隔开，常用于“温度 +/-”、“音量 +/-”及“频道 +/-”。 +4. **圆形导航方向盘 (D-Pad Wheel)**： + - 直径约 `180.dp` 的圆形组合组件，外环包含 4 个扇区方向按键，内嵌独立的圆形 OK 键。 + +### 4.2 按键状态机反馈 +1. **控制模式 (学习开关 OFF)**： + - **已录制 (READY)**：按键实体呈现饱满质感，点击触发波纹反馈，调用 `sendKey` 发射红外，提示“已发射”。 + - **未录制 (UNLEARNED)**：按键显示浅色未激活状态；点击弹出轻量提示：`“按键尚未学习，请打开右上角学习模式”`。 +2. **学习录制模式 (学习开关 ON)**： + - 顶部呈现橙色高亮提示条：`“🔴 学习模式已开启：点击任意按键开始录制”`。 + - 所有按键进入可录制状态（带提示外框）。 + - 点击目标按键后： + - 按键上显示微型 Loading 光圈。 + - 调用 `learnKey(deviceName, defaultSlot, displayName)`。 + - 手机或控制器捕获红外信号成功后，按键变为 READY 并伴随成功提示。 + +--- + +## 5. 验证与测试标准 (Verification & Acceptance Criteria) + +1. **单元测试 (Unit Tests)**： + - `InfraredRemoteViewModelTest` 覆盖场景切换、学习模式开关、按键已学/未学状态映射、点击发射以及点击学习请求的转发。 +2. **UI 测试 (Compose Tests)**： + - 空调与电视遥控器按键正常渲染并带正确 Tag。 + - 学习模式切换后 UI 状态正确切换。 +3. **真机与编译验收**： + - 模块与 App 通过 JVM 测试与打包验证。 + - 手机上点击空调/电视按键能发起正确的 Slot 编号学习与发射。 diff --git a/docs/testing/infrared-hardware-validation.md b/docs/testing/infrared-hardware-validation.md new file mode 100644 index 0000000..2d541ce --- /dev/null +++ b/docs/testing/infrared-hardware-validation.md @@ -0,0 +1,85 @@ +# 红外控制硬件验证规范与记录 / Infrared Hardware Validation Guide & Records + +## 1. 硬件环境与已知设备信息 / Hardware Environment + +本阶段用于真实验证的实体设备信息如下： + +- **设备名称**: 红外控制器 (例如 `红外控制器` 或厂商平台绑定的 `irDevName`) +- **IEEE 地址**: `1c1cfd001dba533c` (短地址: `d822`) +- **信号强度 (LQI/RSSI)**: `-4` +- **电量**: `100%` +- **设备类型**: 红外控制器 (Infrared Controller) +- **网关/主机**: ABox 智能主机 +- **被控实体**: 实体空调 / 电视遥控器及对应电器 + +--- + +## 2. 硬件测试记录表 / Hardware Validation Log + +| 日期 (Date) | App Commit | 运行模式 (Mode) | Profile ID | 设备名称 (Device Name) | SDK Key | 操作 (Operation) | 耗时 (ms) | ABSDK Code | 脱敏消息 (Message) | 物理响应 (Physical Response) | 结论 (Result) | +|---|---|---|---|---|---|---|---|---|---|---|---| +| 2026-08-24 | b27c67f | FAKE | abox:infrared-fake | ir-living | app_ir_power1 | Learn | 120 | 00000 | success | 模拟学习完成并入库 READY | PASS (Fake) | +| 2026-08-24 | b27c67f | FAKE | abox:infrared-fake | ir-living | app_ir_power1 | Send | 45 | 00000 | success | 模拟发射成功 | PASS (Fake) | +| 2026-08-24 | 待填 | REAL_ABSDK | abox | 红外控制器 | app_ir_xxxx | Learn | - | - | - | 遥控器对准控制器按下目标按键 | 待真机执行 | +| 2026-08-24 | 待填 | REAL_ABSDK | abox | 红外控制器 | app_ir_xxxx | Send | - | - | - | 实体电器执行开关/调节响应 | 待真机执行 | + +--- + +## 3. 标准真机测试流程 (12 项用例) / Standard 12-Step Test Procedure + +### 用例 1: 真实会话认证前置 (Authenticate Shared Bridge) +- **前置**: 通过登录模块对进程单例 `AbsdkBridge` 进行登录认证。 +- **步骤**: 检查进入红外控制页面前，会话 Token 是否有效。 +- **预期**: 若未认证，进入 Real 模式操作时返回 `TokenInvalid` 并提示返回登录。 + +### 用例 2: 输入并保存真实设备名 (Enter and Save irDevName) +- **步骤**: 在“红外设备名称”输入框中输入 `红外控制器` 或后台分配的真实设备名，点击“保存设备名”。 +- **预期**: 本地 Room 保存成功，页面显示“已保存设备：红外控制器”，启用“学习新按键”入口。 + +### 用例 3: 学习全新唯一按键 (Learn Unique Key) +- **步骤**: 点击“学习新按键”，输入显示名称（如“空调开”），点击“开始学习”；将物理遥控器对准红外控制器按下按键。 +- **预期**: 本地先写入 `LEARNING` 状态，硬件捕获完成后状态自动刷新为 `READY`，记录响应耗时与返回码。 + +### 用例 4: 立即发射已学习按键 (Send Learned Key Immediately) +- **步骤**: 学习成功后，点击该按键右侧的“发射”按钮。 +- **预期**: ABSDK 返回 `00000`，实体电器执行对应操作，发射期间按钮防重复点击。 + +### 用例 5: 重复发射验证稳定性 (Repeat Send) +- **步骤**: 间隔 3 秒再次点击同一按键的“发射”按钮。 +- **预期**: 发射稳定成功，电器再次响应，按键保持 `READY` 状态不变。 + +### 用例 6: 重新学习同一 SDK Key (Relearn Same Key) +- **步骤**: 针对已存在或失败的按键点击“重试”/重新学习。 +- **预期**: 复用相同的 `InfraredKeyId` 和 `sdkKey`，先变更为 `LEARNING`，学习完成后恢复 `READY`，不生成冗余记录。 + +### 用例 7: 控制器断电/离线测试 (Controller Offline) +- **步骤**: 拔掉红外控制器电源，发起学习或发射。 +- **预期**: ABSDK 返回 `20206`，领域层转换为 `DomainError.DeviceOffline`，学习按键标为 `FAILED`，UI 提示控制器离线。 + +### 用例 8: 遥控器无信号/超时测试 (No Signal / Learning Timeout) +- **步骤**: 点击“开始学习”，但不按物理遥控器任何按键，等待 SDK 返回。 +- **预期**: 记录实际超时等待时间与错误码（如 `20204`/`20205`），按键转换为 `FAILED` 并允许重试。 + +### 用例 9: 学习过程中离开页面 (Leave Page During Learning) +- **步骤**: 点击开始学习后，立即点击“返回”离开红外页面；稍后重新进入。 +- **预期**: Application 协程作用域内任务继续执行，学习完成后 Room 数据库正确持久化结果，重新进入显示最新状态。 + +### 用例 10: 进程被杀死后状态恢复 (Process Interruption Recovery) +- **步骤**: 在 `LEARNING` 状态下强制杀死 App 进程并重启。 +- **预期**: App 启动或重新进入页面时，`RecoverInterruptedInfraredLearning` 将遗留的 `LEARNING` 保守恢复为 `FAILED`，提示用户重新学习。 + +### 用例 11: Token 失效与重新登录 (Token Expiration) +- **步骤**: 主机端使 Token 失效或超过 2 小时后发起红外操作。 +- **预期**: 返回 `TokenInvalid`，本地会话被清除，页面提示登录失效并导航返回。 + +### 用例 12: 检查未文档化响应字段 (Inspect Undocumented Fields) +- **步骤**: 在调试构建中检查 `ABRet.getDicDatas()` 是否包含未文档化字段。 +- **安全约束**: 严禁将 Raw Payload、Token、密码或未脱敏数据打印至生产日志。 + +--- + +## 4. 协议与硬件事实确认记录 / Observed Facts + +- **SDK 阻塞模式**: 同步阻塞 HTTP POST 调用，由 `AbsdkBridge` 调度至 `Dispatchers.IO` 并通过进程级 `Mutex` 串行执行。 +- **数据隔离**: `FAKE` 模式自动使用 `profileId:infrared-fake` 隔离数据，`REAL_ABSDK` 模式使用主会话数据。 +- **安全门禁**: 真实 ABSDK 依赖明文传输，Release 构建中完全禁用硬件接口并由 `InfraredReleaseModule` 安全阻断。 diff --git a/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/AcCodeGenerator.kt b/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/AcCodeGenerator.kt new file mode 100644 index 0000000..09ec03e --- /dev/null +++ b/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/AcCodeGenerator.kt @@ -0,0 +1,52 @@ +package com.flagship.abox.manager.domain.infrared + +object AcCodeGenerator { + + /** + * Generates a standard protocol Hex string for an Air Conditioner state. + * Uses Gree/Generic standard 64-bit frame: + * Byte 0: Mode (3 bits) | Power (1 bit) | Fan Speed (2 bits) | Swing (2 bits) + * Byte 1: Temperature (4 bits: temp - 16) | Timer (4 bits) + * Byte 2: Auxiliary options (Eco, Turbo, Health, Light) + * Byte 3: Checksum + */ + fun generateHex(state: AcStateSnapshot, brand: String? = null): String { + val modeBits = when (state.mode) { + AcMode.AUTO -> 0b000 + AcMode.COOL -> 0b001 + AcMode.DRY -> 0b010 + AcMode.FAN -> 0b011 + AcMode.HEAT -> 0b100 + } + val powerBit = if (state.power) 0b1 else 0b0 + val fanBits = when (state.fanSpeed) { + AcFanSpeed.AUTO -> 0b00 + AcFanSpeed.LOW -> 0b01 + AcFanSpeed.MEDIUM -> 0b10 + AcFanSpeed.HIGH -> 0b11 + } + val swingBits = (if (state.verticalSwing) 0b01 else 0b00) or (if (state.horizontalSwing) 0b10 else 0b00) + + val byte0 = ((modeBits and 0x07) shl 5) or + ((powerBit and 0x01) shl 4) or + ((fanBits and 0x03) shl 2) or + (swingBits and 0x03) + + val clampedTemp = state.temperature.coerceIn(16, 30) + val tempBits = (clampedTemp - 16) and 0x0F + val byte1 = (tempBits shl 4) and 0xF0 + + val ecoBit = if (state.eco) 0b1 else 0b0 + val byte2 = (ecoBit and 0x01) shl 7 + + val checksum = (byte0 + byte1 + byte2) and 0xFF + + return buildString { + append("0x") + append(String.format("%02X", byte0)) + append(String.format("%02X", byte1)) + append(String.format("%02X", byte2)) + append(String.format("%02X", checksum)) + } + } +} diff --git a/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/AddVirtualRemoteKey.kt b/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/AddVirtualRemoteKey.kt new file mode 100644 index 0000000..26cb835 --- /dev/null +++ b/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/AddVirtualRemoteKey.kt @@ -0,0 +1,53 @@ +package com.flagship.abox.manager.domain.infrared + +import com.flagship.abox.manager.domain.DomainError +import com.flagship.abox.manager.domain.DomainResult +import com.flagship.abox.manager.domain.ProviderProfileId +import java.util.UUID + +class AddVirtualRemoteKey( + private val repository: VirtualRemoteRepository, +) { + suspend operator fun invoke( + profileId: ProviderProfileId, + remoteId: VirtualRemoteId, + displayName: String, + ): DomainResult { + val trimmed = displayName.trim() + if (trimmed.isBlank()) { + return DomainResult.Failure(DomainError.InvalidRequest(detail = "Button name cannot be blank")) + } + val remote = when (val res = repository.getRemote(profileId, remoteId)) { + is DomainResult.Success -> res.value ?: return DomainResult.Failure(DomainError.NoData(detail = "Remote not found")) + is DomainResult.Failure -> return res + } + + val buttonId = "CUSTOM_" + UUID.randomUUID().toString().take(8).uppercase() + val assignedSlot = if (remote.transmissionMode == TransmissionMode.STATIC_SLOTS) { + // Find next available slot + val bindings = (repository.getKeyBindings(remoteId) as? DomainResult.Success)?.value.orEmpty() + val usedSlots = bindings.mapNotNull { it.assignedSlot?.toIntOrNull() }.toSet() + val nextSlot = (1..99).firstOrNull { it !in usedSlots } + ?: return DomainResult.Failure(DomainError.InvalidRequest(detail = "槽位配额已满，无法分配静态槽位")) + nextSlot.toString() + } else null + + val binding = RemoteKeyBinding( + id = UUID.randomUUID().toString(), + remoteId = remoteId, + profileId = profileId, + buttonId = buttonId, + displayName = trimmed, + assignedSlot = assignedSlot, + rawHexCode = null, + status = InfraredKeyStatus.FAILED, // Initially unlearned + ) + + when (val res = repository.updateKeyBinding(binding)) { + is DomainResult.Failure -> return res + is DomainResult.Success -> Unit + } + + return DomainResult.Success(binding) + } +} diff --git a/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/CreateVirtualRemote.kt b/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/CreateVirtualRemote.kt new file mode 100644 index 0000000..cc2f747 --- /dev/null +++ b/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/CreateVirtualRemote.kt @@ -0,0 +1,110 @@ +package com.flagship.abox.manager.domain.infrared + +import com.flagship.abox.manager.domain.DeviceName +import com.flagship.abox.manager.domain.DomainError +import com.flagship.abox.manager.domain.DomainResult +import com.flagship.abox.manager.domain.InfraredCode +import com.flagship.abox.manager.domain.InfraredGateway +import com.flagship.abox.manager.domain.ProviderProfileId +import java.util.UUID + +class CreateVirtualRemote( + private val repository: VirtualRemoteRepository, + private val gateway: InfraredGateway, + private val clock: EpochMillisClock, +) { + suspend operator fun invoke( + profileId: ProviderProfileId, + deviceName: DeviceName, + displayName: String, + type: RemoteDeviceType, + brandModel: String? = null, + transmissionMode: TransmissionMode = if (type == RemoteDeviceType.CUSTOM) TransmissionMode.STATIC_SLOTS else TransmissionMode.DYNAMIC_SCRATCH, + layoutStyle: PanelLayoutStyle? = null, + ): DomainResult { + val trimmedName = displayName.trim() + if (trimmedName.isBlank()) { + return DomainResult.Failure( + DomainError.InvalidRequest(detail = "Remote display name cannot be blank"), + ) + } + + val resolvedLayout = layoutStyle ?: VirtualRemote.defaultLayoutFor(type) + val resolvedTransMode = if (type == RemoteDeviceType.CUSTOM) { + TransmissionMode.STATIC_SLOTS + } else { + transmissionMode + } + + val templates = PresetCodeLibrary.getTemplatesForType(type, brandModel, resolvedLayout) + val remoteId = VirtualRemoteId(UUID.randomUUID().toString().replace("-", "").take(16)) + val now = clock.now() + + val initialAcState = if (type == RemoteDeviceType.AIR_CONDITIONER) AcStateSnapshot() else null + + val remote = VirtualRemote( + id = remoteId, + profileId = profileId, + deviceName = deviceName, + displayName = trimmedName, + type = type, + brandModel = brandModel, + layoutStyle = resolvedLayout, + transmissionMode = resolvedTransMode, + dynamicScratchSlot = VirtualRemote.DEFAULT_DYNAMIC_SCRATCH_SLOT, + acState = initialAcState, + createdAtEpochMillis = now, + updatedAtEpochMillis = now, + ) + + // Build key bindings + val bindings = if (resolvedTransMode == TransmissionMode.STATIC_SLOTS) { + templates.mapIndexed { index, template -> + RemoteKeyBinding( + id = UUID.randomUUID().toString(), + remoteId = remoteId, + profileId = profileId, + buttonId = template.buttonId, + displayName = template.displayName, + assignedSlot = (index + 1).toString(), + rawHexCode = template.defaultHexCode, + status = if (template.defaultHexCode != null) InfraredKeyStatus.READY else InfraredKeyStatus.FAILED, + ) + } + } else { + templates.map { template -> + RemoteKeyBinding( + id = UUID.randomUUID().toString(), + remoteId = remoteId, + profileId = profileId, + buttonId = template.buttonId, + displayName = template.displayName, + assignedSlot = null, + rawHexCode = template.defaultHexCode, + status = if (template.defaultHexCode != null || type == RemoteDeviceType.AIR_CONDITIONER) { + InfraredKeyStatus.READY + } else { + InfraredKeyStatus.FAILED + }, + ) + } + } + + // If static and has default hex codes, download to hardware slots + if (resolvedTransMode == TransmissionMode.STATIC_SLOTS) { + val codesToDownload = bindings.mapNotNull { b -> + if (b.assignedSlot != null && b.rawHexCode != null) { + InfraredCode(deviceName, b.assignedSlot, b.rawHexCode) + } else null + } + if (codesToDownload.isNotEmpty()) { + when (val dlResult = gateway.downloadCodes(profileId, codesToDownload)) { + is DomainResult.Failure -> return dlResult + is DomainResult.Success -> Unit + } + } + } + + return repository.createRemote(remote, bindings) + } +} diff --git a/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/DeleteVirtualRemote.kt b/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/DeleteVirtualRemote.kt new file mode 100644 index 0000000..c9ad649 --- /dev/null +++ b/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/DeleteVirtualRemote.kt @@ -0,0 +1,13 @@ +package com.flagship.abox.manager.domain.infrared + +import com.flagship.abox.manager.domain.DomainResult +import com.flagship.abox.manager.domain.ProviderProfileId + +class DeleteVirtualRemote( + private val repository: VirtualRemoteRepository, +) { + suspend operator fun invoke( + profileId: ProviderProfileId, + remoteId: VirtualRemoteId, + ): DomainResult = repository.deleteRemote(profileId, remoteId) +} diff --git a/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/DeleteVirtualRemoteKey.kt b/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/DeleteVirtualRemoteKey.kt new file mode 100644 index 0000000..5ed2dc0 --- /dev/null +++ b/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/DeleteVirtualRemoteKey.kt @@ -0,0 +1,14 @@ +package com.flagship.abox.manager.domain.infrared + +import com.flagship.abox.manager.domain.DomainResult +import com.flagship.abox.manager.domain.ProviderProfileId + +class DeleteVirtualRemoteKey( + private val repository: VirtualRemoteRepository, +) { + suspend operator fun invoke( + profileId: ProviderProfileId, + remoteId: VirtualRemoteId, + buttonId: String, + ): DomainResult = repository.deleteKeyBinding(remoteId, buttonId) +} diff --git a/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/InfraredKeyFactory.kt b/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/InfraredKeyFactory.kt new file mode 100644 index 0000000..c83bd96 --- /dev/null +++ b/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/InfraredKeyFactory.kt @@ -0,0 +1,86 @@ +package com.flagship.abox.manager.domain.infrared + +import com.flagship.abox.manager.domain.DeviceName +import com.flagship.abox.manager.domain.DomainError +import com.flagship.abox.manager.domain.DomainResult +import com.flagship.abox.manager.domain.ProviderProfileId + +fun interface InfraredKeyIdGenerator { + fun nextId(): InfraredKeyId +} + +fun interface EpochMillisClock { + fun now(): Long +} + +class InfraredKeyFactory( + private val idGenerator: InfraredKeyIdGenerator, + private val clock: EpochMillisClock, +) { + fun create( + profileId: ProviderProfileId, + deviceName: DeviceName, + displayName: String, + sdkKey: String? = null, + ): DomainResult { + val normalizedName = displayName.trim() + if ( + profileId.value.isBlank() || + profileId.value != profileId.value.trim() || + deviceName.value.isBlank() || + deviceName.value != deviceName.value.trim() || + normalizedName.isBlank() + ) { + return DomainResult.Failure( + DomainError.InvalidRequest(detail = "Profile, device name, and display name are required"), + ) + } + val id = idGenerator.nextId() + val canonicalId = canonicalizeId(id.value) + ?: return DomainResult.Failure( + DomainError.InvalidRequest(detail = "Infrared key id is invalid"), + ) + + val finalSdkKey = if (sdkKey != null) { + val trimmed = sdkKey.trim() + val intVal = trimmed.toIntOrNull() + if (intVal == null || intVal !in 1..100) { + return DomainResult.Failure( + DomainError.InvalidRequest(detail = "Infrared key slot must be an integer between 1 and 100"), + ) + } + intVal.toString() + } else { + "app_ir_$canonicalId" + } + + val now = clock.now() + return DomainResult.Success( + SavedInfraredKey( + id = id, + profileId = profileId, + deviceName = deviceName, + displayName = normalizedName, + sdkKey = finalSdkKey, + status = InfraredKeyStatus.LEARNING, + lastErrorCode = null, + lastErrorDetail = null, + createdAtEpochMillis = now, + updatedAtEpochMillis = now, + ), + ) + } + + private fun canonicalizeId(value: String): String? = when { + ASCII_ALPHANUMERIC_ID.matches(value) -> value.lowercase() + STANDARD_UUID.matches(value) -> value.replace("-", "").lowercase() + else -> null + } + + private companion object { + val ASCII_ALPHANUMERIC_ID = Regex("^[A-Za-z0-9]{1,32}$") + val STANDARD_UUID = Regex( + "^[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{12}$", + ) + } +} diff --git a/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/InfraredKeyModels.kt b/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/InfraredKeyModels.kt new file mode 100644 index 0000000..9c0a2ec --- /dev/null +++ b/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/InfraredKeyModels.kt @@ -0,0 +1,38 @@ +package com.flagship.abox.manager.domain.infrared + +import com.flagship.abox.manager.domain.DeviceName +import com.flagship.abox.manager.domain.ProviderProfileId + +@JvmInline +value class InfraredKeyId(val value: String) + +data class InfraredKeyRef( + val profileId: ProviderProfileId, + val keyId: InfraredKeyId, +) + +enum class InfraredKeyStatus { + LEARNING, + READY, + FAILED, +} + +const val INTERRUPTED_LEARNING_ERROR_DETAIL = + "Interrupted learning result is unknown; retry required" + +/** + * Persisted infrared key state. [lastErrorDetail] may contain only fixed, domain-owned, + * sanitized text; raw SDK maps, tokens, codes, and vendor payloads must never be stored there. + */ +data class SavedInfraredKey( + val id: InfraredKeyId, + val profileId: ProviderProfileId, + val deviceName: DeviceName, + val displayName: String, + val sdkKey: String, + val status: InfraredKeyStatus, + val lastErrorCode: String?, + val lastErrorDetail: String?, + val createdAtEpochMillis: Long, + val updatedAtEpochMillis: Long, +) diff --git a/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/InfraredKeyRepository.kt b/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/InfraredKeyRepository.kt new file mode 100644 index 0000000..c0cf9ff --- /dev/null +++ b/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/InfraredKeyRepository.kt @@ -0,0 +1,53 @@ +package com.flagship.abox.manager.domain.infrared + +import com.flagship.abox.manager.domain.DeviceName +import com.flagship.abox.manager.domain.DomainResult +import com.flagship.abox.manager.domain.ProviderProfileId +import kotlinx.coroutines.flow.Flow + +interface InfraredKeyRepository { + fun observeKeys( + profileId: ProviderProfileId, + deviceName: DeviceName, + ): Flow>> + + suspend fun getKey(ref: InfraredKeyRef): DomainResult + + suspend fun insert(key: SavedInfraredKey): DomainResult + + suspend fun transitionStatus( + ref: InfraredKeyRef, + expectedStatuses: Set, + targetStatus: InfraredKeyStatus, + lastErrorCode: String?, + lastErrorDetail: String?, + updatedAtEpochMillis: Long, + ): DomainResult + + suspend fun rename( + ref: InfraredKeyRef, + displayName: String, + updatedAtEpochMillis: Long, + ): DomainResult + + suspend fun deleteIfNotLearning(ref: InfraredKeyRef): DomainResult + + /** + * Atomically marks this profile's interrupted LEARNING keys created on or before [cutoffEpochMillis] + * as FAILED, clears the vendor error code, stores [INTERRUPTED_LEARNING_ERROR_DETAIL], and updates their timestamp. + */ + suspend fun failInterruptedLearning( + profileId: ProviderProfileId, + cutoffEpochMillis: Long = Long.MAX_VALUE, + updatedAtEpochMillis: Long = cutoffEpochMillis, + ): DomainResult +} + +interface InfraredDeviceConfigurationRepository { + fun observeDeviceName(profileId: ProviderProfileId): Flow> + + suspend fun setDeviceName( + profileId: ProviderProfileId, + deviceName: DeviceName, + ): DomainResult +} \ No newline at end of file diff --git a/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/LearnInfraredKey.kt b/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/LearnInfraredKey.kt new file mode 100644 index 0000000..43919ad --- /dev/null +++ b/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/LearnInfraredKey.kt @@ -0,0 +1,246 @@ +package com.flagship.abox.manager.domain.infrared + +import com.flagship.abox.manager.domain.DeviceName +import com.flagship.abox.manager.domain.DomainError +import com.flagship.abox.manager.domain.DomainResult +import com.flagship.abox.manager.domain.InfraredGateway +import com.flagship.abox.manager.domain.ProviderProfileId +import kotlinx.coroutines.CancellationException +import kotlinx.coroutines.NonCancellable +import kotlinx.coroutines.withContext + +class LearnInfraredKey( + private val repository: InfraredKeyRepository, + private val gateway: InfraredGateway, + private val factory: InfraredKeyFactory, + private val clock: EpochMillisClock, +) { + suspend operator fun invoke( + profileId: ProviderProfileId, + deviceName: DeviceName, + displayName: String, + sdkKey: String? = null, + ): DomainResult { + val key = when (val result = factory.create(profileId, deviceName, displayName, sdkKey)) { + is DomainResult.Success -> result.value + is DomainResult.Failure -> return result + } + + when (val result = repository.insert(key)) { + is DomainResult.Success -> Unit + is DomainResult.Failure -> return result + } + + val result = try { + gateway.learnKey( + profileId = key.profileId, + deviceName = key.deviceName, + key = key.sdkKey, + ) + } catch (e: CancellationException) { + withContext(NonCancellable) { + repository.transitionStatus( + ref = key.ref(), + expectedStatuses = setOf(InfraredKeyStatus.LEARNING), + targetStatus = InfraredKeyStatus.FAILED, + lastErrorCode = null, + lastErrorDetail = "Cancelled", + updatedAtEpochMillis = clock.now(), + ) + } + throw e + } + + return when (result) { + is DomainResult.Success -> when ( + val transition = repository.transitionStatus( + ref = key.ref(), + expectedStatuses = setOf(InfraredKeyStatus.LEARNING), + targetStatus = InfraredKeyStatus.READY, + lastErrorCode = null, + lastErrorDetail = null, + updatedAtEpochMillis = clock.now(), + ) + ) { + is DomainResult.Success -> DomainResult.Success(key.id) + is DomainResult.Failure -> transition + } + + is DomainResult.Failure -> { + repository.transitionStatus( + ref = key.ref(), + expectedStatuses = setOf(InfraredKeyStatus.LEARNING), + targetStatus = InfraredKeyStatus.FAILED, + lastErrorCode = result.error.externalCode, + lastErrorDetail = null, + updatedAtEpochMillis = clock.now(), + ) + result + } + } + } +} + +class RetryInfraredKeyLearning( + private val repository: InfraredKeyRepository, + private val gateway: InfraredGateway, + private val clock: EpochMillisClock, +) { + suspend operator fun invoke(ref: InfraredKeyRef): DomainResult { + val key = when (val result = repository.getKey(ref)) { + is DomainResult.Success -> result.value + ?: return DomainResult.Failure( + DomainError.InvalidRequest(detail = "Infrared key not found"), + ) + + is DomainResult.Failure -> return result + } + if (key.status == InfraredKeyStatus.LEARNING) { + return DomainResult.Failure( + DomainError.InvalidRequest(detail = "Infrared key is already learning"), + ) + } + + when ( + val result = repository.transitionStatus( + ref = ref, + expectedStatuses = setOf( + InfraredKeyStatus.FAILED, + ), + targetStatus = InfraredKeyStatus.LEARNING, + lastErrorCode = null, + lastErrorDetail = null, + updatedAtEpochMillis = clock.now(), + ) + ) { + is DomainResult.Success -> Unit + is DomainResult.Failure -> return result + } + + val result = try { + gateway.learnKey( + profileId = key.profileId, + deviceName = key.deviceName, + key = key.sdkKey, + ) + } catch (e: CancellationException) { + withContext(NonCancellable) { + repository.transitionStatus( + ref = ref, + expectedStatuses = setOf(InfraredKeyStatus.LEARNING), + targetStatus = InfraredKeyStatus.FAILED, + lastErrorCode = null, + lastErrorDetail = "Cancelled", + updatedAtEpochMillis = clock.now(), + ) + } + throw e + } + + return when (result) { + is DomainResult.Success -> repository.transitionStatus( + ref = ref, + expectedStatuses = setOf(InfraredKeyStatus.LEARNING), + targetStatus = InfraredKeyStatus.READY, + lastErrorCode = null, + lastErrorDetail = null, + updatedAtEpochMillis = clock.now(), + ) + + is DomainResult.Failure -> { + repository.transitionStatus( + ref = ref, + expectedStatuses = setOf(InfraredKeyStatus.LEARNING), + targetStatus = InfraredKeyStatus.FAILED, + lastErrorCode = result.error.externalCode, + lastErrorDetail = null, + updatedAtEpochMillis = clock.now(), + ) + result + } + } + } +} + +class RelearnInfraredKey( + private val repository: InfraredKeyRepository, + private val gateway: InfraredGateway, + private val clock: EpochMillisClock, +) { + suspend operator fun invoke(ref: InfraredKeyRef): DomainResult { + val key = when (val result = repository.getKey(ref)) { + is DomainResult.Success -> result.value + ?: return DomainResult.Failure( + DomainError.InvalidRequest(detail = "Infrared key not found"), + ) + + is DomainResult.Failure -> return result + } + + when ( + val result = repository.transitionStatus( + ref = ref, + expectedStatuses = setOf( + InfraredKeyStatus.READY, + InfraredKeyStatus.FAILED, + InfraredKeyStatus.LEARNING, + ), + targetStatus = InfraredKeyStatus.LEARNING, + lastErrorCode = null, + lastErrorDetail = null, + updatedAtEpochMillis = clock.now(), + ) + ) { + is DomainResult.Success -> Unit + is DomainResult.Failure -> return result + } + + val result = try { + gateway.learnKey( + profileId = key.profileId, + deviceName = key.deviceName, + key = key.sdkKey, + ) + } catch (e: CancellationException) { + withContext(NonCancellable) { + repository.transitionStatus( + ref = ref, + expectedStatuses = setOf(InfraredKeyStatus.LEARNING), + targetStatus = InfraredKeyStatus.FAILED, + lastErrorCode = null, + lastErrorDetail = "Cancelled", + updatedAtEpochMillis = clock.now(), + ) + } + throw e + } + + return when (result) { + is DomainResult.Success -> repository.transitionStatus( + ref = ref, + expectedStatuses = setOf(InfraredKeyStatus.LEARNING), + targetStatus = InfraredKeyStatus.READY, + lastErrorCode = null, + lastErrorDetail = null, + updatedAtEpochMillis = clock.now(), + ) + + is DomainResult.Failure -> { + repository.transitionStatus( + ref = ref, + expectedStatuses = setOf(InfraredKeyStatus.LEARNING), + targetStatus = InfraredKeyStatus.FAILED, + lastErrorCode = result.error.externalCode, + lastErrorDetail = null, + updatedAtEpochMillis = clock.now(), + ) + result + } + } + } +} + +private fun SavedInfraredKey.ref() = InfraredKeyRef( + profileId = profileId, + keyId = id, +) diff --git a/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/LearnVirtualRemoteKey.kt b/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/LearnVirtualRemoteKey.kt new file mode 100644 index 0000000..fb453a3 --- /dev/null +++ b/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/LearnVirtualRemoteKey.kt @@ -0,0 +1,70 @@ +package com.flagship.abox.manager.domain.infrared + +import com.flagship.abox.manager.domain.DomainError +import com.flagship.abox.manager.domain.DomainResult +import com.flagship.abox.manager.domain.InfraredGateway +import com.flagship.abox.manager.domain.ProviderProfileId + +class LearnVirtualRemoteKey( + private val repository: VirtualRemoteRepository, + private val gateway: InfraredGateway, +) { + suspend operator fun invoke( + profileId: ProviderProfileId, + remoteId: VirtualRemoteId, + buttonId: String, + ): DomainResult { + val remote = when (val res = repository.getRemote(profileId, remoteId)) { + is DomainResult.Success -> res.value ?: return DomainResult.Failure(DomainError.NoData(detail = "Remote not found")) + is DomainResult.Failure -> return res + } + val bindings = when (val res = repository.getKeyBindings(remoteId)) { + is DomainResult.Success -> res.value + is DomainResult.Failure -> return res + } + val binding = bindings.find { it.buttonId == buttonId } + ?: return DomainResult.Failure(DomainError.InvalidRequest(detail = "Button not found")) + + val targetSlot = binding.assignedSlot ?: run { + val allBindings = (repository.getKeyBindings(remoteId) as? DomainResult.Success)?.value.orEmpty() + val usedSlots = allBindings.mapNotNull { it.assignedSlot?.toIntOrNull() }.toSet() + val nextSlot = (1..99).firstOrNull { it !in usedSlots } ?: 1 + nextSlot.toString() + } + + // Set status to LEARNING while hardware listens + repository.updateKeyBinding( + binding.copy( + status = InfraredKeyStatus.LEARNING, + assignedSlot = targetSlot, + lastErrorCode = null, + lastErrorDetail = null, + ), + ) + + return when (val learnResult = gateway.learnKey(profileId, remote.deviceName, targetSlot)) { + is DomainResult.Success -> { + repository.updateKeyBinding( + binding.copy( + status = InfraredKeyStatus.READY, + assignedSlot = targetSlot, + lastErrorCode = null, + lastErrorDetail = null, + ), + ) + DomainResult.Success(Unit) + } + is DomainResult.Failure -> { + repository.updateKeyBinding( + binding.copy( + status = InfraredKeyStatus.FAILED, + assignedSlot = targetSlot, + lastErrorCode = learnResult.error.externalCode, + lastErrorDetail = learnResult.error.detail, + ), + ) + learnResult + } + } + } +} diff --git a/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/ManageInfraredKey.kt b/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/ManageInfraredKey.kt new file mode 100644 index 0000000..37acd6f --- /dev/null +++ b/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/ManageInfraredKey.kt @@ -0,0 +1,65 @@ +package com.flagship.abox.manager.domain.infrared + +import com.flagship.abox.manager.domain.DomainError +import com.flagship.abox.manager.domain.DomainResult +import com.flagship.abox.manager.domain.InfraredGateway +import com.flagship.abox.manager.domain.ProviderProfileId + +class SendInfraredKey( + private val repository: InfraredKeyRepository, + private val gateway: InfraredGateway, +) { + suspend operator fun invoke(ref: InfraredKeyRef): DomainResult { + val key = when (val result = repository.getKey(ref)) { + is DomainResult.Success -> result.value + ?: return DomainResult.Failure( + DomainError.NoData(detail = "Infrared key not found"), + ) + + is DomainResult.Failure -> return result + } + if (key.status != InfraredKeyStatus.READY) { + return DomainResult.Failure( + DomainError.InvalidRequest(detail = "Infrared key is not ready"), + ) + } + return gateway.sendKey( + profileId = key.profileId, + deviceName = key.deviceName, + key = key.sdkKey, + ) + } +} + +class RenameInfraredKey( + private val repository: InfraredKeyRepository, + private val clock: EpochMillisClock, +) { + suspend operator fun invoke( + ref: InfraredKeyRef, + displayName: String, + ): DomainResult { + val trimmed = displayName.trim() + if (trimmed.isEmpty()) { + return DomainResult.Failure( + DomainError.InvalidRequest(detail = "Infrared key display name is required"), + ) + } + return repository.rename(ref, trimmed, clock.now()) + } +} + +class DeleteInfraredKey( + private val repository: InfraredKeyRepository, +) { + suspend operator fun invoke(ref: InfraredKeyRef): DomainResult = + repository.deleteIfNotLearning(ref) +} + +class RecoverInterruptedInfraredLearning( + private val repository: InfraredKeyRepository, + private val clock: EpochMillisClock, +) { + suspend operator fun invoke(profileId: ProviderProfileId): DomainResult = + repository.failInterruptedLearning(profileId, clock.now()) +} diff --git a/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/PresetCodeLibrary.kt b/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/PresetCodeLibrary.kt new file mode 100644 index 0000000..7a521c7 --- /dev/null +++ b/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/PresetCodeLibrary.kt @@ -0,0 +1,101 @@ +package com.flagship.abox.manager.domain.infrared + +data class PresetBrandOption( + val id: String, + val displayName: String, + val deviceType: RemoteDeviceType, +) + +object PresetCodeLibrary { + + val availablePresets: List = listOf( + // 电视预设 + PresetBrandOption("generic_tv", "通用电视 (Generic TV)", RemoteDeviceType.TV), + PresetBrandOption("xiaomi_tv", "小米电视 (Xiaomi TV)", RemoteDeviceType.TV), + PresetBrandOption("sony_tv", "索尼电视 (Sony TV)", RemoteDeviceType.TV), + PresetBrandOption("samsung_tv", "三星电视 (Samsung TV)", RemoteDeviceType.TV), + + // 空调预设 + PresetBrandOption("gree_ac", "格力空调 (Gree AC)", RemoteDeviceType.AIR_CONDITIONER), + PresetBrandOption("midea_ac", "美的空调 (Midea AC)", RemoteDeviceType.AIR_CONDITIONER), + PresetBrandOption("haier_ac", "海尔空调 (Haier AC)", RemoteDeviceType.AIR_CONDITIONER), + PresetBrandOption("aux_ac", "奥克斯空调 (AUX AC)", RemoteDeviceType.AIR_CONDITIONER), + + // 风扇预设 + PresetBrandOption("midea_fan", "美的电风扇 (Midea Fan)", RemoteDeviceType.FAN), + PresetBrandOption("generic_fan", "通用风扇 (Generic Fan)", RemoteDeviceType.FAN), + + // 自定义 + PresetBrandOption("custom_blank", "自定义遥控器 (Custom)", RemoteDeviceType.CUSTOM), + ) + + data class PresetButtonTemplate( + val buttonId: String, + val displayName: String, + val defaultHexCode: String? = null, + ) + + fun getTemplatesForType( + type: RemoteDeviceType, + presetId: String? = null, + layoutStyle: PanelLayoutStyle? = null, + ): List = when (type) { + RemoteDeviceType.TV -> getTvTemplates(hasHexCode = true) + RemoteDeviceType.AIR_CONDITIONER -> listOf( + PresetButtonTemplate("AC_POWER", "电源"), + PresetButtonTemplate("AC_TEMP_UP", "升温"), + PresetButtonTemplate("AC_TEMP_DOWN", "降温"), + PresetButtonTemplate("AC_MODE", "模式"), + PresetButtonTemplate("AC_FAN", "风速"), + PresetButtonTemplate("AC_SWING_V", "上下扫风"), + PresetButtonTemplate("AC_SWING_H", "左右扫风"), + PresetButtonTemplate("AC_ECO", "节能"), + ) + RemoteDeviceType.FAN -> listOf( + PresetButtonTemplate("FAN_POWER", "电源", "0x01FE02FD"), + PresetButtonTemplate("FAN_SPEED", "风速", "0x01FE04FB"), + PresetButtonTemplate("FAN_SWING", "摇头", "0x01FE06F9"), + PresetButtonTemplate("FAN_TIMER", "定时", "0x01FE08F7"), + PresetButtonTemplate("FAN_MODE", "模式", "0x01FE0AF5"), + ) + RemoteDeviceType.CUSTOM -> when (layoutStyle) { + PanelLayoutStyle.TV_NAV -> getTvTemplates(hasHexCode = false) + PanelLayoutStyle.MEDIA_PLAYER -> getMediaPlayerTemplates(hasHexCode = false) + PanelLayoutStyle.AC_COMPACT -> emptyList() + PanelLayoutStyle.GRID, null -> listOf( + PresetButtonTemplate("CUSTOM_POWER", "电源"), + PresetButtonTemplate("CUSTOM_KEY_1", "按键 1"), + PresetButtonTemplate("CUSTOM_KEY_2", "按键 2"), + PresetButtonTemplate("CUSTOM_KEY_3", "按键 3"), + ) + } + } + + private fun getTvTemplates(hasHexCode: Boolean): List = listOf( + PresetButtonTemplate("TV_POWER", "电源", if (hasHexCode) "0x00FF02FD" else null), + PresetButtonTemplate("TV_MUTE", "静音", if (hasHexCode) "0x00FF04FB" else null), + PresetButtonTemplate("TV_SOURCE", "信号源", if (hasHexCode) "0x00FF06F9" else null), + PresetButtonTemplate("TV_NAV_UP", "上", if (hasHexCode) "0x00FF08F7" else null), + PresetButtonTemplate("TV_NAV_DOWN", "下", if (hasHexCode) "0x00FF0AF5" else null), + PresetButtonTemplate("TV_NAV_LEFT", "左", if (hasHexCode) "0x00FF0CF3" else null), + PresetButtonTemplate("TV_NAV_RIGHT", "右", if (hasHexCode) "0x00FF0EF1" else null), + PresetButtonTemplate("TV_OK", "确定", if (hasHexCode) "0x00FF10EF" else null), + PresetButtonTemplate("TV_HOME", "主页", if (hasHexCode) "0x00FF12ED" else null), + PresetButtonTemplate("TV_BACK", "返回", if (hasHexCode) "0x00FF14EB" else null), + PresetButtonTemplate("TV_MENU", "菜单", if (hasHexCode) "0x00FF16E9" else null), + PresetButtonTemplate("TV_VOL_UP", "音量 +", if (hasHexCode) "0x00FF18E7" else null), + PresetButtonTemplate("TV_VOL_DOWN", "音量 -", if (hasHexCode) "0x00FF1AE5" else null), + PresetButtonTemplate("TV_CH_UP", "频道 +", if (hasHexCode) "0x00FF1CE3" else null), + PresetButtonTemplate("TV_CH_DOWN", "频道 -", if (hasHexCode) "0x00FF1EE1" else null), + ) + + private fun getMediaPlayerTemplates(hasHexCode: Boolean): List = listOf( + PresetButtonTemplate("MEDIA_POWER", "电源", if (hasHexCode) "0x02FD02FD" else null), + PresetButtonTemplate("MEDIA_MUTE", "静音", if (hasHexCode) "0x02FD04FB" else null), + PresetButtonTemplate("MEDIA_PLAY_PAUSE", "播放/暂停", if (hasHexCode) "0x02FD06F9" else null), + PresetButtonTemplate("MEDIA_PREV", "上一曲", if (hasHexCode) "0x02FD08F7" else null), + PresetButtonTemplate("MEDIA_NEXT", "下一曲", if (hasHexCode) "0x02FD0AF5" else null), + PresetButtonTemplate("MEDIA_REWIND", "快退", if (hasHexCode) "0x02FD0CF3" else null), + PresetButtonTemplate("MEDIA_FF", "快进", if (hasHexCode) "0x02FD0EF1" else null), + ) +} diff --git a/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/SendVirtualRemoteAction.kt b/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/SendVirtualRemoteAction.kt new file mode 100644 index 0000000..c18b2f3 --- /dev/null +++ b/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/SendVirtualRemoteAction.kt @@ -0,0 +1,90 @@ +package com.flagship.abox.manager.domain.infrared + +import com.flagship.abox.manager.domain.DomainError +import com.flagship.abox.manager.domain.DomainResult +import com.flagship.abox.manager.domain.InfraredCode +import com.flagship.abox.manager.domain.InfraredGateway +import com.flagship.abox.manager.domain.ProviderProfileId + +class SendVirtualRemoteAction( + private val repository: VirtualRemoteRepository, + private val gateway: InfraredGateway, +) { + suspend fun sendButton( + profileId: ProviderProfileId, + remoteId: VirtualRemoteId, + buttonId: String, + ): DomainResult { + val remote = when (val res = repository.getRemote(profileId, remoteId)) { + is DomainResult.Success -> res.value ?: return DomainResult.Failure(DomainError.NoData(detail = "Remote not found")) + is DomainResult.Failure -> return res + } + val bindings = when (val res = repository.getKeyBindings(remoteId)) { + is DomainResult.Success -> res.value + is DomainResult.Failure -> return res + } + val binding = bindings.find { it.buttonId == buttonId } + ?: return DomainResult.Failure(DomainError.InvalidRequest(detail = "Button binding not found")) + + if (binding.status != InfraredKeyStatus.READY) { + return DomainResult.Failure(DomainError.InvalidRequest(detail = "Button is not ready to send")) + } + + return when (remote.transmissionMode) { + TransmissionMode.STATIC_SLOTS -> { + val slot = binding.assignedSlot + ?: return DomainResult.Failure(DomainError.InvalidRequest(detail = "No slot assigned for static mode")) + gateway.sendKey(profileId, remote.deviceName, slot) + } + TransmissionMode.DYNAMIC_SCRATCH -> { + if (binding.rawHexCode != null) { + // 1. Download to scratch slot + val scratchSlot = remote.dynamicScratchSlot + when (val dlResult = gateway.downloadCodes(profileId, listOf(InfraredCode(remote.deviceName, scratchSlot, binding.rawHexCode)))) { + is DomainResult.Failure -> return dlResult + is DomainResult.Success -> Unit + } + // 2. Send scratch slot + gateway.sendKey(profileId, remote.deviceName, scratchSlot) + } else if (binding.assignedSlot != null) { + // Fallback to sending learned hardware slot + gateway.sendKey(profileId, remote.deviceName, binding.assignedSlot) + } else { + DomainResult.Failure(DomainError.InvalidRequest(detail = "No hex code or slot available for transmission")) + } + } + } + } + + suspend fun sendAcState( + profileId: ProviderProfileId, + remoteId: VirtualRemoteId, + state: AcStateSnapshot, + ): DomainResult { + val remote = when (val res = repository.getRemote(profileId, remoteId)) { + is DomainResult.Success -> res.value ?: return DomainResult.Failure(DomainError.NoData(detail = "Remote not found")) + is DomainResult.Failure -> return res + } + if (remote.type != RemoteDeviceType.AIR_CONDITIONER) { + return DomainResult.Failure(DomainError.InvalidRequest(detail = "Target is not an air conditioner")) + } + + // 1. Update state snapshot in repository + when (val updateRes = repository.updateAcState(profileId, remoteId, state)) { + is DomainResult.Failure -> return updateRes + is DomainResult.Success -> Unit + } + + // 2. Generate full state hex frame + val hexCode = AcCodeGenerator.generateHex(state, remote.brandModel) + + // 3. Write to scratch slot and transmit + val scratchSlot = remote.dynamicScratchSlot + when (val dlResult = gateway.downloadCodes(profileId, listOf(InfraredCode(remote.deviceName, scratchSlot, hexCode)))) { + is DomainResult.Failure -> return dlResult + is DomainResult.Success -> Unit + } + + return gateway.sendKey(profileId, remote.deviceName, scratchSlot) + } +} diff --git a/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/UpdateVirtualRemoteLayout.kt b/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/UpdateVirtualRemoteLayout.kt new file mode 100644 index 0000000..bd42b09 --- /dev/null +++ b/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/UpdateVirtualRemoteLayout.kt @@ -0,0 +1,25 @@ +package com.flagship.abox.manager.domain.infrared + +import com.flagship.abox.manager.domain.DomainError +import com.flagship.abox.manager.domain.DomainResult +import com.flagship.abox.manager.domain.ProviderProfileId + +class UpdateVirtualRemoteLayout( + private val repository: VirtualRemoteRepository, +) { + suspend operator fun invoke( + profileId: ProviderProfileId, + remoteId: VirtualRemoteId, + layoutStyle: PanelLayoutStyle, + ): DomainResult { + val remote = when (val res = repository.getRemote(profileId, remoteId)) { + is DomainResult.Success -> res.value ?: return DomainResult.Failure(DomainError.NoData(detail = "Remote not found")) + is DomainResult.Failure -> return res + } + val updated = remote.copy( + layoutStyle = layoutStyle, + updatedAtEpochMillis = System.currentTimeMillis(), + ) + return repository.updateRemote(updated) + } +} diff --git a/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/VirtualRemoteModels.kt b/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/VirtualRemoteModels.kt new file mode 100644 index 0000000..112a29c --- /dev/null +++ b/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/VirtualRemoteModels.kt @@ -0,0 +1,108 @@ +package com.flagship.abox.manager.domain.infrared + +import com.flagship.abox.manager.domain.DeviceName +import com.flagship.abox.manager.domain.ProviderProfileId + +@JvmInline +value class VirtualRemoteId(val value: String) + +enum class RemoteDeviceType { + TV, + AIR_CONDITIONER, + FAN, + CUSTOM, +} + +enum class TransmissionMode { + STATIC_SLOTS, + DYNAMIC_SCRATCH, +} + +enum class PanelLayoutStyle { + TV_NAV, + GRID, + MEDIA_PLAYER, + AC_COMPACT, +} + +enum class AcMode { + COOL, + HEAT, + AUTO, + DRY, + FAN, +} + +enum class AcFanSpeed { + AUTO, + LOW, + MEDIUM, + HIGH, +} + +data class AcStateSnapshot( + val power: Boolean = true, + val mode: AcMode = AcMode.COOL, + val temperature: Int = 26, + val fanSpeed: AcFanSpeed = AcFanSpeed.AUTO, + val verticalSwing: Boolean = true, + val horizontalSwing: Boolean = false, + val eco: Boolean = false, +) + +data class VirtualRemote( + val id: VirtualRemoteId, + val profileId: ProviderProfileId, + val deviceName: DeviceName, + val displayName: String, + val type: RemoteDeviceType, + val brandModel: String? = null, + val layoutStyle: PanelLayoutStyle = defaultLayoutFor(type), + val transmissionMode: TransmissionMode, + val dynamicScratchSlot: String = DEFAULT_DYNAMIC_SCRATCH_SLOT, + val acState: AcStateSnapshot? = null, + val createdAtEpochMillis: Long, + val updatedAtEpochMillis: Long, +) { + companion object { + const val DEFAULT_DYNAMIC_SCRATCH_SLOT = "100" + + fun defaultLayoutFor(type: RemoteDeviceType): PanelLayoutStyle = when (type) { + RemoteDeviceType.TV -> PanelLayoutStyle.TV_NAV + RemoteDeviceType.AIR_CONDITIONER -> PanelLayoutStyle.AC_COMPACT + RemoteDeviceType.FAN -> PanelLayoutStyle.GRID + RemoteDeviceType.CUSTOM -> PanelLayoutStyle.GRID + } + } +} + +data class RemoteKeyBinding( + val id: String, + val remoteId: VirtualRemoteId, + val profileId: ProviderProfileId, + val buttonId: String, + val displayName: String, + val assignedSlot: String? = null, + val rawHexCode: String? = null, + val status: InfraredKeyStatus = InfraredKeyStatus.READY, + val lastErrorCode: String? = null, + val lastErrorDetail: String? = null, +) + +data class SlotQuotaSummary( + val totalCapacity: Int = 100, + val dynamicScratchSlot: Int = 100, + val assignedStaticSlots: Set = emptySet(), +) { + val availableStaticSlots: List + get() = (1 until dynamicScratchSlot).filter { it !in assignedStaticSlots } + + val usedCount: Int + get() = assignedStaticSlots.size + 1 // assigned static slots + 1 dynamic scratch slot + + val remainingStaticCount: Int + get() = availableStaticSlots.size + + val isStaticFull: Boolean + get() = availableStaticSlots.isEmpty() +} diff --git a/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/VirtualRemoteRepository.kt b/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/VirtualRemoteRepository.kt new file mode 100644 index 0000000..fb9e622 --- /dev/null +++ b/domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/VirtualRemoteRepository.kt @@ -0,0 +1,58 @@ +package com.flagship.abox.manager.domain.infrared + +import com.flagship.abox.manager.domain.DeviceName +import com.flagship.abox.manager.domain.DomainResult +import com.flagship.abox.manager.domain.ProviderProfileId +import kotlinx.coroutines.flow.Flow + +interface VirtualRemoteRepository { + fun observeRemotes( + profileId: ProviderProfileId, + deviceName: DeviceName, + ): Flow>> + + fun observeRemote( + profileId: ProviderProfileId, + remoteId: VirtualRemoteId, + ): Flow> + + fun observeKeyBindings( + remoteId: VirtualRemoteId, + ): Flow>> + + fun observeSlotQuota( + profileId: ProviderProfileId, + deviceName: DeviceName, + ): Flow> + + suspend fun getRemote( + profileId: ProviderProfileId, + remoteId: VirtualRemoteId, + ): DomainResult + + suspend fun getKeyBindings( + remoteId: VirtualRemoteId, + ): DomainResult> + + suspend fun createRemote( + remote: VirtualRemote, + initialBindings: List, + ): DomainResult + + suspend fun updateRemote(remote: VirtualRemote): DomainResult + + suspend fun deleteRemote( + profileId: ProviderProfileId, + remoteId: VirtualRemoteId, + ): DomainResult + + suspend fun updateKeyBinding(binding: RemoteKeyBinding): DomainResult + + suspend fun deleteKeyBinding(remoteId: VirtualRemoteId, buttonId: String): DomainResult + + suspend fun updateAcState( + profileId: ProviderProfileId, + remoteId: VirtualRemoteId, + state: AcStateSnapshot, + ): DomainResult +} diff --git a/domain/src/test/kotlin/com/flagship/abox/manager/domain/infrared/InMemoryInfraredTestDoubles.kt b/domain/src/test/kotlin/com/flagship/abox/manager/domain/infrared/InMemoryInfraredTestDoubles.kt new file mode 100644 index 0000000..0fd17cd --- /dev/null +++ b/domain/src/test/kotlin/com/flagship/abox/manager/domain/infrared/InMemoryInfraredTestDoubles.kt @@ -0,0 +1,345 @@ +package com.flagship.abox.manager.domain.infrared + +import com.flagship.abox.manager.domain.DeviceName +import com.flagship.abox.manager.domain.DomainError +import com.flagship.abox.manager.domain.DomainResult +import com.flagship.abox.manager.domain.InfraredCode +import com.flagship.abox.manager.domain.InfraredCodeDownloadResult +import com.flagship.abox.manager.domain.InfraredGateway +import com.flagship.abox.manager.domain.ProviderProfileId +import kotlinx.coroutines.flow.Flow +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.map + +data class InfraredLearningCall( + val profileId: ProviderProfileId, + val deviceName: DeviceName, + val key: String, +) + +data class InfraredStatusTransitionCall( + val ref: InfraredKeyRef, + val expectedStatuses: Set, + val targetStatus: InfraredKeyStatus, + val lastErrorCode: String?, + val lastErrorDetail: String?, + val updatedAtEpochMillis: Long, +) + +data class InfraredSendCall( + val profileId: ProviderProfileId, + val deviceName: DeviceName, + val key: String, +) + +data class InfraredRenameCall( + val ref: InfraredKeyRef, + val displayName: String, + val updatedAtEpochMillis: Long, +) + +data class InfraredRecoveryCall( + val profileId: ProviderProfileId, + val updatedAtEpochMillis: Long, +) + +class InMemoryInfraredKeyRepository : InfraredKeyRepository { + private val keys = linkedMapOf() + private val state = MutableStateFlow>(emptyList()) + + var getError: DomainError? = null + var insertError: DomainError? = null + var renameError: DomainError? = null + var deleteError: DomainError? = null + var recoveryError: DomainError? = null + val transitionErrors = mutableMapOf() + + var onInsert: ((SavedInfraredKey) -> Unit)? = null + var onTransition: ((InfraredStatusTransitionCall) -> Unit)? = null + + val insertedKeys = mutableListOf() + val getCalls = mutableListOf() + val transitionCalls = mutableListOf() + val renameCalls = mutableListOf() + val deleteCalls = mutableListOf() + val recoveryCalls = mutableListOf() + + override fun observeKeys( + profileId: ProviderProfileId, + deviceName: DeviceName, + ): Flow>> = state.map { values -> + DomainResult.Success( + values.filter { it.profileId == profileId && it.deviceName == deviceName }, + ) + } + + override suspend fun getKey(ref: InfraredKeyRef): DomainResult { + getCalls += ref + getError?.let { return DomainResult.Failure(it) } + return DomainResult.Success(keys[ref]) + } + + override suspend fun insert(key: SavedInfraredKey): DomainResult { + insertedKeys += key + onInsert?.invoke(key) + insertError?.let { return DomainResult.Failure(it) } + keys[key.ref()] = key + publish() + return DomainResult.Success(Unit) + } + + override suspend fun transitionStatus( + ref: InfraredKeyRef, + expectedStatuses: Set, + targetStatus: InfraredKeyStatus, + lastErrorCode: String?, + lastErrorDetail: String?, + updatedAtEpochMillis: Long, + ): DomainResult { + val call = InfraredStatusTransitionCall( + ref = ref, + expectedStatuses = expectedStatuses, + targetStatus = targetStatus, + lastErrorCode = lastErrorCode, + lastErrorDetail = lastErrorDetail, + updatedAtEpochMillis = updatedAtEpochMillis, + ) + transitionCalls += call + onTransition?.invoke(call) + transitionErrors[targetStatus]?.let { return DomainResult.Failure(it) } + + val existing = keys[ref] + ?: return DomainResult.Failure(DomainError.InvalidRequest(detail = "Infrared key not found")) + if (existing.status !in expectedStatuses) { + return DomainResult.Failure( + DomainError.InvalidRequest(detail = "Infrared key status changed"), + ) + } + keys[ref] = existing.copy( + status = targetStatus, + lastErrorCode = lastErrorCode, + lastErrorDetail = lastErrorDetail, + updatedAtEpochMillis = updatedAtEpochMillis, + ) + publish() + return DomainResult.Success(Unit) + } + + override suspend fun rename( + ref: InfraredKeyRef, + displayName: String, + updatedAtEpochMillis: Long, + ): DomainResult { + renameCalls += InfraredRenameCall(ref, displayName, updatedAtEpochMillis) + renameError?.let { return DomainResult.Failure(it) } + val existing = keys[ref] + ?: return DomainResult.Failure(DomainError.InvalidRequest(detail = "Infrared key not found")) + keys[ref] = existing.copy( + displayName = displayName, + updatedAtEpochMillis = updatedAtEpochMillis, + ) + publish() + return DomainResult.Success(Unit) + } + + override suspend fun deleteIfNotLearning(ref: InfraredKeyRef): DomainResult { + deleteCalls += ref + deleteError?.let { return DomainResult.Failure(it) } + val existing = keys[ref] + ?: return DomainResult.Failure(DomainError.InvalidRequest(detail = "Infrared key not found")) + if (existing.status == InfraredKeyStatus.LEARNING) { + return DomainResult.Failure( + DomainError.InvalidRequest(detail = "Cannot delete a learning infrared key"), + ) + } + keys.remove(ref) + publish() + return DomainResult.Success(Unit) + } + + override suspend fun failInterruptedLearning( + profileId: ProviderProfileId, + cutoffEpochMillis: Long, + updatedAtEpochMillis: Long, + ): DomainResult { + recoveryCalls += InfraredRecoveryCall(profileId, updatedAtEpochMillis) + recoveryError?.let { return DomainResult.Failure(it) } + var changed = 0 + keys.replaceAll { _, key -> + if (key.profileId == profileId && key.status == InfraredKeyStatus.LEARNING && key.createdAtEpochMillis <= cutoffEpochMillis) { + changed += 1 + key.copy( + status = InfraredKeyStatus.FAILED, + lastErrorCode = null, + lastErrorDetail = INTERRUPTED_LEARNING_ERROR_DETAIL, + updatedAtEpochMillis = updatedAtEpochMillis, + ) + } else { + key + } + } + publish() + return DomainResult.Success(changed) + } + + fun seed(key: SavedInfraredKey) { + keys[key.ref()] = key + publish() + } + + fun onlyKey(): SavedInfraredKey = keys.values.single() + + fun allKeys(): List = keys.values.toList() + + private fun publish() { + state.value = keys.values.toList() + } +} + +class RecordingInfraredGateway : InfraredGateway { + var learnResult: DomainResult = DomainResult.Success(Unit) + var sendResult: DomainResult = DomainResult.Success(Unit) + var onLearn: ((ProviderProfileId, DeviceName, String) -> DomainResult)? = null + val learnedKeys = mutableListOf() + val sentKeys = mutableListOf() + val downloadedCodes = mutableListOf() + + override suspend fun learnKey( + profileId: ProviderProfileId, + deviceName: DeviceName, + key: String, + ): DomainResult { + learnedKeys += InfraredLearningCall(profileId, deviceName, key) + return onLearn?.invoke(profileId, deviceName, key) ?: learnResult + } + + override suspend fun sendKey( + profileId: ProviderProfileId, + deviceName: DeviceName, + key: String, + ): DomainResult { + sentKeys += InfraredSendCall(profileId, deviceName, key) + return sendResult + } + + override suspend fun downloadCodes( + profileId: ProviderProfileId, + codes: List, + ): DomainResult> { + downloadedCodes += codes + return DomainResult.Success(codes.map { InfraredCodeDownloadResult(it, successful = true) }) + } +} + +class InMemoryVirtualRemoteRepository : VirtualRemoteRepository { + private val remotes = mutableMapOf() + private val bindings = mutableMapOf>() + private val state = MutableStateFlow>(emptyList()) + + override fun observeRemotes( + profileId: ProviderProfileId, + deviceName: DeviceName, + ): Flow>> = state.map { values -> + DomainResult.Success(values.filter { it.profileId == profileId && it.deviceName == deviceName }) + } + + override fun observeRemote( + profileId: ProviderProfileId, + remoteId: VirtualRemoteId, + ): Flow> = state.map { values -> + DomainResult.Success(values.find { it.id == remoteId && it.profileId == profileId }) + } + + override fun observeKeyBindings( + remoteId: VirtualRemoteId, + ): Flow>> = state.map { + DomainResult.Success(bindings[remoteId]?.toList().orEmpty()) + } + + override fun observeSlotQuota( + profileId: ProviderProfileId, + deviceName: DeviceName, + ): Flow> = state.map { values -> + val relevant = values.filter { it.profileId == profileId && it.deviceName == deviceName } + val used = relevant.flatMap { bindings[it.id].orEmpty() } + .mapNotNull { it.assignedSlot?.toIntOrNull() } + .toSet() + DomainResult.Success(SlotQuotaSummary(assignedStaticSlots = used)) + } + + override suspend fun getRemote( + profileId: ProviderProfileId, + remoteId: VirtualRemoteId, + ): DomainResult = DomainResult.Success(remotes[remoteId]?.takeIf { it.profileId == profileId }) + + override suspend fun getKeyBindings( + remoteId: VirtualRemoteId, + ): DomainResult> = DomainResult.Success(bindings[remoteId]?.toList().orEmpty()) + + override suspend fun createRemote( + remote: VirtualRemote, + initialBindings: List, + ): DomainResult { + remotes[remote.id] = remote + bindings[remote.id] = initialBindings.toMutableList() + publish() + return DomainResult.Success(remote.id) + } + + override suspend fun updateRemote(remote: VirtualRemote): DomainResult { + remotes[remote.id] = remote + publish() + return DomainResult.Success(Unit) + } + + override suspend fun deleteRemote( + profileId: ProviderProfileId, + remoteId: VirtualRemoteId, + ): DomainResult { + remotes.remove(remoteId) + bindings.remove(remoteId) + publish() + return DomainResult.Success(Unit) + } + + override suspend fun updateKeyBinding(binding: RemoteKeyBinding): DomainResult { + val list = bindings[binding.remoteId] ?: mutableListOf() + val idx = list.indexOfFirst { it.id == binding.id || it.buttonId == binding.buttonId } + if (idx >= 0) list[idx] = binding else list.add(binding) + bindings[binding.remoteId] = list + publish() + return DomainResult.Success(Unit) + } + + override suspend fun deleteKeyBinding( + remoteId: VirtualRemoteId, + buttonId: String, + ): DomainResult { + val list = bindings[remoteId] ?: return DomainResult.Success(Unit) + list.removeAll { it.buttonId == buttonId } + bindings[remoteId] = list + publish() + return DomainResult.Success(Unit) + } + + override suspend fun updateAcState( + profileId: ProviderProfileId, + remoteId: VirtualRemoteId, + state: AcStateSnapshot, + ): DomainResult { + val existing = remotes[remoteId] ?: return DomainResult.Success(Unit) + remotes[remoteId] = existing.copy(acState = state) + publish() + return DomainResult.Success(Unit) + } + + private fun publish() { + state.value = remotes.values.toList() + } +} + +fun SavedInfraredKey.ref() = InfraredKeyRef( + profileId = profileId, + keyId = id, +) + diff --git a/domain/src/test/kotlin/com/flagship/abox/manager/domain/infrared/InfraredKeyFactoryTest.kt b/domain/src/test/kotlin/com/flagship/abox/manager/domain/infrared/InfraredKeyFactoryTest.kt new file mode 100644 index 0000000..95c7b6b --- /dev/null +++ b/domain/src/test/kotlin/com/flagship/abox/manager/domain/infrared/InfraredKeyFactoryTest.kt @@ -0,0 +1,89 @@ +package com.flagship.abox.manager.domain.infrared + +import com.flagship.abox.manager.domain.DeviceName +import com.flagship.abox.manager.domain.DomainResult +import com.flagship.abox.manager.domain.ProviderProfileId +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Test + +class InfraredKeyFactoryTest { + private val id = InfraredKeyId("01J5MOLERABC123") + private val factory = InfraredKeyFactory( + idGenerator = InfraredKeyIdGenerator { id }, + clock = EpochMillisClock { 1_724_435_200_000L }, + ) + + @Test + fun createsLearningKeyWithStableAsciiSdkKey() { + val result = factory.create( + ProviderProfileId("abox"), + DeviceName("ir-1"), + "空调开关", + ) as DomainResult.Success + + assertEquals(id, result.value.id) + assertEquals("app_ir_01j5molerabc123", result.value.sdkKey) + assertEquals(InfraredKeyStatus.LEARNING, result.value.status) + assertEquals(null, result.value.lastErrorCode) + assertEquals(null, result.value.lastErrorDetail) + assertEquals("空调开关", result.value.displayName) + assertEquals(1_724_435_200_000L, result.value.createdAtEpochMillis) + assertEquals(result.value.createdAtEpochMillis, result.value.updatedAtEpochMillis) + } + + @Test + fun createsLearningKeyWithCustomNumericSlot() { + val result = factory.create( + ProviderProfileId("abox"), + DeviceName("ir-1"), + "空调开", + sdkKey = "1", + ) as DomainResult.Success + + assertEquals("1", result.value.sdkKey) + } + + @Test + fun rejectsInvalidNumericSlots() { + assertTrue(factory.create(ProviderProfileId("abox"), DeviceName("ir-1"), "Power", sdkKey = "0") is DomainResult.Failure) + assertTrue(factory.create(ProviderProfileId("abox"), DeviceName("ir-1"), "Power", sdkKey = "101") is DomainResult.Failure) + assertTrue(factory.create(ProviderProfileId("abox"), DeviceName("ir-1"), "Power", sdkKey = "abc") is DomainResult.Failure) + } + + @Test + fun rejectsBlankDeviceOrDisplayName() { + assertTrue(factory.create(ProviderProfileId("abox"), DeviceName(""), "Power") is DomainResult.Failure) + assertTrue(factory.create(ProviderProfileId("abox"), DeviceName("ir-1"), " ") is DomainResult.Failure) + } + + @Test + fun rejectsIdentifiersWithSurroundingWhitespace() { + assertTrue(factory.create(ProviderProfileId(" abox"), DeviceName("ir-1"), "Power") is DomainResult.Failure) + assertTrue(factory.create(ProviderProfileId("abox"), DeviceName("ir-1 "), "Power") is DomainResult.Failure) + } + + @Test + fun rejectsLossyOrOversizedIds() { + assertTrue(factoryWithId("ab-c").createValidKey() is DomainResult.Failure) + assertTrue(factoryWithId("a".repeat(33)).createValidKey() is DomainResult.Failure) + } + + @Test + fun canonicalizesStandardUuidId() { + val result = factoryWithId("550E8400-E29B-41D4-A716-446655440000").createValidKey() as DomainResult.Success + + assertEquals("app_ir_550e8400e29b41d4a716446655440000", result.value.sdkKey) + } + + private fun factoryWithId(value: String) = InfraredKeyFactory( + idGenerator = InfraredKeyIdGenerator { InfraredKeyId(value) }, + clock = EpochMillisClock { 1_724_435_200_000L }, + ) + + private fun InfraredKeyFactory.createValidKey() = create( + ProviderProfileId("abox"), + DeviceName("ir-1"), + "Power", + ) +} diff --git a/domain/src/test/kotlin/com/flagship/abox/manager/domain/infrared/LearnInfraredKeyTest.kt b/domain/src/test/kotlin/com/flagship/abox/manager/domain/infrared/LearnInfraredKeyTest.kt new file mode 100644 index 0000000..0c727df --- /dev/null +++ b/domain/src/test/kotlin/com/flagship/abox/manager/domain/infrared/LearnInfraredKeyTest.kt @@ -0,0 +1,343 @@ +package com.flagship.abox.manager.domain.infrared + +import com.flagship.abox.manager.domain.DeviceName +import com.flagship.abox.manager.domain.DomainError +import com.flagship.abox.manager.domain.DomainResult +import com.flagship.abox.manager.domain.ProviderProfileId +import kotlinx.coroutines.test.runTest +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Test + +class LearnInfraredKeyTest { + private val profile = ProviderProfileId("abox") + private val device = DeviceName("ir-1") + private val keyId = InfraredKeyId("key1") + private val clock = SteppingClock(100L) + private val factory = InfraredKeyFactory( + idGenerator = InfraredKeyIdGenerator { keyId }, + clock = clock, + ) + private val repository = InMemoryInfraredKeyRepository() + private val gateway = RecordingInfraredGateway() + private val learn = LearnInfraredKey(repository, gateway, factory, clock) + private val retry = RetryInfraredKeyLearning(repository, gateway, clock) + private val relearn = RelearnInfraredKey(repository, gateway, clock) + + @Test + fun persistsLearningBeforeCallingHardwareThenMarksReady() = runTest { + val events = mutableListOf() + repository.onInsert = { events += "insert:${it.status}" } + gateway.onLearn = { _, _, _ -> + events += "hardware" + DomainResult.Success(Unit) + } + repository.onTransition = { events += "transition:${it.targetStatus}" } + + val result = learn(profile, device, "Power") + + assertEquals(DomainResult.Success(keyId), result) + assertEquals(listOf("insert:LEARNING", "hardware", "transition:READY"), events) + assertEquals(InfraredKeyStatus.READY, repository.onlyKey().status) + assertEquals(null, repository.onlyKey().lastErrorCode) + assertEquals(null, repository.onlyKey().lastErrorDetail) + } + + @Test + fun hardwareFailureMarksFailedAndReturnsOriginalError() = runTest { + val gatewayError = DomainError.DeviceOffline("20206") + gateway.learnResult = DomainResult.Failure(gatewayError) + + val result = learn(profile, device, "Power") + + assertEquals(gatewayError, (result as DomainResult.Failure).error) + assertEquals(InfraredKeyStatus.FAILED, repository.onlyKey().status) + assertEquals("20206", repository.onlyKey().lastErrorCode) + assertEquals(null, repository.onlyKey().lastErrorDetail) + } + + @Test + fun insertFailureNeverCallsHardware() = runTest { + val insertError = DomainError.Unknown(detail = "database unavailable") + repository.insertError = insertError + + val result = learn(profile, device, "Power") + + assertEquals(insertError, (result as DomainResult.Failure).error) + assertTrue(gateway.learnedKeys.isEmpty()) + assertTrue(repository.transitionCalls.isEmpty()) + } + + @Test + fun factoryFailureNeverTouchesRepositoryOrHardware() = runTest { + val result = learn(profile, device, " ") + + assertTrue((result as DomainResult.Failure).error is DomainError.InvalidRequest) + assertTrue(repository.insertedKeys.isEmpty()) + assertTrue(repository.transitionCalls.isEmpty()) + assertTrue(gateway.learnedKeys.isEmpty()) + } + + @Test + fun readyTransitionFailureIsReturnedAfterHardwareSuccess() = runTest { + val transitionError = DomainError.Unknown(detail = "write conflict") + repository.transitionErrors[InfraredKeyStatus.READY] = transitionError + + val result = learn(profile, device, "Power") + + assertEquals(transitionError, (result as DomainResult.Failure).error) + assertEquals(InfraredKeyStatus.LEARNING, repository.onlyKey().status) + assertEquals(1, gateway.learnedKeys.size) + } + + @Test + fun failedTransitionErrorDoesNotReplaceGatewayFailure() = runTest { + val gatewayError = DomainError.DeviceOffline("20206") + gateway.learnResult = DomainResult.Failure(gatewayError) + repository.transitionErrors[InfraredKeyStatus.FAILED] = + DomainError.Unknown(detail = "write conflict") + + val result = learn(profile, device, "Power") + + assertEquals(gatewayError, (result as DomainResult.Failure).error) + assertEquals(InfraredKeyStatus.LEARNING, repository.onlyKey().status) + assertEquals("20206", repository.transitionCalls.single().lastErrorCode) + assertEquals(null, repository.transitionCalls.single().lastErrorDetail) + } + + @Test + fun newLearningUsesExpectedLearningTransitionsAndFreshTimestamps() = runTest { + learn(profile, device, "Power") + + val inserted = repository.insertedKeys.single() + val transition = repository.transitionCalls.single() + assertEquals(setOf(InfraredKeyStatus.LEARNING), transition.expectedStatuses) + assertEquals(inserted.ref(), transition.ref) + assertEquals(100L, inserted.createdAtEpochMillis) + assertEquals(100L, inserted.updatedAtEpochMillis) + assertEquals(101L, transition.updatedAtEpochMillis) + } + + @Test + fun retryReusesStableIdAndSdkKey() = runTest { + val original = failedKey(id = InfraredKeyId("key1"), sdkKey = "app_ir_key1") + repository.seed(original) + + val result = retry(original.ref()) + + assertEquals(DomainResult.Success(Unit), result) + assertEquals("app_ir_key1", gateway.learnedKeys.single().key) + assertEquals(InfraredKeyId("key1"), repository.onlyKey().id) + assertEquals(InfraredKeyStatus.READY, repository.onlyKey().status) + assertEquals(0, repository.insertedKeys.size) + assertEquals(2, repository.transitionCalls.size) + assertEquals( + setOf(InfraredKeyStatus.FAILED), + repository.transitionCalls.first().expectedStatuses, + ) + assertEquals( + setOf(InfraredKeyStatus.LEARNING), + repository.transitionCalls.last().expectedStatuses, + ) + } + + @Test + fun relearnReusesStableIdAndSdkKeyForReadyKey() = runTest { + val original = failedKey(id = InfraredKeyId("key1"), sdkKey = "app_ir_key1").copy( + status = InfraredKeyStatus.READY, + lastErrorCode = null, + lastErrorDetail = null, + ) + repository.seed(original) + + val result = relearn(original.ref()) + + assertEquals(DomainResult.Success(Unit), result) + assertEquals("app_ir_key1", gateway.learnedKeys.single().key) + assertEquals(InfraredKeyId("key1"), repository.onlyKey().id) + assertEquals(InfraredKeyStatus.READY, repository.onlyKey().status) + assertEquals(0, repository.insertedKeys.size) + assertEquals(2, repository.transitionCalls.size) + assertEquals( + setOf(InfraredKeyStatus.READY, InfraredKeyStatus.FAILED, InfraredKeyStatus.LEARNING), + repository.transitionCalls.first().expectedStatuses, + ) + assertEquals( + setOf(InfraredKeyStatus.LEARNING), + repository.transitionCalls.last().expectedStatuses, + ) + } + + @Test + fun retryRejectsAlreadyLearningKey() = runTest { + repository.seed(learningKey()) + + val result = retry(repository.onlyKey().ref()) + + assertTrue((result as DomainResult.Failure).error is DomainError.InvalidRequest) + assertTrue(gateway.learnedKeys.isEmpty()) + assertTrue(repository.transitionCalls.isEmpty()) + } + + @Test + fun retryRejectsMissingKey() = runTest { + val result = retry(InfraredKeyRef(profile, InfraredKeyId("missing"))) + + assertTrue((result as DomainResult.Failure).error is DomainError.InvalidRequest) + assertTrue(gateway.learnedKeys.isEmpty()) + assertTrue(repository.transitionCalls.isEmpty()) + } + + @Test + fun retryReturnsGetFailureWithoutCallingHardware() = runTest { + val getError = DomainError.Unknown(detail = "database unavailable") + repository.getError = getError + + val result = retry(InfraredKeyRef(profile, keyId)) + + assertEquals(getError, (result as DomainResult.Failure).error) + assertTrue(gateway.learnedKeys.isEmpty()) + assertTrue(repository.transitionCalls.isEmpty()) + } + + @Test + fun retryDoesNotCallHardwareWhenLearningTransitionFails() = runTest { + val original = failedKey() + repository.seed(original) + val transitionError = DomainError.Unknown(detail = "write conflict") + repository.transitionErrors[InfraredKeyStatus.LEARNING] = transitionError + + val result = retry(original.ref()) + + assertEquals(transitionError, (result as DomainResult.Failure).error) + assertTrue(gateway.learnedKeys.isEmpty()) + assertEquals(InfraredKeyStatus.FAILED, repository.onlyKey().status) + } + + @Test + fun retryExpectedStatusFailurePreventsHardwareAfterConcurrentStatusChange() = runTest { + val original = failedKey() + repository.seed(original) + repository.onTransition = { call -> + if (call.targetStatus == InfraredKeyStatus.LEARNING) { + repository.seed(original.copy(status = InfraredKeyStatus.LEARNING)) + } + } + + val result = retry(original.ref()) + + assertTrue((result as DomainResult.Failure).error is DomainError.InvalidRequest) + assertTrue(gateway.learnedKeys.isEmpty()) + assertEquals(InfraredKeyStatus.LEARNING, repository.onlyKey().status) + } + + @Test + fun retryUsesSeparateTimestampsAndClearsErrorsBeforeHardware() = runTest { + val original = failedKey() + repository.seed(original) + gateway.onLearn = { _, _, _ -> + assertEquals(InfraredKeyStatus.LEARNING, repository.onlyKey().status) + assertEquals(null, repository.onlyKey().lastErrorCode) + assertEquals(null, repository.onlyKey().lastErrorDetail) + assertEquals(100L, repository.onlyKey().updatedAtEpochMillis) + DomainResult.Success(Unit) + } + + assertEquals(DomainResult.Success(Unit), retry(original.ref())) + assertEquals(InfraredKeyStatus.READY, repository.onlyKey().status) + assertEquals(null, repository.onlyKey().lastErrorCode) + assertEquals(null, repository.onlyKey().lastErrorDetail) + assertEquals(101L, repository.onlyKey().updatedAtEpochMillis) + assertEquals(listOf(100L, 101L), repository.transitionCalls.map { it.updatedAtEpochMillis }) + } + + @Test + fun retryGatewayFailureMarksFailedWithExternalCodeAndReturnsOriginalError() = runTest { + val original = failedKey() + repository.seed(original) + val gatewayError = DomainError.DeviceOffline("20206") + gateway.learnResult = DomainResult.Failure(gatewayError) + + val result = retry(original.ref()) + + assertEquals(gatewayError, (result as DomainResult.Failure).error) + assertEquals(InfraredKeyStatus.FAILED, repository.onlyKey().status) + assertEquals("20206", repository.onlyKey().lastErrorCode) + assertEquals(null, repository.onlyKey().lastErrorDetail) + } + + @Test + fun retryFailedTransitionErrorDoesNotReplaceGatewayFailure() = runTest { + val original = failedKey() + repository.seed(original) + val gatewayError = DomainError.DeviceOffline("20206") + gateway.learnResult = DomainResult.Failure(gatewayError) + repository.transitionErrors[InfraredKeyStatus.FAILED] = + DomainError.Unknown(detail = "write conflict") + + val result = retry(original.ref()) + + assertEquals(gatewayError, (result as DomainResult.Failure).error) + assertEquals(InfraredKeyStatus.LEARNING, repository.onlyKey().status) + assertEquals("20206", repository.transitionCalls.last().lastErrorCode) + assertEquals(null, repository.transitionCalls.last().lastErrorDetail) + } + + @Test + fun retryReadyTransitionFailureIsReturnedAfterHardwareSuccess() = runTest { + val original = failedKey() + repository.seed(original) + val transitionError = DomainError.Unknown(detail = "write conflict") + repository.transitionErrors[InfraredKeyStatus.READY] = transitionError + + val result = retry(original.ref()) + + assertEquals(transitionError, (result as DomainResult.Failure).error) + assertEquals(InfraredKeyStatus.LEARNING, repository.onlyKey().status) + assertEquals(1, gateway.learnedKeys.size) + } + + @Test + fun learningCancellationTransitionsStatusToFailed() = runTest { + gateway.onLearn = { _, _, _ -> + throw kotlinx.coroutines.CancellationException("User cancelled") + } + + try { + learn(profile, device, "Power") + } catch (_: kotlinx.coroutines.CancellationException) { + // expected + } + + assertEquals(InfraredKeyStatus.FAILED, repository.onlyKey().status) + assertEquals("Cancelled", repository.onlyKey().lastErrorDetail) + } + + private fun failedKey( + id: InfraredKeyId = keyId, + sdkKey: String = "app_ir_key1", + ) = SavedInfraredKey( + id = id, + profileId = profile, + deviceName = device, + displayName = "Power", + sdkKey = sdkKey, + status = InfraredKeyStatus.FAILED, + lastErrorCode = "old-error", + lastErrorDetail = "old-detail", + createdAtEpochMillis = 1L, + updatedAtEpochMillis = 2L, + ) + + private fun learningKey() = failedKey().copy( + status = InfraredKeyStatus.LEARNING, + lastErrorCode = null, + lastErrorDetail = null, + ) +} + +private class SteppingClock(start: Long) : EpochMillisClock { + private var next = start + + override fun now(): Long = next++ +} diff --git a/domain/src/test/kotlin/com/flagship/abox/manager/domain/infrared/ManageInfraredKeyTest.kt b/domain/src/test/kotlin/com/flagship/abox/manager/domain/infrared/ManageInfraredKeyTest.kt new file mode 100644 index 0000000..9e2c655 --- /dev/null +++ b/domain/src/test/kotlin/com/flagship/abox/manager/domain/infrared/ManageInfraredKeyTest.kt @@ -0,0 +1,251 @@ +package com.flagship.abox.manager.domain.infrared + +import com.flagship.abox.manager.domain.DeviceName +import com.flagship.abox.manager.domain.DomainError +import com.flagship.abox.manager.domain.DomainResult +import com.flagship.abox.manager.domain.ProviderProfileId +import kotlinx.coroutines.test.runTest +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Test + +class ManageInfraredKeyTest { + private val profile = ProviderProfileId("abox") + private val otherProfile = ProviderProfileId("other") + private val repository = InMemoryInfraredKeyRepository() + private val gateway = RecordingInfraredGateway() + private val clock = SteppingManagementClock(500L) + private val send = SendInfraredKey(repository, gateway) + private val rename = RenameInfraredKey(repository, clock) + private val delete = DeleteInfraredKey(repository) + private val recover = RecoverInterruptedInfraredLearning(repository, clock) + + @Test + fun sendsReadyKeyUsingStoredDeviceAndSdkKeyWithoutRepositoryWrites() = runTest { + val key = readyKey(deviceName = DeviceName("ir-living"), sdkKey = "app_ir_power") + repository.seed(key) + + assertEquals(DomainResult.Success(Unit), send(key.ref())) + assertEquals( + InfraredSendCall(profile, DeviceName("ir-living"), "app_ir_power"), + gateway.sentKeys.single(), + ) + assertEquals(listOf(key.ref()), repository.getCalls) + assertTrue(repository.transitionCalls.isEmpty()) + assertTrue(repository.renameCalls.isEmpty()) + assertTrue(repository.deleteCalls.isEmpty()) + assertTrue(repository.recoveryCalls.isEmpty()) + assertEquals(key, repository.onlyKey()) + } + + @Test + fun sendFailureDoesNotDemoteReadyKey() = runTest { + val key = readyKey() + repository.seed(key) + val gatewayError = DomainError.OperationFailed("20205") + gateway.sendResult = DomainResult.Failure(gatewayError) + + assertEquals(gatewayError, (send(key.ref()) as DomainResult.Failure).error) + assertEquals( + listOf(InfraredSendCall(profile, DeviceName("ir-1"), "app_ir_key1")), + gateway.sentKeys, + ) + assertEquals(InfraredKeyStatus.READY, repository.onlyKey().status) + assertTrue(repository.transitionCalls.isEmpty()) + } + + @Test + fun missingSendReturnsNoDataWithoutHardwareCall() = runTest { + val result = send(InfraredKeyRef(profile, InfraredKeyId("missing"))) + + assertTrue((result as DomainResult.Failure).error is DomainError.NoData) + assertEquals( + listOf(InfraredKeyRef(profile, InfraredKeyId("missing"))), + repository.getCalls, + ) + assertTrue(gateway.sentKeys.isEmpty()) + } + + @Test + fun nonReadySendReturnsInvalidRequestWithoutHardwareCall() = runTest { + repository.seed(failedKey()) + + val result = send(repository.onlyKey().ref()) + + assertTrue((result as DomainResult.Failure).error is DomainError.InvalidRequest) + assertTrue(gateway.sentKeys.isEmpty()) + } + + @Test + fun sendReturnsRepositoryFailureWithoutHardwareCall() = runTest { + val repositoryError = DomainError.Unknown(detail = "database unavailable") + repository.getError = repositoryError + + val result = send(InfraredKeyRef(profile, InfraredKeyId("key1"))) + + assertEquals(repositoryError, (result as DomainResult.Failure).error) + assertTrue(gateway.sentKeys.isEmpty()) + } + + @Test + fun renameTrimsDisplayNameAndPreservesStableIdentityAndErrors() = runTest { + val before = readyKey(displayName = "Power", sdkKey = "app_ir_power").copy( + status = InfraredKeyStatus.FAILED, + lastErrorCode = "20206", + lastErrorDetail = "fixed-detail", + ) + repository.seed(before) + + assertEquals(DomainResult.Success(Unit), rename(before.ref(), " 空调开关 ")) + + val after = repository.onlyKey() + assertEquals("空调开关", after.displayName) + assertEquals(before.sdkKey, after.sdkKey) + assertEquals(before.id, after.id) + assertEquals(before.lastErrorCode, after.lastErrorCode) + assertEquals(before.lastErrorDetail, after.lastErrorDetail) + assertEquals(before.createdAtEpochMillis, after.createdAtEpochMillis) + assertEquals(500L, after.updatedAtEpochMillis) + assertEquals( + InfraredRenameCall(before.ref(), "空调开关", 500L), + repository.renameCalls.single(), + ) + } + + @Test + fun renameRejectsBlankDisplayNameWithoutRepositoryCall() = runTest { + val key = readyKey() + repository.seed(key) + + val result = rename(key.ref(), " \t ") + + assertTrue((result as DomainResult.Failure).error is DomainError.InvalidRequest) + assertTrue(repository.renameCalls.isEmpty()) + assertEquals(key, repository.onlyKey()) + } + + @Test + fun renameReturnsRepositoryFailure() = runTest { + val key = readyKey() + repository.seed(key) + val repositoryError = DomainError.Unknown(detail = "write failed") + repository.renameError = repositoryError + + val result = rename(key.ref(), "New name") + + assertEquals(repositoryError, (result as DomainResult.Failure).error) + assertEquals("Power", repository.onlyKey().displayName) + } + + @Test + fun deleteDelegatesAtomicLearningGuardToRepository() = runTest { + val key = learningKey() + repository.seed(key) + + val result = delete(key.ref()) + + assertTrue((result as DomainResult.Failure).error is DomainError.InvalidRequest) + assertEquals(listOf(key.ref()), repository.deleteCalls) + assertTrue(repository.getCalls.isEmpty()) + assertTrue(repository.allKeys().isNotEmpty()) + } + + @Test + fun deleteRemovesReadyKey() = runTest { + val key = readyKey() + repository.seed(key) + + assertEquals(DomainResult.Success(Unit), delete(key.ref())) + assertEquals(listOf(key.ref()), repository.deleteCalls) + assertTrue(repository.getCalls.isEmpty()) + assertTrue(repository.allKeys().isEmpty()) + } + + @Test + fun recoveryDelegatesOnceAndMarksOnlyProfileLearningKeysFailed() = runTest { + val learningOne = learningKey(id = InfraredKeyId("one"), lastErrorCode = "old") + val learningTwo = learningKey(id = InfraredKeyId("two")) + val ready = readyKey(id = InfraredKeyId("ready")) + val other = learningKey(id = InfraredKeyId("other"), profileId = otherProfile) + repository.seed(learningOne) + repository.seed(learningTwo) + repository.seed(ready) + repository.seed(other) + + assertEquals(DomainResult.Success(2), recover(profile)) + assertEquals( + listOf(InfraredRecoveryCall(profile, 500L)), + repository.recoveryCalls, + ) + assertTrue(repository.getCalls.isEmpty()) + assertTrue(repository.transitionCalls.isEmpty()) + val recovered = repository.allKeys().filter { it.profileId == profile && it.id.value in setOf("one", "two") } + assertTrue(recovered.all { it.status == InfraredKeyStatus.FAILED }) + assertTrue(recovered.all { it.lastErrorCode == null }) + assertTrue( + recovered.all { + it.lastErrorDetail == "Interrupted learning result is unknown; retry required" + }, + ) + assertTrue(recovered.all { it.updatedAtEpochMillis == 500L }) + assertEquals(InfraredKeyStatus.READY, repository.allKeys().single { it.id.value == "ready" }.status) + assertEquals(InfraredKeyStatus.LEARNING, repository.allKeys().single { it.profileId == otherProfile }.status) + assertTrue(gateway.learnedKeys.isEmpty()) + assertTrue(gateway.sentKeys.isEmpty()) + } + + @Test + fun recoveryReturnsRepositoryFailureWithoutHardwareCall() = runTest { + val repositoryError = DomainError.Unknown(detail = "write failed") + repository.recoveryError = repositoryError + + val result = recover(profile) + + assertEquals(repositoryError, (result as DomainResult.Failure).error) + assertEquals(listOf(InfraredRecoveryCall(profile, 500L)), repository.recoveryCalls) + assertTrue(gateway.learnedKeys.isEmpty()) + assertTrue(gateway.sentKeys.isEmpty()) + } + + private fun readyKey( + id: InfraredKeyId = InfraredKeyId("key1"), + profileId: ProviderProfileId = profile, + deviceName: DeviceName = DeviceName("ir-1"), + displayName: String = "Power", + sdkKey: String = "app_ir_key1", + ) = SavedInfraredKey( + id = id, + profileId = profileId, + deviceName = deviceName, + displayName = displayName, + sdkKey = sdkKey, + status = InfraredKeyStatus.READY, + lastErrorCode = null, + lastErrorDetail = null, + createdAtEpochMillis = 1L, + updatedAtEpochMillis = 2L, + ) + + private fun failedKey() = readyKey().copy( + status = InfraredKeyStatus.FAILED, + lastErrorCode = "old-error", + lastErrorDetail = "old-detail", + ) + + private fun learningKey( + id: InfraredKeyId = InfraredKeyId("key1"), + profileId: ProviderProfileId = profile, + lastErrorCode: String? = null, + lastErrorDetail: String? = null, + ) = readyKey(id = id, profileId = profileId).copy( + status = InfraredKeyStatus.LEARNING, + lastErrorCode = lastErrorCode, + lastErrorDetail = lastErrorDetail, + ) +} + +private class SteppingManagementClock(start: Long) : EpochMillisClock { + private var next = start + + override fun now(): Long = next++ +} diff --git a/domain/src/test/kotlin/com/flagship/abox/manager/domain/infrared/VirtualRemoteUseCaseTest.kt b/domain/src/test/kotlin/com/flagship/abox/manager/domain/infrared/VirtualRemoteUseCaseTest.kt new file mode 100644 index 0000000..d507536 --- /dev/null +++ b/domain/src/test/kotlin/com/flagship/abox/manager/domain/infrared/VirtualRemoteUseCaseTest.kt @@ -0,0 +1,119 @@ +package com.flagship.abox.manager.domain.infrared + +import com.flagship.abox.manager.domain.DeviceName +import com.flagship.abox.manager.domain.DomainResult +import com.flagship.abox.manager.domain.ProviderProfileId +import kotlinx.coroutines.test.runTest +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNotNull +import org.junit.Assert.assertTrue +import org.junit.Before +import org.junit.Test + +class VirtualRemoteUseCaseTest { + + private val profileId = ProviderProfileId("profile1") + private val deviceName = DeviceName("ir-1") + private val clock = EpochMillisClock { 10_000L } + + private lateinit var repository: InMemoryVirtualRemoteRepository + private lateinit var gateway: RecordingInfraredGateway + private lateinit var createRemote: CreateVirtualRemote + private lateinit var sendAction: SendVirtualRemoteAction + private lateinit var deleteRemote: DeleteVirtualRemote + + @Before + fun setup() { + repository = InMemoryVirtualRemoteRepository() + gateway = RecordingInfraredGateway() + createRemote = CreateVirtualRemote(repository, gateway, clock) + sendAction = SendVirtualRemoteAction(repository, gateway) + deleteRemote = DeleteVirtualRemote(repository) + } + + @Test + fun createVirtualRemoteWithStaticSlotsDownloadsPresetCodesToHardware() = runTest { + val result = createRemote( + profileId = profileId, + deviceName = deviceName, + displayName = "Living Room TV", + type = RemoteDeviceType.TV, + brandModel = "generic_tv", + transmissionMode = TransmissionMode.STATIC_SLOTS, + ) + + assertTrue(result is DomainResult.Success) + val remoteId = (result as DomainResult.Success).value + + // Check remote created in repository + val remote = (repository.getRemote(profileId, remoteId) as DomainResult.Success).value + assertNotNull(remote) + assertEquals("Living Room TV", remote?.displayName) + assertEquals(TransmissionMode.STATIC_SLOTS, remote?.transmissionMode) + + // Check preset codes downloaded to hardware gateway + assertTrue(gateway.downloadedCodes.isNotEmpty()) + + // Send a button in static mode -> directly triggers sendKey with assigned slot + val sendRes = sendAction.sendButton(profileId, remoteId, "TV_POWER") + assertTrue(sendRes is DomainResult.Success) + assertEquals(1, gateway.sentKeys.size) + assertEquals("1", gateway.sentKeys.first().key) + } + + @Test + fun sendVirtualRemoteActionForAcUpdatesStateAndDownloadsToScratchSlot() = runTest { + val createResult = createRemote( + profileId = profileId, + deviceName = deviceName, + displayName = "Bedroom AC", + type = RemoteDeviceType.AIR_CONDITIONER, + brandModel = "gree_ac", + transmissionMode = TransmissionMode.DYNAMIC_SCRATCH, + ) + val remoteId = (createResult as DomainResult.Success).value + + val newAcState = AcStateSnapshot( + power = true, + mode = AcMode.COOL, + temperature = 27, + fanSpeed = AcFanSpeed.HIGH, + verticalSwing = true, + ) + + val sendRes = sendAction.sendAcState(profileId, remoteId, newAcState) + assertTrue(sendRes is DomainResult.Success) + + // 1. Downloaded to scratch slot 100 + assertEquals(1, gateway.downloadedCodes.size) + val downloaded = gateway.downloadedCodes.first() + assertEquals("100", downloaded.key) + assertTrue(downloaded.code.startsWith("0x")) + + // 2. Transmitted via sendKey with slot 100 + assertEquals(1, gateway.sentKeys.size) + assertEquals("100", gateway.sentKeys.first().key) + + // 3. State machine updated in repository + val updatedRemote = (repository.getRemote(profileId, remoteId) as DomainResult.Success).value + assertEquals(27, updatedRemote?.acState?.temperature) + assertEquals(AcFanSpeed.HIGH, updatedRemote?.acState?.fanSpeed) + } + + @Test + fun deleteVirtualRemoteRemovesFromRepository() = runTest { + val createResult = createRemote( + profileId = profileId, + deviceName = deviceName, + displayName = "Fan", + type = RemoteDeviceType.FAN, + transmissionMode = TransmissionMode.DYNAMIC_SCRATCH, + ) + val remoteId = (createResult as DomainResult.Success).value + + deleteRemote(profileId, remoteId) + + val fetched = (repository.getRemote(profileId, remoteId) as DomainResult.Success).value + assertEquals(null, fetched) + } +} diff --git a/gradle.properties b/gradle.properties index badfccb..640f2f3 100644 --- a/gradle.properties +++ b/gradle.properties @@ -3,3 +3,4 @@ org.gradle.configuration-cache=false android.useAndroidX=true android.nonTransitiveRClass=true kotlin.code.style=official +android.overridePathCheck=true diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml index 1ad4e45..7aa0738 100644 --- a/gradle/libs.versions.toml +++ b/gradle/libs.versions.toml @@ -35,6 +35,8 @@ hilt-android = { module = "com.google.dagger:hilt-android", version.ref = "hilt" hilt-compiler = { module = "com.google.dagger:hilt-compiler", version.ref = "hilt" } room-runtime = { module = "androidx.room:room-runtime", version.ref = "room" } room-ktx = { module = "androidx.room:room-ktx", version.ref = "room" } +room-compiler = { module = "androidx.room:room-compiler", version.ref = "room" } +room-testing = { module = "androidx.room:room-testing", version.ref = "room" } datastore-preferences = { module = "androidx.datastore:datastore-preferences", version.ref = "datastore" } junit = { module = "junit:junit", version.ref = "junit" } androidx-junit = { module = "androidx.test.ext:junit", version.ref = "androidxJunit" } diff --git a/settings.gradle.kts b/settings.gradle.kts index 4b9cad8..3e34f95 100644 --- a/settings.gradle.kts +++ b/settings.gradle.kts @@ -28,4 +28,5 @@ include(":absdk-bridge") include(":testing:fakes") include(":android:core:designsystem") include(":android:core:session") +include(":android:feature:infrared") include(":android:app") diff --git a/testing/fakes/src/main/kotlin/com/flagship/abox/manager/testing/fakes/FakeDeviceGateways.kt b/testing/fakes/src/main/kotlin/com/flagship/abox/manager/testing/fakes/FakeDeviceGateways.kt index cbd527b..60c3c21 100644 --- a/testing/fakes/src/main/kotlin/com/flagship/abox/manager/testing/fakes/FakeDeviceGateways.kt +++ b/testing/fakes/src/main/kotlin/com/flagship/abox/manager/testing/fakes/FakeDeviceGateways.kt @@ -12,8 +12,8 @@ import com.flagship.abox.manager.domain.SocketPowerState import com.flagship.abox.manager.domain.SocketStatus import com.flagship.abox.manager.domain.TemperatureHumidityGateway import com.flagship.abox.manager.domain.TemperatureHumidityReading -import java.util.Collections import java.util.concurrent.ConcurrentHashMap +import java.util.concurrent.CopyOnWriteArrayList class FakeSocketGateway : SocketGateway { private val states = ConcurrentHashMap() @@ -78,10 +78,11 @@ class FakeTemperatureHumidityGateway : TemperatureHumidityGateway { } class FakeInfraredGateway : InfraredGateway { - val sentKeys: MutableList = Collections.synchronizedList(mutableListOf()) - val learnedKeys: MutableList = Collections.synchronizedList(mutableListOf()) - val downloadCalls: MutableList = - Collections.synchronizedList(mutableListOf()) + val sentKeys = CopyOnWriteArrayList() + val learnedKeys = CopyOnWriteArrayList() + val downloadCalls = CopyOnWriteArrayList() + private val sendResults = ConcurrentHashMap>() + private val learnResults = ConcurrentHashMap>() @Volatile var sendResult: DomainResult = DomainResult.Success(Unit) @@ -98,7 +99,7 @@ class FakeInfraredGateway : InfraredGateway { key: String, ): DomainResult { sentKeys += InfraredCall(profileId, deviceName, key) - return sendResult + return sendResults[InfraredOperationKey(profileId, deviceName, key)] ?: sendResult } override suspend fun learnKey( @@ -107,16 +108,40 @@ class FakeInfraredGateway : InfraredGateway { key: String, ): DomainResult { learnedKeys += InfraredCall(profileId, deviceName, key) - return learnResult + return learnResults[InfraredOperationKey(profileId, deviceName, key)] ?: learnResult } + fun setSendResult( + profileId: ProviderProfileId, + deviceName: DeviceName, + key: String, + result: DomainResult, + ) { + sendResults[InfraredOperationKey(profileId, deviceName, key)] = result + } + + fun setLearnResult( + profileId: ProviderProfileId, + deviceName: DeviceName, + key: String, + result: DomainResult, + ) { + learnResults[InfraredOperationKey(profileId, deviceName, key)] = result + } + + val downloadedCodes: List + get() = downloadCalls.flatMap { it.codes } + override suspend fun downloadCodes( profileId: ProviderProfileId, codes: List, ): DomainResult> { + val codesSnapshot = codes.toList() downloadError?.let { return DomainResult.Failure(it) } - downloadCalls += InfraredDownloadCall(profileId, codes) - return DomainResult.Success(codes.map { InfraredCodeDownloadResult(it, successful = true) }) + downloadCalls += InfraredDownloadCall(profileId, codesSnapshot) + return DomainResult.Success( + codesSnapshot.map { InfraredCodeDownloadResult(it, successful = true) }, + ) } } @@ -131,6 +156,12 @@ data class InfraredDownloadCall( val codes: List, ) +private data class InfraredOperationKey( + val profileId: ProviderProfileId, + val deviceName: DeviceName, + val key: String, +) + private data class DeviceKey( val profileId: ProviderProfileId, val deviceName: DeviceName, diff --git a/testing/fakes/src/main/kotlin/com/flagship/abox/manager/testing/fakes/FakeInfraredKeyRepository.kt b/testing/fakes/src/main/kotlin/com/flagship/abox/manager/testing/fakes/FakeInfraredKeyRepository.kt new file mode 100644 index 0000000..d50a42d --- /dev/null +++ b/testing/fakes/src/main/kotlin/com/flagship/abox/manager/testing/fakes/FakeInfraredKeyRepository.kt @@ -0,0 +1,165 @@ +package com.flagship.abox.manager.testing.fakes + +import com.flagship.abox.manager.domain.DeviceName +import com.flagship.abox.manager.domain.DomainError +import com.flagship.abox.manager.domain.DomainResult +import com.flagship.abox.manager.domain.ProviderProfileId +import com.flagship.abox.manager.domain.infrared.INTERRUPTED_LEARNING_ERROR_DETAIL +import com.flagship.abox.manager.domain.infrared.InfraredDeviceConfigurationRepository +import com.flagship.abox.manager.domain.infrared.InfraredKeyRef +import com.flagship.abox.manager.domain.infrared.InfraredKeyRepository +import com.flagship.abox.manager.domain.infrared.InfraredKeyStatus +import com.flagship.abox.manager.domain.infrared.SavedInfraredKey +import kotlinx.coroutines.flow.Flow +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.map + +class FakeInfraredKeyRepository : InfraredKeyRepository { + private val lock = Any() + private val keys = linkedMapOf() + private val state = MutableStateFlow>(emptyList()) + + override fun observeKeys( + profileId: ProviderProfileId, + deviceName: DeviceName, + ): Flow>> = state.map { values -> + DomainResult.Success( + values.filter { it.profileId == profileId && it.deviceName == deviceName }, + ) + } + + override suspend fun getKey(ref: InfraredKeyRef): DomainResult = + synchronized(lock) { + DomainResult.Success(keys[ref]) + } + + override suspend fun insert(key: SavedInfraredKey): DomainResult = synchronized(lock) { + val ref = key.ref() + if (keys.keys.any { it.keyId == key.id }) { + return@synchronized invalidRequest("Infrared key id already exists") + } + if (keys.values.any { + it.profileId == key.profileId && + it.deviceName == key.deviceName && + it.sdkKey == key.sdkKey + } + ) { + return@synchronized invalidRequest("Infrared key binding already exists") + } + keys[ref] = key + publishLocked() + DomainResult.Success(Unit) + } + + override suspend fun transitionStatus( + ref: InfraredKeyRef, + expectedStatuses: Set, + targetStatus: InfraredKeyStatus, + lastErrorCode: String?, + lastErrorDetail: String?, + updatedAtEpochMillis: Long, + ): DomainResult = synchronized(lock) { + val existing = keys[ref] ?: return@synchronized keyNotFound() + if (existing.status !in expectedStatuses) { + return@synchronized invalidRequest("Infrared key status changed") + } + keys[ref] = existing.copy( + status = targetStatus, + lastErrorCode = lastErrorCode, + lastErrorDetail = lastErrorDetail, + updatedAtEpochMillis = updatedAtEpochMillis, + ) + publishLocked() + DomainResult.Success(Unit) + } + + override suspend fun rename( + ref: InfraredKeyRef, + displayName: String, + updatedAtEpochMillis: Long, + ): DomainResult = synchronized(lock) { + val existing = keys[ref] ?: return@synchronized keyNotFound() + keys[ref] = existing.copy( + displayName = displayName, + updatedAtEpochMillis = updatedAtEpochMillis, + ) + publishLocked() + DomainResult.Success(Unit) + } + + override suspend fun deleteIfNotLearning(ref: InfraredKeyRef): DomainResult = + synchronized(lock) { + val existing = keys[ref] ?: return@synchronized keyNotFound() + if (existing.status == InfraredKeyStatus.LEARNING) { + return@synchronized invalidRequest("Cannot delete a learning infrared key") + } + keys.remove(ref) + publishLocked() + DomainResult.Success(Unit) + } + + override suspend fun failInterruptedLearning( + profileId: ProviderProfileId, + cutoffEpochMillis: Long, + updatedAtEpochMillis: Long, + ): DomainResult = synchronized(lock) { + var changed = 0 + keys.replaceAll { _, key -> + if (key.profileId == profileId && key.status == InfraredKeyStatus.LEARNING && key.createdAtEpochMillis <= cutoffEpochMillis) { + changed += 1 + key.copy( + status = InfraredKeyStatus.FAILED, + lastErrorCode = null, + lastErrorDetail = INTERRUPTED_LEARNING_ERROR_DETAIL, + updatedAtEpochMillis = updatedAtEpochMillis, + ) + } else { + key + } + } + if (changed > 0) publishLocked() + DomainResult.Success(changed) + } + + private fun publishLocked() { + state.value = keys.values.toList() + } + + private fun keyNotFound(): DomainResult.Failure = + invalidRequest("Infrared key not found") + + private fun invalidRequest(detail: String): DomainResult.Failure = + DomainResult.Failure(DomainError.InvalidRequest(detail = detail)) +} + +class FakeInfraredDeviceConfigurationRepository : InfraredDeviceConfigurationRepository { + private val lock = Any() + private val deviceNames = MutableStateFlow>(emptyMap()) + var observeError: DomainError? = null + + override fun observeDeviceName( + profileId: ProviderProfileId, + ): Flow> = deviceNames.map { values -> + observeError?.let { return@map DomainResult.Failure(it) } + DomainResult.Success(values[profileId]) + } + + override suspend fun setDeviceName( + profileId: ProviderProfileId, + deviceName: DeviceName, + ): DomainResult = synchronized(lock) { + val value = deviceName.value + if (value.isBlank() || value != value.trim()) { + return@synchronized DomainResult.Failure( + DomainError.InvalidRequest(detail = "Infrared device name must be trimmed and non-blank"), + ) + } + deviceNames.value = deviceNames.value + (profileId to deviceName) + DomainResult.Success(Unit) + } +} + +private fun SavedInfraredKey.ref() = InfraredKeyRef( + profileId = profileId, + keyId = id, +) diff --git a/testing/fakes/src/main/kotlin/com/flagship/abox/manager/testing/fakes/FakeVirtualRemoteRepository.kt b/testing/fakes/src/main/kotlin/com/flagship/abox/manager/testing/fakes/FakeVirtualRemoteRepository.kt new file mode 100644 index 0000000..ac183cc --- /dev/null +++ b/testing/fakes/src/main/kotlin/com/flagship/abox/manager/testing/fakes/FakeVirtualRemoteRepository.kt @@ -0,0 +1,137 @@ +package com.flagship.abox.manager.testing.fakes + +import com.flagship.abox.manager.domain.DeviceName +import com.flagship.abox.manager.domain.DomainResult +import com.flagship.abox.manager.domain.ProviderProfileId +import com.flagship.abox.manager.domain.infrared.AcStateSnapshot +import com.flagship.abox.manager.domain.infrared.RemoteKeyBinding +import com.flagship.abox.manager.domain.infrared.SlotQuotaSummary +import com.flagship.abox.manager.domain.infrared.VirtualRemote +import com.flagship.abox.manager.domain.infrared.VirtualRemoteId +import com.flagship.abox.manager.domain.infrared.VirtualRemoteRepository +import kotlinx.coroutines.flow.Flow +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.map +import java.util.concurrent.ConcurrentHashMap + +class FakeVirtualRemoteRepository : VirtualRemoteRepository { + + private val remotes = ConcurrentHashMap() + private val bindings = ConcurrentHashMap>() + private val changeTrigger = MutableStateFlow(0L) + + override fun observeRemotes( + profileId: ProviderProfileId, + deviceName: DeviceName, + ): Flow>> = changeTrigger.map { + DomainResult.Success( + remotes.values.filter { it.profileId == profileId && it.deviceName == deviceName } + .sortedByDescending { it.createdAtEpochMillis }, + ) + } + + override fun observeRemote( + profileId: ProviderProfileId, + remoteId: VirtualRemoteId, + ): Flow> = changeTrigger.map { + val remote = remotes[remoteId]?.takeIf { it.profileId == profileId } + DomainResult.Success(remote) + } + + override fun observeKeyBindings( + remoteId: VirtualRemoteId, + ): Flow>> = changeTrigger.map { + DomainResult.Success(bindings[remoteId]?.toList().orEmpty()) + } + + override fun observeSlotQuota( + profileId: ProviderProfileId, + deviceName: DeviceName, + ): Flow> = changeTrigger.map { + val relevantBindings = remotes.values + .filter { it.profileId == profileId && it.deviceName == deviceName } + .flatMap { bindings[it.id].orEmpty() } + val usedSlots = relevantBindings.mapNotNull { it.assignedSlot?.toIntOrNull() }.toSet() + DomainResult.Success( + SlotQuotaSummary( + totalCapacity = 100, + dynamicScratchSlot = 100, + assignedStaticSlots = usedSlots, + ), + ) + } + + override suspend fun getRemote( + profileId: ProviderProfileId, + remoteId: VirtualRemoteId, + ): DomainResult { + val remote = remotes[remoteId]?.takeIf { it.profileId == profileId } + return DomainResult.Success(remote) + } + + override suspend fun getKeyBindings( + remoteId: VirtualRemoteId, + ): DomainResult> = + DomainResult.Success(bindings[remoteId]?.toList().orEmpty()) + + override suspend fun createRemote( + remote: VirtualRemote, + initialBindings: List, + ): DomainResult { + remotes[remote.id] = remote + bindings[remote.id] = initialBindings.toMutableList() + changeTrigger.value = System.currentTimeMillis() + return DomainResult.Success(remote.id) + } + + override suspend fun updateRemote(remote: VirtualRemote): DomainResult { + remotes[remote.id] = remote + changeTrigger.value = System.currentTimeMillis() + return DomainResult.Success(Unit) + } + + override suspend fun deleteRemote( + profileId: ProviderProfileId, + remoteId: VirtualRemoteId, + ): DomainResult { + remotes.remove(remoteId) + bindings.remove(remoteId) + changeTrigger.value = System.currentTimeMillis() + return DomainResult.Success(Unit) + } + + override suspend fun updateKeyBinding(binding: RemoteKeyBinding): DomainResult { + val list = bindings[binding.remoteId] ?: mutableListOf() + val index = list.indexOfFirst { it.id == binding.id || it.buttonId == binding.buttonId } + if (index >= 0) { + list[index] = binding + } else { + list.add(binding) + } + bindings[binding.remoteId] = list + changeTrigger.value = System.currentTimeMillis() + return DomainResult.Success(Unit) + } + + override suspend fun deleteKeyBinding( + remoteId: VirtualRemoteId, + buttonId: String, + ): DomainResult { + val list = bindings[remoteId] ?: return DomainResult.Success(Unit) + list.removeAll { it.buttonId == buttonId } + bindings[remoteId] = list + changeTrigger.value = System.currentTimeMillis() + return DomainResult.Success(Unit) + } + + override suspend fun updateAcState( + profileId: ProviderProfileId, + remoteId: VirtualRemoteId, + state: AcStateSnapshot, + ): DomainResult { + val existing = remotes[remoteId] ?: return DomainResult.Success(Unit) + remotes[remoteId] = existing.copy(acState = state) + changeTrigger.value = System.currentTimeMillis() + return DomainResult.Success(Unit) + } +} diff --git a/testing/fakes/src/test/kotlin/com/flagship/abox/manager/testing/fakes/FakeDeviceGatewaysTest.kt b/testing/fakes/src/test/kotlin/com/flagship/abox/manager/testing/fakes/FakeDeviceGatewaysTest.kt index 8b46b3a..432ea50 100644 --- a/testing/fakes/src/test/kotlin/com/flagship/abox/manager/testing/fakes/FakeDeviceGatewaysTest.kt +++ b/testing/fakes/src/test/kotlin/com/flagship/abox/manager/testing/fakes/FakeDeviceGatewaysTest.kt @@ -4,8 +4,14 @@ import com.flagship.abox.manager.domain.DeviceName import com.flagship.abox.manager.domain.DomainError import com.flagship.abox.manager.domain.DomainResult import com.flagship.abox.manager.domain.InfraredCode +import com.flagship.abox.manager.domain.InfraredCodeDownloadResult import com.flagship.abox.manager.domain.ProviderProfileId import com.flagship.abox.manager.domain.SocketPowerState +import java.util.concurrent.ConcurrentLinkedQueue +import java.util.concurrent.CountDownLatch +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.joinAll +import kotlinx.coroutines.launch import kotlinx.coroutines.test.runTest import org.junit.Assert.assertEquals import org.junit.Assert.assertTrue @@ -54,4 +60,119 @@ class FakeDeviceGatewaysTest { assertEquals(InfraredDownloadCall(profileOne, listOf(code)), gateway.downloadCalls.single()) assertTrue(download is DomainResult.Success) } + + @Test + fun infraredDownloadRecordsAndReturnsAnInputSnapshot() = runTest { + val gateway = FakeInfraredGateway() + val code = InfraredCode(DeviceName("ir-1"), "power", "code-value") + val mutableCodes = mutableListOf(code) + + val result = gateway.downloadCodes(profileOne, mutableCodes) + mutableCodes.clear() + + assertEquals( + InfraredDownloadCall(profileOne, listOf(code)), + gateway.downloadCalls.single(), + ) + assertEquals( + DomainResult.Success(listOf(InfraredCodeDownloadResult(code, successful = true))), + result, + ) + } + + @Test + fun infraredCallLogCanBeIteratedSafelyAroundConcurrentWrites() = runTest { + val gateway = FakeInfraredGateway() + val deviceName = DeviceName("ir-1") + gateway.sendKey(profileOne, deviceName, "initial") + val staleIterators = List(10) { gateway.sentKeys.iterator() } + val start = CountDownLatch(1) + val failures = ConcurrentLinkedQueue() + val writerCount = 4 + val callsPerWriter = 100 + + val writers = List(writerCount) { writerIndex -> + launch(Dispatchers.Default) { + start.await() + repeat(callsPerWriter) { callIndex -> + gateway.sendKey(profileOne, deviceName, "$writerIndex-$callIndex") + } + } + } + val reader = launch(Dispatchers.Default) { + start.await() + repeat(100) { + try { + gateway.sentKeys.forEach { call -> call.key.length } + } catch (failure: Throwable) { + failures += failure + } + } + } + + start.countDown() + (writers + reader).joinAll() + staleIterators.forEach { iterator -> + try { + iterator.forEachRemaining { call -> call.key.length } + } catch (failure: Throwable) { + failures += failure + } + } + + assertTrue(failures.toList().joinToString(), failures.isEmpty()) + assertEquals(1 + writerCount * callsPerWriter, gateway.sentKeys.size) + } + + @Test + fun infraredLearnResultsCanDifferByProfileDeviceAndKey() = runTest { + val gateway = FakeInfraredGateway() + val infraredDevice = DeviceName("ir-1") + gateway.setLearnResult( + profileOne, + infraredDevice, + "power", + DomainResult.Failure(DomainError.DeviceOffline("20206")), + ) + + assertTrue(gateway.learnKey(profileOne, infraredDevice, "power") is DomainResult.Failure) + assertEquals( + DomainResult.Success(Unit), + gateway.learnKey(profileTwo, infraredDevice, "power"), + ) + assertEquals( + DomainResult.Success(Unit), + gateway.learnKey(profileOne, infraredDevice, "volume-up"), + ) + assertEquals( + DomainResult.Success(Unit), + gateway.learnKey(profileOne, DeviceName("ir-2"), "power"), + ) + } + + @Test + fun infraredSendResultsCanDifferByProfileDeviceAndKey() = runTest { + val gateway = FakeInfraredGateway() + val infraredDevice = DeviceName("ir-1") + gateway.setSendResult( + profileOne, + infraredDevice, + "power", + DomainResult.Failure(DomainError.DeviceOffline("20206")), + ) + + assertTrue(gateway.sendKey(profileOne, infraredDevice, "power") is DomainResult.Failure) + assertEquals( + DomainResult.Success(Unit), + gateway.sendKey(profileTwo, infraredDevice, "power"), + ) + assertEquals( + DomainResult.Success(Unit), + gateway.sendKey(profileOne, infraredDevice, "volume-up"), + ) + assertEquals( + DomainResult.Success(Unit), + gateway.sendKey(profileOne, DeviceName("ir-2"), "power"), + ) + } } diff --git a/testing/fakes/src/test/kotlin/com/flagship/abox/manager/testing/fakes/FakeInfraredKeyRepositoryTest.kt b/testing/fakes/src/test/kotlin/com/flagship/abox/manager/testing/fakes/FakeInfraredKeyRepositoryTest.kt new file mode 100644 index 0000000..6e3dd45 --- /dev/null +++ b/testing/fakes/src/test/kotlin/com/flagship/abox/manager/testing/fakes/FakeInfraredKeyRepositoryTest.kt @@ -0,0 +1,299 @@ +package com.flagship.abox.manager.testing.fakes + +import com.flagship.abox.manager.domain.DeviceName +import com.flagship.abox.manager.domain.DomainError +import com.flagship.abox.manager.domain.DomainResult +import com.flagship.abox.manager.domain.ProviderProfileId +import com.flagship.abox.manager.domain.infrared.INTERRUPTED_LEARNING_ERROR_DETAIL +import com.flagship.abox.manager.domain.infrared.InfraredKeyId +import com.flagship.abox.manager.domain.infrared.InfraredKeyRef +import com.flagship.abox.manager.domain.infrared.InfraredKeyStatus +import com.flagship.abox.manager.domain.infrared.SavedInfraredKey +import kotlinx.coroutines.CoroutineStart +import kotlinx.coroutines.async +import kotlinx.coroutines.flow.first +import kotlinx.coroutines.flow.take +import kotlinx.coroutines.flow.toList +import kotlinx.coroutines.test.runTest +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNull +import org.junit.Assert.assertTrue +import org.junit.Test + +class FakeInfraredKeyRepositoryTest { + private val profileOne = ProviderProfileId("one") + private val profileTwo = ProviderProfileId("two") + private val deviceOne = DeviceName("ir-1") + private val deviceTwo = DeviceName("ir-2") + + @Test + fun observeKeysEmitsChangesAndFiltersByProfileAndDevice() = runTest { + val repository = FakeInfraredKeyRepository() + val emissions = backgroundScope.async(start = CoroutineStart.UNDISPATCHED) { + repository.observeKeys(profileOne, deviceOne).take(2).toList() + } + + repository.insert(savedKey(id = "matching")) + + assertEquals( + listOf( + DomainResult.Success(emptyList()), + DomainResult.Success(listOf(savedKey(id = "matching"))), + ), + emissions.await(), + ) + + repository.insert(savedKey(id = "other-profile", profileId = profileTwo)) + repository.insert(savedKey(id = "other-device", deviceName = deviceTwo)) + + assertEquals( + DomainResult.Success(listOf(savedKey(id = "matching"))), + repository.observeKeys(profileOne, deviceOne).first(), + ) + } + + @Test + fun getKeyReturnsOnlyTheMatchingProfileAndId() = runTest { + val repository = FakeInfraredKeyRepository() + repository.insert(savedKey(id = "power")) + + assertEquals( + DomainResult.Success(savedKey(id = "power")), + repository.getKey(InfraredKeyRef(profileOne, InfraredKeyId("power"))), + ) + assertEquals( + DomainResult.Success(null), + repository.getKey(InfraredKeyRef(profileTwo, InfraredKeyId("power"))), + ) + } + + @Test + fun insertRejectsDuplicateIdAndDuplicateProviderDeviceSdkBinding() = runTest { + val repository = FakeInfraredKeyRepository() + assertEquals(DomainResult.Success(Unit), repository.insert(savedKey(id = "power"))) + + val duplicateId = repository.insert( + savedKey( + id = "power", + profileId = profileTwo, + deviceName = deviceTwo, + sdkKey = "other-sdk-key", + ), + ) + val duplicateBinding = repository.insert( + savedKey(id = "volume", displayName = "Volume"), + ) + + assertInvalidRequest(duplicateId) + assertInvalidRequest(duplicateBinding) + assertEquals( + DomainResult.Success(listOf(savedKey(id = "power"))), + repository.observeKeys(profileOne, deviceOne).first(), + ) + } + + @Test + fun transitionStatusRequiresExpectedStatusAndUpdatesFailureContextAtomically() = runTest { + val repository = FakeInfraredKeyRepository() + val ref = InfraredKeyRef(profileOne, InfraredKeyId("power")) + repository.insert(savedKey(id = "power", status = InfraredKeyStatus.LEARNING)) + + val rejected = repository.transitionStatus( + ref = ref, + expectedStatuses = setOf(InfraredKeyStatus.READY), + targetStatus = InfraredKeyStatus.FAILED, + lastErrorCode = "20206", + lastErrorDetail = "offline", + updatedAtEpochMillis = 20L, + ) + assertInvalidRequest(rejected) + assertEquals(InfraredKeyStatus.LEARNING, repository.successfulKey(ref)?.status) + assertNull(repository.successfulKey(ref)?.lastErrorCode) + assertNull(repository.successfulKey(ref)?.lastErrorDetail) + + assertEquals( + DomainResult.Success(Unit), + repository.transitionStatus( + ref = ref, + expectedStatuses = setOf(InfraredKeyStatus.LEARNING), + targetStatus = InfraredKeyStatus.FAILED, + lastErrorCode = "20206", + lastErrorDetail = "offline", + updatedAtEpochMillis = 20L, + ), + ) + assertEquals( + savedKey( + id = "power", + status = InfraredKeyStatus.FAILED, + lastErrorCode = "20206", + lastErrorDetail = "offline", + updatedAtEpochMillis = 20L, + ), + repository.successfulKey(ref), + ) + } + + @Test + fun renameUpdatesDisplayNameAndTimestamp() = runTest { + val repository = FakeInfraredKeyRepository() + val ref = InfraredKeyRef(profileOne, InfraredKeyId("power")) + repository.insert(savedKey(id = "power", status = InfraredKeyStatus.READY)) + + assertEquals( + DomainResult.Success(Unit), + repository.rename(ref, displayName = "Main Power", updatedAtEpochMillis = 30L), + ) + assertEquals("Main Power", repository.successfulKey(ref)?.displayName) + assertEquals(30L, repository.successfulKey(ref)?.updatedAtEpochMillis) + } + + @Test + fun deleteRejectsLearningKeysAndRemovesOtherStatuses() = runTest { + val repository = FakeInfraredKeyRepository() + val learningRef = InfraredKeyRef(profileOne, InfraredKeyId("learning")) + val readyRef = InfraredKeyRef(profileOne, InfraredKeyId("ready")) + repository.insert(savedKey(id = "learning", sdkKey = "learning", status = InfraredKeyStatus.LEARNING)) + repository.insert(savedKey(id = "ready", sdkKey = "ready", status = InfraredKeyStatus.READY)) + + assertInvalidRequest(repository.deleteIfNotLearning(learningRef)) + assertEquals(DomainResult.Success(Unit), repository.deleteIfNotLearning(readyRef)) + assertTrue(repository.successfulKey(learningRef) != null) + assertNull(repository.successfulKey(readyRef)) + } + + @Test + fun failInterruptedLearningRecoversOnlyLearningKeysForOneProfileWithFixedDetail() = runTest { + val repository = FakeInfraredKeyRepository() + repository.insert(savedKey(id = "one-learning", sdkKey = "one-learning")) + repository.insert( + savedKey( + id = "one-ready", + sdkKey = "one-ready", + status = InfraredKeyStatus.READY, + ), + ) + repository.insert( + savedKey( + id = "two-learning", + profileId = profileTwo, + sdkKey = "two-learning", + ), + ) + + assertEquals( + DomainResult.Success(1), + repository.failInterruptedLearning(profileOne, updatedAtEpochMillis = 40L), + ) + + val recovered = repository.successfulKey( + InfraredKeyRef(profileOne, InfraredKeyId("one-learning")), + ) + assertEquals(InfraredKeyStatus.FAILED, recovered?.status) + assertNull(recovered?.lastErrorCode) + assertEquals(INTERRUPTED_LEARNING_ERROR_DETAIL, recovered?.lastErrorDetail) + assertEquals(40L, recovered?.updatedAtEpochMillis) + assertEquals( + InfraredKeyStatus.READY, + repository.successfulKey(InfraredKeyRef(profileOne, InfraredKeyId("one-ready")))?.status, + ) + assertEquals( + InfraredKeyStatus.LEARNING, + repository.successfulKey(InfraredKeyRef(profileTwo, InfraredKeyId("two-learning")))?.status, + ) + assertEquals( + DomainResult.Success(0), + repository.failInterruptedLearning(profileOne, updatedAtEpochMillis = 50L), + ) + } + + @Test + fun failInterruptedLearningRespectsCutoffEpochMillis() = runTest { + val repository = FakeInfraredKeyRepository() + repository.insert( + savedKey( + id = "old-learning", + sdkKey = "old-learning", + status = InfraredKeyStatus.LEARNING, + ).copy(createdAtEpochMillis = 100L), + ) + repository.insert( + savedKey( + id = "new-learning", + sdkKey = "new-learning", + status = InfraredKeyStatus.LEARNING, + ).copy(createdAtEpochMillis = 200L), + ) + + val result = repository.failInterruptedLearning( + profileId = profileOne, + cutoffEpochMillis = 150L, + updatedAtEpochMillis = 150L, + ) + + assertEquals(DomainResult.Success(1), result) + assertEquals( + InfraredKeyStatus.FAILED, + repository.successfulKey(InfraredKeyRef(profileOne, InfraredKeyId("old-learning")))?.status, + ) + assertEquals( + InfraredKeyStatus.LEARNING, + repository.successfulKey(InfraredKeyRef(profileOne, InfraredKeyId("new-learning")))?.status, + ) + } + + @Test + fun deviceConfigurationIsIsolatedByProfile() = runTest { + val repository = FakeInfraredDeviceConfigurationRepository() + + assertEquals(DomainResult.Success(null), repository.observeDeviceName(profileOne).first()) + assertEquals( + DomainResult.Success(Unit), + repository.setDeviceName(profileOne, deviceOne), + ) + assertEquals(DomainResult.Success(deviceOne), repository.observeDeviceName(profileOne).first()) + assertEquals(DomainResult.Success(null), repository.observeDeviceName(profileTwo).first()) + } + + @Test + fun deviceConfigurationRejectsBlankOrSurroundingWhitespace() = runTest { + val repository = FakeInfraredDeviceConfigurationRepository() + + assertInvalidRequest(repository.setDeviceName(profileOne, DeviceName(" "))) + assertInvalidRequest(repository.setDeviceName(profileOne, DeviceName(" ir-1"))) + assertInvalidRequest(repository.setDeviceName(profileOne, DeviceName("ir-1 "))) + assertEquals(DomainResult.Success(null), repository.observeDeviceName(profileOne).first()) + } + + private fun savedKey( + id: String, + profileId: ProviderProfileId = profileOne, + deviceName: DeviceName = deviceOne, + displayName: String = "Power", + sdkKey: String = "power", + status: InfraredKeyStatus = InfraredKeyStatus.LEARNING, + lastErrorCode: String? = null, + lastErrorDetail: String? = null, + updatedAtEpochMillis: Long = 10L, + ) = SavedInfraredKey( + id = InfraredKeyId(id), + profileId = profileId, + deviceName = deviceName, + displayName = displayName, + sdkKey = sdkKey, + status = status, + lastErrorCode = lastErrorCode, + lastErrorDetail = lastErrorDetail, + createdAtEpochMillis = 10L, + updatedAtEpochMillis = updatedAtEpochMillis, + ) + + private suspend fun FakeInfraredKeyRepository.successfulKey( + ref: InfraredKeyRef, + ): SavedInfraredKey? = (getKey(ref) as DomainResult.Success).value + + private fun assertInvalidRequest(result: DomainResult<*>) { + assertTrue(result is DomainResult.Failure) + assertTrue((result as DomainResult.Failure).error is DomainError.InvalidRequest) + } +}