feat: wire infrared remote screen and settings navigation

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<String, KClass<out DomainError>>(
+            "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")

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

android/app/build.gradle.kts

@@ -45,6 +45,15 @@ android {
     kotlinOptions {
         jvmTarget = "17"
     }
+
+    packaging {
+        resources {
+            excludes += "/META-INF/{AL2.0,LGPL2.1}"
+            excludes += "/META-INF/DEPENDENCIES"
+            excludes += "/META-INF/LICENSE*"
+            excludes += "/META-INF/NOTICE*"
+        }
+    }
 }
 
 kapt {
@@ -54,7 +63,9 @@ kapt {
 dependencies {
     implementation(project(":domain"))
     implementation(project(":android:core:designsystem"))
+    implementation(project(":android:feature:infrared"))
     debugImplementation(project(":testing:fakes"))
+    debugImplementation(project(":absdk-bridge"))
 
     implementation(platform(libs.compose.bom))
     implementation(libs.androidx.activity.compose)
@@ -68,6 +79,7 @@ dependencies {
     kapt(libs.hilt.compiler)
 
     testImplementation(libs.junit)
+    testImplementation(libs.kotlinx.coroutines.test)
     androidTestImplementation(platform(libs.compose.bom))
     androidTestImplementation(libs.androidx.junit)
     androidTestImplementation(libs.espresso.core)

android/app/src/androidTest/kotlin/com/flagship/abox/manager/ui/ABoxManagerAppTest.kt

@@ -0,0 +1,26 @@
+package com.flagship.abox.manager.ui
+
+import androidx.compose.ui.test.assertIsDisplayed
+import androidx.compose.ui.test.junit4.createAndroidComposeRule
+import androidx.compose.ui.test.onNodeWithTag
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.performClick
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.flagship.abox.manager.MainActivity
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class ABoxManagerAppTest {
+
+    @get:Rule
+    val composeTestRule = createAndroidComposeRule<MainActivity>()
+
+    @Test
+    fun opensInfraredControlScreenFromFoundationScreen() {
+        composeTestRule.onNodeWithText("Infrared Control").performClick()
+        composeTestRule.onNodeWithTag("infrared_mode_label").assertIsDisplayed()
+        composeTestRule.onNodeWithTag("infrared_device_name_input").assertIsDisplayed()
+    }
+}

android/app/src/debug/AndroidManifest.xml

@@ -0,0 +1,4 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <uses-permission android:name="android.permission.INTERNET" />
+    <application android:usesCleartextTraffic="true" />
+</manifest>

android/app/src/debug/kotlin/com/flagship/abox/manager/di/DebugRoutingInfraredGateway.kt

@@ -0,0 +1,41 @@
+package com.flagship.abox.manager.di
+
+import com.flagship.abox.manager.domain.DeviceName
+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 com.flagship.abox.manager.infrared.runtime.InfraredRuntimeMode
+import com.flagship.abox.manager.infrared.runtime.InfraredRuntimeModeStore
+
+class DebugRoutingInfraredGateway(
+    private val modeStore: InfraredRuntimeModeStore,
+    private val fakeGateway: InfraredGateway,
+    private val realGateway: InfraredGateway,
+) : InfraredGateway {
+
+    private suspend fun delegate(): InfraredGateway {
+        return when (modeStore.currentMode()) {
+            InfraredRuntimeMode.REAL_ABSDK -> realGateway
+            InfraredRuntimeMode.FAKE -> fakeGateway
+        }
+    }
+
+    override suspend fun sendKey(
+        profileId: ProviderProfileId,
+        deviceName: DeviceName,
+        key: String,
+    ): DomainResult<Unit> = delegate().sendKey(profileId, deviceName, key)
+
+    override suspend fun learnKey(
+        profileId: ProviderProfileId,
+        deviceName: DeviceName,
+        key: String,
+    ): DomainResult<Unit> = delegate().learnKey(profileId, deviceName, key)
+
+    override suspend fun downloadCodes(
+        profileId: ProviderProfileId,
+        codes: List<InfraredCode>,
+    ): DomainResult<List<InfraredCodeDownloadResult>> = delegate().downloadCodes(profileId, codes)
+}

android/app/src/debug/kotlin/com/flagship/abox/manager/di/FoundationModule.kt

@@ -1,10 +1,13 @@
 package com.flagship.abox.manager.di
 
+import com.flagship.abox.manager.absdk.bridge.AbsdkBridge
+import com.flagship.abox.manager.absdk.bridge.CleartextAbsdkTransport
 import com.flagship.abox.manager.domain.DeviceCatalog
 import com.flagship.abox.manager.domain.InfraredGateway
 import com.flagship.abox.manager.domain.SessionGateway
 import com.flagship.abox.manager.domain.SocketGateway
 import com.flagship.abox.manager.domain.TemperatureHumidityGateway
+import com.flagship.abox.manager.infrared.runtime.InfraredRuntimeModeStore
 import com.flagship.abox.manager.testing.fakes.FakeDeviceCatalog
 import com.flagship.abox.manager.testing.fakes.FakeInfraredGateway
 import com.flagship.abox.manager.testing.fakes.FakeSessionGateway
@@ -21,7 +24,9 @@ import javax.inject.Singleton
 object FoundationModule {
     @Provides
     @Singleton
-    fun provideSessionGateway(): SessionGateway = FakeSessionGateway()
+    fun provideSessionGateway(
+        @OptIn(CleartextAbsdkTransport::class) real: AbsdkBridge,
+    ): SessionGateway = real
 
     @Provides
     @Singleton
@@ -38,5 +43,18 @@ object FoundationModule {
 
     @Provides
     @Singleton
-    fun provideInfraredGateway(): InfraredGateway = FakeInfraredGateway()
+    fun provideFakeInfraredGateway(): FakeInfraredGateway = 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)
 }

android/app/src/main/kotlin/com/flagship/abox/manager/ui/ABoxManagerApp.kt

@@ -2,38 +2,72 @@ package com.flagship.abox.manager.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.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.material3.Card
+import androidx.compose.material3.CardDefaults
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.OutlinedTextField
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
+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.res.stringResource
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.input.PasswordVisualTransformation
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
+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.R
 import com.flagship.abox.manager.designsystem.ABoxButton
 import com.flagship.abox.manager.designsystem.ABoxSurface
 import com.flagship.abox.manager.designsystem.ABoxTheme
+import com.flagship.abox.manager.infrared.remote.ui.InfraredRemoteRoute
+import com.flagship.abox.manager.infrared.ui.InfraredControlRoute
 
 private const val FOUNDATION_ROUTE = "foundation"
 private const val PLACEHOLDER_ROUTE = "placeholder"
+private const val INFRARED_REMOTE_ROUTE = "infrared_remote/{profileId}"
+private const val INFRARED_SETTINGS_ROUTE = "infrared_settings/{profileId}"
+private const val TEMPORARY_ABOX_PROFILE_ID = "abox"
 
 @Composable
 fun ABoxManagerApp() {
     ABoxTheme {
         ABoxSurface(modifier = Modifier.fillMaxSize()) {
             val navController = rememberNavController()
+            var sessionMessage by remember { mutableStateOf<String?>(null) }
+
             NavHost(
                 navController = navController,
                 startDestination = FOUNDATION_ROUTE,
             ) {
                 composable(FOUNDATION_ROUTE) {
-                    FoundationScreen(onContinue = { navController.navigate(PLACEHOLDER_ROUTE) })
+                    FoundationScreen(
+                        sessionInvalidMessage = sessionMessage,
+                        onContinue = { navController.navigate(PLACEHOLDER_ROUTE) },
+                        onOpenInfrared = {
+                            sessionMessage = null
+                            navController.navigate("infrared_remote/$TEMPORARY_ABOX_PROFILE_ID")
+                        },
+                    )
                 }
                 composable(PLACEHOLDER_ROUTE) {
                     MessageScreen(
@@ -41,29 +75,179 @@ fun ABoxManagerApp() {
                         description = stringResource(R.string.placeholder_description),
                     )
                 }
+                composable(
+                    route = INFRARED_REMOTE_ROUTE,
+                    arguments = listOf(
+                        navArgument("profileId") { type = NavType.StringType },
+                    ),
+                ) {
+                    val sessionInvalidText = stringResource(R.string.infrared_session_invalid_message)
+                    InfraredRemoteRoute(
+                        onBack = { navController.popBackStack() },
+                        onOpenSettings = {
+                            navController.navigate("infrared_settings/$TEMPORARY_ABOX_PROFILE_ID")
+                        },
+                        onSessionInvalid = {
+                            sessionMessage = sessionInvalidText
+                            navController.popBackStack(FOUNDATION_ROUTE, inclusive = false)
+                        },
+                    )
+                }
+                composable(
+                    route = INFRARED_SETTINGS_ROUTE,
+                    arguments = listOf(
+                        navArgument("profileId") { type = NavType.StringType },
+                    ),
+                ) {
+                    val sessionInvalidText = stringResource(R.string.infrared_session_invalid_message)
+                    InfraredControlRoute(
+                        onBack = { navController.popBackStack() },
+                        onSessionInvalid = {
+                            sessionMessage = sessionInvalidText
+                            navController.popBackStack(FOUNDATION_ROUTE, inclusive = false)
+                        },
+                    )
+                }
             }
         }
     }
 }
 
 @Composable
-private fun FoundationScreen(onContinue: () -> Unit) {
+private fun FoundationScreen(
+    sessionInvalidMessage: String?,
+    onContinue: () -> Unit,
+    onOpenInfrared: () -> Unit,
+    viewModel: FoundationViewModel = hiltViewModel(),
+) {
+    val state by viewModel.uiState.collectAsStateWithLifecycle()
+
     Column(
         modifier = Modifier
             .fillMaxSize()
-            .padding(32.dp),
+            .padding(24.dp),
         horizontalAlignment = Alignment.CenterHorizontally,
-        verticalArrangement = Arrangement.Center,
+        verticalArrangement = Arrangement.spacedBy(16.dp),
     ) {
-        MessageScreen(
+        Spacer(modifier = Modifier.height(8.dp))
-            title = stringResource(R.string.foundation_title),
+        Text(
-            description = stringResource(R.string.foundation_description),
+            text = stringResource(R.string.foundation_title),
+            style = MaterialTheme.typography.headlineMedium,
+            fontWeight = FontWeight.Bold,
+            textAlign = TextAlign.Center,
+        )
+        Text(
+            text = sessionInvalidMessage ?: stringResource(R.string.foundation_description),
+            style = MaterialTheme.typography.bodyMedium,
+            color = if (sessionInvalidMessage != null) MaterialTheme.colorScheme.error else MaterialTheme.colorScheme.onSurfaceVariant,
+            textAlign = TextAlign.Center,
+        )
+
+        // 临时网关登录卡片
+        Card(
+            modifier = Modifier.fillMaxWidth(),
+            colors = CardDefaults.cardColors(
+                containerColor = MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.5f),
+            ),
+        ) {
+            Column(
+                modifier = Modifier.padding(16.dp),
+                verticalArrangement = Arrangement.spacedBy(12.dp),
+            ) {
+                Row(
+                    modifier = Modifier.fillMaxWidth(),
+                    horizontalArrangement = Arrangement.SpaceBetween,
+                    verticalAlignment = Alignment.CenterVertically,
+                ) {
+                    Text(
+                        text = "ABox 网关登录 (Real 模式前置)",
+                        style = MaterialTheme.typography.titleMedium,
+                        fontWeight = FontWeight.SemiBold,
+                    )
+                    if (state.session != null) {
+                        OutlinedButton(
+                            onClick = viewModel::logout,
+                            enabled = !state.isLoading,
+                        ) {
+                            Text("退出")
+                        }
+                    }
+                }
+
+                if (state.session == null) {
+                    OutlinedTextField(
+                        value = state.usernameInput,
+                        onValueChange = viewModel::onUsernameChanged,
+                        label = { Text("账号 (默认 a)") },
+                        singleLine = true,
+                        modifier = Modifier.fillMaxWidth(),
+                    )
+                    OutlinedTextField(
+                        value = state.passwordInput,
+                        onValueChange = viewModel::onPasswordChanged,
+                        label = { Text("密码 (默认 a)") },
+                        visualTransformation = PasswordVisualTransformation(),
+                        singleLine = true,
+                        modifier = Modifier.fillMaxWidth(),
                     )
                     ABoxButton(
+                        onClick = viewModel::login,
+                        modifier = Modifier.fillMaxWidth(),
+                        enabled = !state.isLoading,
+                    ) {
+                        if (state.isLoading) {
+                            CircularProgressIndicator(
+                                modifier = Modifier.size(20.dp),
+                                strokeWidth = 2.dp,
+                                color = MaterialTheme.colorScheme.onPrimary,
+                            )
+                        } else {
+                            Text("连接并登录网关")
+                        }
+                    }
+                } else {
+                    Text(
+                        text = "✅ 已登录 ABox (账号: ${state.session?.username?.value})",
+                        style = MaterialTheme.typography.bodyMedium,
+                        color = MaterialTheme.colorScheme.primary,
+                        fontWeight = FontWeight.Medium,
+                    )
+                    Text(
+                        text = "网关会话已建立，现在可以在红外控制中使用真实 ABSDK 模式。",
+                        style = MaterialTheme.typography.bodySmall,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant,
+                    )
+                }
+
+                state.errorMessage?.let { error ->
+                    Text(
+                        text = "⚠️ $error",
+                        style = MaterialTheme.typography.bodySmall,
+                        color = MaterialTheme.colorScheme.error,
+                    )
+                }
+                state.successMessage?.let { success ->
+                    Text(
+                        text = "ℹ️ $success",
+                        style = MaterialTheme.typography.bodySmall,
+                        color = MaterialTheme.colorScheme.primary,
+                    )
+                }
+            }
+        }
+
+        Spacer(modifier = Modifier.weight(1f))
+
+        ABoxButton(
+            onClick = onOpenInfrared,
+            modifier = Modifier.fillMaxWidth(),
+        ) {
+            Text(stringResource(R.string.infrared_control_action))
+        }
+
+        OutlinedButton(
             onClick = onContinue,
-            modifier = Modifier
+            modifier = Modifier.fillMaxWidth(),
-                .fillMaxWidth()
-                .padding(top = 24.dp),
         ) {
             Text(stringResource(R.string.continue_action))
         }
@@ -82,12 +266,12 @@ private fun MessageScreen(
     ) {
         Text(
             text = title,
-            style = androidx.compose.material3.MaterialTheme.typography.headlineMedium,
+            style = MaterialTheme.typography.headlineMedium,
             textAlign = TextAlign.Center,
         )
         Text(
             text = description,
-            style = androidx.compose.material3.MaterialTheme.typography.bodyLarge,
+            style = MaterialTheme.typography.bodyLarge,
             textAlign = TextAlign.Center,
         )
     }

android/app/src/main/kotlin/com/flagship/abox/manager/ui/FoundationViewModel.kt

@@ -0,0 +1,103 @@
+package com.flagship.abox.manager.ui
+
+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.LoginCredentials
+import com.flagship.abox.manager.domain.Password
+import com.flagship.abox.manager.domain.ProviderProfileId
+import com.flagship.abox.manager.domain.Session
+import com.flagship.abox.manager.domain.SessionGateway
+import com.flagship.abox.manager.domain.Username
+import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.launch
+import javax.inject.Inject
+
+data class FoundationUiState(
+    val usernameInput: String = "a",
+    val passwordInput: String = "a",
+    val isLoading: Boolean = false,
+    val session: Session? = null,
+    val errorMessage: String? = null,
+    val successMessage: String? = null,
+)
+
+@HiltViewModel
+class FoundationViewModel @Inject constructor(
+    private val sessionGateway: SessionGateway,
+) : ViewModel() {
+
+    private val profileId = ProviderProfileId("abox")
+    private val _uiState = MutableStateFlow(FoundationUiState())
+    val uiState: StateFlow<FoundationUiState> = _uiState.asStateFlow()
+
+    init {
+        viewModelScope.launch {
+            sessionGateway.observeSession(profileId).collect { session ->
+                _uiState.value = _uiState.value.copy(session = session)
+            }
+        }
+    }
+
+    fun onUsernameChanged(value: String) {
+        _uiState.value = _uiState.value.copy(usernameInput = value, errorMessage = null)
+    }
+
+    fun onPasswordChanged(value: String) {
+        _uiState.value = _uiState.value.copy(passwordInput = value, errorMessage = null)
+    }
+
+    fun login() {
+        val username = _uiState.value.usernameInput.trim()
+        val password = _uiState.value.passwordInput.trim()
+        if (username.isBlank() || password.isBlank()) {
+            _uiState.value = _uiState.value.copy(errorMessage = "用户名和密码不能为空")
+            return
+        }
+
+        _uiState.value = _uiState.value.copy(isLoading = true, errorMessage = null, successMessage = null)
+
+        viewModelScope.launch {
+            val result = sessionGateway.login(
+                profileId = profileId,
+                credentials = LoginCredentials(Username(username), Password(password)),
+            )
+            when (result) {
+                is DomainResult.Success -> {
+                    _uiState.value = _uiState.value.copy(
+                        isLoading = false,
+                        session = result.value,
+                        successMessage = "登录成功！已获取 ABox 会话 Token",
+                    )
+                }
+                is DomainResult.Failure -> {
+                    val detail = when (val error = result.error) {
+                        is DomainError.Authentication -> "认证失败 (错误码: ${error.externalCode ?: "20004"})，请检查账号密码"
+                        is DomainError.Network -> "网络连接失败: ${error.detail ?: "请确认已连接网关 WiFi"}"
+                        is DomainError.TokenInvalid -> "Token 无效"
+                        else -> error.detail ?: "登录失败 (${error.externalCode ?: "unknown"})"
+                    }
+                    _uiState.value = _uiState.value.copy(
+                        isLoading = false,
+                        errorMessage = detail,
+                    )
+                }
+            }
+        }
+    }
+
+    fun logout() {
+        viewModelScope.launch {
+            sessionGateway.logout(profileId)
+            _uiState.value = _uiState.value.copy(session = null, successMessage = "已退出登录")
+        }
+    }
+
+    fun clearMessage() {
+        _uiState.value = _uiState.value.copy(errorMessage = null, successMessage = null)
+    }
+}

android/app/src/main/res/values-zh-rCN/strings.xml

@@ -5,4 +5,6 @@
     <string name="continue_action">继续</string>
     <string name="placeholder_title">功能模块可以开始开发</string>
     <string name="placeholder_description">设备、红外和情景页面将由对应模块负责人实现。</string>
+    <string name="infrared_control_action">红外控制</string>
+    <string name="infrared_session_invalid_message">ABox 会话未认证，请先登录。</string>
 </resources>

android/app/src/main/res/values/strings.xml

@@ -5,4 +5,6 @@
     <string name="continue_action">Continue</string>
     <string name="placeholder_title">Feature development can start</string>
     <string name="placeholder_description">Device, infrared and scene screens will be added by their module owners.</string>
+    <string name="infrared_control_action">Infrared Control</string>
+    <string name="infrared_session_invalid_message">ABox session is not authenticated. Please log in first.</string>
 </resources>

android/app/src/release/kotlin/com/flagship/abox/manager/di/InfraredReleaseModule.kt

@@ -0,0 +1,47 @@
+package com.flagship.abox.manager.di
+
+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 dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import javax.inject.Singleton
+
+@Module
+@InstallIn(SingletonComponent::class)
+object InfraredReleaseModule {
+
+    @Provides
+    @Singleton
+    fun provideInfraredGateway(): InfraredGateway = object : InfraredGateway {
+        override suspend fun sendKey(
+            profileId: ProviderProfileId,
+            deviceName: DeviceName,
+            key: String,
+        ): DomainResult<Unit> = disabledFailure()
+
+        override suspend fun learnKey(
+            profileId: ProviderProfileId,
+            deviceName: DeviceName,
+            key: String,
+        ): DomainResult<Unit> = disabledFailure()
+
+        override suspend fun downloadCodes(
+            profileId: ProviderProfileId,
+            codes: List<InfraredCode>,
+        ): DomainResult<List<InfraredCodeDownloadResult>> = disabledFailure()
+
+        private fun <T> disabledFailure(): DomainResult<T> = DomainResult.Failure(
+            DomainError.OperationFailed(
+                externalCode = "REAL_ABSDK_DISABLED",
+                detail = "Infrared hardware transport is disabled in release builds",
+            ),
+        )
+    }
+}

android/app/src/test/kotlin/com/flagship/abox/manager/di/DebugRoutingInfraredGatewayTest.kt

@@ -0,0 +1,70 @@
+package com.flagship.abox.manager.di
+
+import com.flagship.abox.manager.domain.DeviceName
+import com.flagship.abox.manager.domain.DomainResult
+import com.flagship.abox.manager.domain.InfraredCode
+import com.flagship.abox.manager.domain.ProviderProfileId
+import com.flagship.abox.manager.infrared.runtime.InfraredRuntimeMode
+import com.flagship.abox.manager.infrared.runtime.InfraredRuntimeModeStore
+import com.flagship.abox.manager.testing.fakes.FakeInfraredGateway
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.test.runTest
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+private class TestModeStore : InfraredRuntimeModeStore {
+    private val modeFlow = MutableStateFlow(InfraredRuntimeMode.FAKE)
+    override val mode: Flow<InfraredRuntimeMode> = modeFlow
+    override suspend fun currentMode(): InfraredRuntimeMode = modeFlow.value
+    override suspend fun setMode(mode: InfraredRuntimeMode): DomainResult<Unit> {
+        modeFlow.value = mode
+        return DomainResult.Success(Unit)
+    }
+}
+
+class DebugRoutingInfraredGatewayTest {
+
+    private val modeStore = TestModeStore()
+    private val fake = FakeInfraredGateway()
+    private val real = FakeInfraredGateway()
+    private val router = DebugRoutingInfraredGateway(modeStore, fake, real)
+
+    private val profile = ProviderProfileId("profile1")
+    private val device = DeviceName("ir-1")
+
+    @Test
+    fun delegatesToFakeByDefault() = runTest {
+        val result = router.sendKey(profile, device, "key1")
+        assertTrue(result is DomainResult.Success)
+        assertEquals(1, fake.sentKeys.size)
+        assertTrue(real.sentKeys.isEmpty())
+
+        router.learnKey(profile, device, "key2")
+        assertEquals(1, fake.learnedKeys.size)
+        assertTrue(real.learnedKeys.isEmpty())
+
+        router.downloadCodes(profile, listOf(InfraredCode(device, "k", "code")))
+        assertEquals(1, fake.downloadCalls.size)
+        assertTrue(real.downloadCalls.isEmpty())
+    }
+
+    @Test
+    fun delegatesToRealWhenModeIsRealAbsdk() = runTest {
+        modeStore.setMode(InfraredRuntimeMode.REAL_ABSDK)
+
+        val result = router.sendKey(profile, device, "key1")
+        assertTrue(result is DomainResult.Success)
+        assertTrue(fake.sentKeys.isEmpty())
+        assertEquals(1, real.sentKeys.size)
+
+        router.learnKey(profile, device, "key2")
+        assertTrue(fake.learnedKeys.isEmpty())
+        assertEquals(1, real.learnedKeys.size)
+
+        router.downloadCodes(profile, listOf(InfraredCode(device, "k", "code")))
+        assertTrue(fake.downloadCalls.isEmpty())
+        assertEquals(1, real.downloadCalls.size)
+    }
+}

android/feature/infrared/build.gradle.kts

@@ -0,0 +1,76 @@
+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.datastore.preferences)
+    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)
+}

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')"
+    ]
+  }
+}

android/feature/infrared/src/androidTest/kotlin/com/flagship/abox/manager/infrared/data/local/RoomInfraredKeyRepositoryTest.kt

@@ -0,0 +1,175 @@
+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<Context>()
+        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 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,
+        )
+    }
+}

android/feature/infrared/src/androidTest/kotlin/com/flagship/abox/manager/infrared/remote/InfraredRemoteScreenTest.kt

@@ -0,0 +1,45 @@
+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
+
+        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)
+    }
+}

android/feature/infrared/src/androidTest/kotlin/com/flagship/abox/manager/infrared/ui/InfraredControlScreenTest.kt

@@ -0,0 +1,121 @@
+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.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.infrared.InfraredKeyId
+import com.flagship.abox.manager.domain.infrared.InfraredKeyStatus
+import com.flagship.abox.manager.domain.infrared.SavedInfraredKey
+import com.flagship.abox.manager.infrared.runtime.InfraredRuntimeMode
+import org.junit.Assert.assertEquals
+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 displaysModeAndDeviceInformation() {
+        val state = InfraredControlUiState(
+            runtimeMode = InfraredRuntimeMode.FAKE,
+            effectiveProfileId = ProviderProfileId("abox:infrared-fake"),
+            savedDeviceName = DeviceName("ir-living"),
+            loading = false,
+        )
+
+        composeTestRule.setContent {
+            InfraredControlScreen(
+                state = state,
+                nextSlot = 1,
+                onBack = {},
+                onSessionInvalid = {},
+                onDeviceNameChanged = {},
+                onSaveDeviceName = {},
+                onLearn = { _, _ -> },
+                onRetry = {},
+                onSend = {},
+                onRename = { _, _ -> },
+                onDelete = {},
+                onModeChanged = {},
+                onMessageShown = {},
+            )
+        }
+
+        composeTestRule.onNodeWithTag("infrared_mode_label").assertIsDisplayed()
+        composeTestRule.onNodeWithTag("infrared_device_name_input").assertIsDisplayed()
+        composeTestRule.onNodeWithTag("infrared_save_device").assertIsDisplayed()
+        composeTestRule.onNodeWithTag("infrared_learn_new_key").assertIsDisplayed()
+    }
+
+    @Test
+    fun rendersKeysWithCorrectActionButtons() {
+        val readyKey = SavedInfraredKey(
+            id = InfraredKeyId("k-ready"),
+            profileId = ProviderProfileId("abox"),
+            deviceName = DeviceName("ir-1"),
+            displayName = "Power Key",
+            sdkKey = "1",
+            status = InfraredKeyStatus.READY,
+            lastErrorCode = null,
+            lastErrorDetail = null,
+            createdAtEpochMillis = 100L,
+            updatedAtEpochMillis = 100L,
+        )
+        val failedKey = SavedInfraredKey(
+            id = InfraredKeyId("k-failed"),
+            profileId = ProviderProfileId("abox"),
+            deviceName = DeviceName("ir-1"),
+            displayName = "Volume Up",
+            sdkKey = "2",
+            status = InfraredKeyStatus.FAILED,
+            lastErrorCode = "20206",
+            lastErrorDetail = null,
+            createdAtEpochMillis = 200L,
+            updatedAtEpochMillis = 200L,
+        )
+
+        val state = InfraredControlUiState(
+            runtimeMode = InfraredRuntimeMode.REAL_ABSDK,
+            savedDeviceName = DeviceName("ir-1"),
+            keys = listOf(readyKey, failedKey),
+            loading = false,
+        )
+
+        var sentKeyId: InfraredKeyId? = null
+        var retriedKeyId: InfraredKeyId? = null
+
+        composeTestRule.setContent {
+            InfraredControlScreen(
+                state = state,
+                nextSlot = 3,
+                onBack = {},
+                onSessionInvalid = {},
+                onDeviceNameChanged = {},
+                onSaveDeviceName = {},
+                onLearn = { _, _ -> },
+                onRetry = { retriedKeyId = it },
+                onSend = { sentKeyId = it },
+                onRename = { _, _ -> },
+                onDelete = {},
+                onModeChanged = {},
+                onMessageShown = {},
+            )
+        }
+
+        composeTestRule.onNodeWithTag("infrared_key_k-ready").assertIsDisplayed()
+        composeTestRule.onNodeWithTag("infrared_send_k-ready").performClick()
+        assertEquals(InfraredKeyId("k-ready"), sentKeyId)
+
+        composeTestRule.onNodeWithTag("infrared_key_k-failed").assertIsDisplayed()
+        composeTestRule.onNodeWithTag("infrared_retry_k-failed").performClick()
+        assertEquals(InfraredKeyId("k-failed"), retriedKeyId)
+    }
+}

android/feature/infrared/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/application/InfraredLearningCoordinator.kt

@@ -0,0 +1,32 @@
+package com.flagship.abox.manager.infrared.application
+
+import com.flagship.abox.manager.domain.DeviceName
+import com.flagship.abox.manager.domain.ProviderProfileId
+import com.flagship.abox.manager.domain.infrared.InfraredKeyRef
+import com.flagship.abox.manager.domain.infrared.LearnInfraredKey
+import com.flagship.abox.manager.domain.infrared.RetryInfraredKeyLearning
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+
+class InfraredLearningCoordinator(
+    private val learnInfraredKey: LearnInfraredKey,
+    private val retryInfraredKeyLearning: RetryInfraredKeyLearning,
+    private val externalScope: CoroutineScope,
+) {
+    fun learn(
+        profileId: ProviderProfileId,
+        deviceName: DeviceName,
+        displayName: String,
+        sdkKey: String? = null,
+    ) {
+        externalScope.launch {
+            learnInfraredKey(profileId, deviceName, displayName, sdkKey)
+        }
+    }
+
+    fun retry(ref: InfraredKeyRef) {
+        externalScope.launch {
+            retryInfraredKeyLearning(ref)
+        }
+    }
+}

android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/data/local/InfraredDao.kt

@@ -0,0 +1,105 @@
+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<List<InfraredKeyEntity>>
+
+    @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<String>,
+        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'
+        """,
+    )
+    suspend fun failInterruptedLearning(
+        profileId: String,
+        targetStatus: String,
+        errorDetail: String,
+        updatedAtEpochMillis: Long,
+    ): Int
+
+    @Query(
+        """
+        SELECT * FROM infrared_device_configuration
+        WHERE profileId = :profileId
+        LIMIT 1
+        """,
+    )
+    fun observeDeviceName(profileId: String): Flow<InfraredDeviceConfigurationEntity?>
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun setDeviceName(entity: InfraredDeviceConfigurationEntity)
+}

android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/data/local/InfraredDatabase.kt

@@ -0,0 +1,16 @@
+package com.flagship.abox.manager.infrared.data.local
+
+import androidx.room.Database
+import androidx.room.RoomDatabase
+
+@Database(
+    entities = [
+        InfraredKeyEntity::class,
+        InfraredDeviceConfigurationEntity::class,
+    ],
+    version = 1,
+    exportSchema = true,
+)
+abstract class InfraredDatabase : RoomDatabase() {
+    abstract fun infraredDao(): InfraredDao
+}

android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/data/local/InfraredEntities.kt

@@ -0,0 +1,33 @@
+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,
+)

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,
+    )
+}

android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/data/local/RoomInfraredKeyRepository.kt

@@ -0,0 +1,190 @@
+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.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<DomainResult<List<SavedInfraredKey>>> {
+        return dao.observeKeys(profileId.value, deviceName.value)
+            .map<List<InfraredKeyEntity>, DomainResult<List<SavedInfraredKey>>> { entities ->
+                DomainResult.Success(entities.map { it.toDomain() })
+            }
+            .catch { throwable ->
+                emit(DomainResult.Failure(mapThrowableToDomainError(throwable)))
+            }
+    }
+
+    override fun observeDeviceName(profileId: ProviderProfileId): Flow<DomainResult<DeviceName?>> {
+        return dao.observeDeviceName(profileId.value)
+            .map<InfraredDeviceConfigurationEntity?, DomainResult<DeviceName?>> { entity ->
+                DomainResult.Success(entity?.deviceName?.let { DeviceName(it) })
+            }
+            .catch { throwable ->
+                emit(DomainResult.Failure(mapThrowableToDomainError(throwable)))
+            }
+    }
+
+    override suspend fun getKey(ref: InfraredKeyRef): DomainResult<SavedInfraredKey?> {
+        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<Unit> {
+        return try {
+            dao.insertKey(key.toEntity())
+            DomainResult.Success(Unit)
+        } catch (throwable: Throwable) {
+            DomainResult.Failure(mapThrowableToDomainError(throwable))
+        }
+    }
+
+    override suspend fun transitionStatus(
+        ref: InfraredKeyRef,
+        expectedStatuses: Set<InfraredKeyStatus>,
+        targetStatus: InfraredKeyStatus,
+        lastErrorCode: String?,
+        lastErrorDetail: String?,
+        updatedAtEpochMillis: Long,
+    ): DomainResult<Unit> {
+        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<Unit> {
+        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<Unit> {
+        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,
+        updatedAtEpochMillis: Long,
+    ): DomainResult<Int> {
+        return try {
+            val count = dao.failInterruptedLearning(
+                profileId = profileId.value,
+                targetStatus = InfraredKeyStatus.FAILED.name,
+                errorDetail = INTERRUPTED_LEARNING_ERROR_DETAIL,
+                updatedAtEpochMillis = updatedAtEpochMillis,
+            )
+            DomainResult.Success(count)
+        } catch (throwable: Throwable) {
+            DomainResult.Failure(mapThrowableToDomainError(throwable))
+        }
+    }
+
+    override suspend fun setDeviceName(
+        profileId: ProviderProfileId,
+        deviceName: DeviceName,
+    ): DomainResult<Unit> {
+        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 {
+        return when (throwable) {
+            is SQLiteConstraintException -> DomainError.InvalidRequest(detail = "Database constraint violation")
+            else -> DomainError.Unknown(detail = "Database operation failed")
+        }
+    }
+}

android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/di/InfraredFeatureModule.kt

@@ -0,0 +1,184 @@
+package com.flagship.abox.manager.infrared.di
+
+import android.content.Context
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.PreferenceDataStoreFactory
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.preferencesDataStoreFile
+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.runtime.DataStoreInfraredRuntimeModeStore
+import com.flagship.abox.manager.infrared.runtime.InfraredRuntimeModeStore
+import com.flagship.abox.manager.infrared.runtime.InfraredRuntimeProfileResolver
+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
+
+@Qualifier
+@Retention(AnnotationRetention.BINARY)
+annotation class InfraredDataStore
+
+@Module
+@InstallIn(SingletonComponent::class)
+object InfraredFeatureModule {
+
+    @Provides
+    @Singleton
+    fun provideInfraredDatabase(
+        @ApplicationContext context: Context,
+    ): InfraredDatabase {
+        return Room.databaseBuilder(
+            context,
+            InfraredDatabase::class.java,
+            "abox_infrared.db",
+        ).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
+    @Singleton
+    @InfraredDataStore
+    fun provideInfraredPreferencesDataStore(
+        @ApplicationContext context: Context,
+    ): DataStore<Preferences> {
+        return PreferenceDataStoreFactory.create(
+            produceFile = { context.preferencesDataStoreFile("infrared_preferences") },
+        )
+    }
+
+    @Provides
+    @Singleton
+    fun provideInfraredRuntimeModeStore(
+        @InfraredDataStore dataStore: DataStore<Preferences>,
+    ): InfraredRuntimeModeStore = DataStoreInfraredRuntimeModeStore(dataStore)
+
+    @Provides
+    @Singleton
+    fun provideInfraredRuntimeProfileResolver(): InfraredRuntimeProfileResolver =
+        InfraredRuntimeProfileResolver()
+
+    @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 provideInfraredLearningCoordinator(
+        learnInfraredKey: LearnInfraredKey,
+        retryInfraredKeyLearning: RetryInfraredKeyLearning,
+        @InfraredApplicationScope scope: CoroutineScope,
+    ): InfraredLearningCoordinator = InfraredLearningCoordinator(
+        learnInfraredKey = learnInfraredKey,
+        retryInfraredKeyLearning = retryInfraredKeyLearning,
+        externalScope = scope,
+    )
+}

android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/remote/InfraredRemoteViewModel.kt

@@ -0,0 +1,214 @@
+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.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 com.flagship.abox.manager.domain.infrared.SendInfraredKey
+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.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
+
+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<String, SavedInfraredKey> = 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<String?>(null)
+    private val activeLearningSlotFlow = MutableStateFlow<String?>(null)
+    private val messageFlow = MutableStateFlow<RemoteUiMessage?>(null)
+
+    private val effectiveProfileAndMode: Flow<Pair<ProviderProfileId?, InfraredRuntimeMode>> =
+        runtimeModeStore.mode.flatMapLatest { mode ->
+            if (authenticatedProfileId == null) {
+                flowOf(Pair(null, mode))
+            } else {
+                flowOf(Pair(profileResolver.resolve(authenticatedProfileId, mode), mode))
+            }
+        }
+
+    private val deviceNameFlow: Flow<DomainResult<DeviceName?>> =
+        effectiveProfileAndMode.flatMapLatest { (profile, _) ->
+            if (profile == null) flowOf(DomainResult.Success(null))
+            else deviceConfigurationRepository.observeDeviceName(profile)
+        }
+
+    private val keysFlow: Flow<DomainResult<List<SavedInfraredKey>>> =
+        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<InfraredRemoteUiState> = combine(
+        sceneFlow,
+        isLearningModeFlow,
+        effectiveProfileAndMode,
+        deviceNameFlow,
+        keysFlow,
+        sendingKeySlotFlow,
+        activeLearningSlotFlow,
+        messageFlow,
+    ) { args: Array<Any?> ->
+        val scene = args[0] as RemoteScene
+        val isLearning = args[1] as Boolean
+        val profileAndMode = args[2] as Pair<ProviderProfileId?, InfraredRuntimeMode>
+        val deviceResult = args[3] as DomainResult<DeviceName?>
+        val keysResult = args[4] as DomainResult<List<SavedInfraredKey>>
+        val sendingSlot = args[5] as String?
+        val learningSlot = args[6] as String?
+        val msg = args[7] as RemoteUiMessage?
+
+        val (profile, mode) = profileAndMode
+        val savedDevice = (deviceResult as? DomainResult.Success<DeviceName?>)?.value
+        val keys = (keysResult as? DomainResult.Success<List<SavedInfraredKey>>)?.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 (isLearningModeFlow.value) {
+            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.displayName}")
+                        }
+                        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 ?: "操作失败")
+            }
+        }
+    }
+}

android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/remote/RemoteModels.kt

@@ -0,0 +1,49 @@
+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,
+        )
+    }
+}

android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/remote/ui/AcRemotePanel.kt

@@ -0,0 +1,172 @@
+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.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.remote.RemoteButtonSpec
+import com.flagship.abox.manager.infrared.remote.RemoteSceneConfig
+
+@Composable
+fun AcRemotePanel(
+    learnedSlotMap: Map<String, SavedInfraredKey>,
+    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 = "温度调节",
+            )
+        }
+
+        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<String, SavedInfraredKey>,
+    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 = "❄️ 制冷模式",
+                    color = Color(0xFF38BDF8),
+                    fontSize = 14.sp,
+                    fontWeight = FontWeight.Medium,
+                )
+                Text(
+                    text = "💨 自动风速 | ↔ 扫风",
+                    color = Color(0xFF94A3B8),
+                    fontSize = 12.sp,
+                )
+            }
+
+            Text(
+                text = "26°C",
+                color = Color(0xFF4ADE80),
+                fontSize = 38.sp,
+                fontFamily = FontFamily.Monospace,
+                fontWeight = FontWeight.Bold,
+            )
+        }
+    }
+}

android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/remote/ui/InfraredRemoteScreen.kt

@@ -0,0 +1,246 @@
+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.testTag
+import androidx.compose.ui.res.painterResource
+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.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
+
+@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() }
+
+    LaunchedEffect(state.message) {
+        state.message?.let { msg ->
+            when (msg) {
+                is RemoteUiMessage.Info -> {
+                    snackbarHostState.showSnackbar(msg.text)
+                    onMessageShown()
+                }
+                is RemoteUiMessage.Error -> {
+                    snackbarHostState.showSnackbar(msg.text)
+                    onMessageShown()
+                }
+                is RemoteUiMessage.SessionInvalid -> {
+                    onSessionInvalid()
+                    onMessageShown()
+                }
+            }
+        }
+    }
+
+    Scaffold(
+        topBar = {
+            TopAppBar(
+                title = {
+                    Text(
+                        text = "红外遥控器",
+                        style = MaterialTheme.typography.titleLarge.copy(fontWeight = FontWeight.Bold),
+                    )
+                },
+                navigationIcon = {
+                    TextButton(onClick = onBack) {
+                        Text("返回")
+                    }
+                },
+                actions = {
+                    // 学习模式开关
+                    Row(
+                        verticalAlignment = Alignment.CenterVertically,
+                        horizontalArrangement = Arrangement.spacedBy(4.dp),
+                    ) {
+                        Text(
+                            text = if (state.isLearningMode) "录制中" else "学习模式",
+                            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 = "🔴 红外学习模式已开启：点击任意按键即可录制信号",
+                            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("❄️ 空调遥控") },
+                        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("📺 电视遥控") },
+                        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))
+            }
+        }
+    }
+}

android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/remote/ui/RemoteComponents.kt

@@ -0,0 +1,407 @@
+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,
+        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,
+        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(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(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)
+                    .clickable(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)
+                    .clickable(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)
+                    .clickable(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)
+                    .clickable(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,
+            )
+        }
+    }
+}

android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/remote/ui/TvRemotePanel.kt

@@ -0,0 +1,161 @@
+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.unit.dp
+import com.flagship.abox.manager.domain.infrared.InfraredKeyStatus
+import com.flagship.abox.manager.domain.infrared.SavedInfraredKey
+import com.flagship.abox.manager.infrared.remote.RemoteButtonSpec
+import com.flagship.abox.manager.infrared.remote.RemoteSceneConfig
+
+@Composable
+fun TvRemotePanel(
+    learnedSlotMap: Map<String, SavedInfraredKey>,
+    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 = "音量 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 = "频道 CH",
+            )
+        }
+    }
+}
+
+@Composable
+private fun TvActionButton(
+    spec: RemoteButtonSpec,
+    learnedSlotMap: Map<String, SavedInfraredKey>,
+    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,
+    )
+}

android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/runtime/DataStoreInfraredRuntimeModeStore.kt

@@ -0,0 +1,58 @@
+package com.flagship.abox.manager.infrared.runtime
+
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.stringPreferencesKey
+import com.flagship.abox.manager.domain.DomainError
+import com.flagship.abox.manager.domain.DomainResult
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.catch
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.map
+import java.io.IOException
+
+class DataStoreInfraredRuntimeModeStore(
+    private val dataStore: DataStore<Preferences>,
+) : InfraredRuntimeModeStore {
+
+    companion object {
+        private val KEY_RUNTIME_MODE = stringPreferencesKey("infrared_runtime_mode")
+    }
+
+    override val mode: Flow<InfraredRuntimeMode> = dataStore.data
+        .catch { exception ->
+            if (exception is IOException) {
+                emit(androidx.datastore.preferences.core.emptyPreferences())
+            } else {
+                throw exception
+            }
+        }
+        .map { preferences ->
+            val storedName = preferences[KEY_RUNTIME_MODE]
+            if (storedName != null) {
+                try {
+                    InfraredRuntimeMode.valueOf(storedName)
+                } catch (_: IllegalArgumentException) {
+                    InfraredRuntimeMode.FAKE
+                }
+            } else {
+                InfraredRuntimeMode.FAKE
+            }
+        }
+
+    override suspend fun currentMode(): InfraredRuntimeMode {
+        return mode.first()
+    }
+
+    override suspend fun setMode(mode: InfraredRuntimeMode): DomainResult<Unit> {
+        return try {
+            dataStore.edit { preferences ->
+                preferences[KEY_RUNTIME_MODE] = mode.name
+            }
+            DomainResult.Success(Unit)
+        } catch (throwable: Throwable) {
+            DomainResult.Failure(DomainError.Unknown(detail = "Failed to update runtime mode"))
+        }
+    }
+}

android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/runtime/InfraredRuntimeMode.kt

@@ -0,0 +1,15 @@
+package com.flagship.abox.manager.infrared.runtime
+
+import com.flagship.abox.manager.domain.DomainResult
+import kotlinx.coroutines.flow.Flow
+
+enum class InfraredRuntimeMode {
+    FAKE,
+    REAL_ABSDK,
+}
+
+interface InfraredRuntimeModeStore {
+    val mode: Flow<InfraredRuntimeMode>
+    suspend fun currentMode(): InfraredRuntimeMode
+    suspend fun setMode(mode: InfraredRuntimeMode): DomainResult<Unit>
+}

android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/runtime/InfraredRuntimeProfileResolver.kt

@@ -0,0 +1,12 @@
+package com.flagship.abox.manager.infrared.runtime
+
+import com.flagship.abox.manager.domain.ProviderProfileId
+
+class InfraredRuntimeProfileResolver {
+    fun resolve(realProfileId: ProviderProfileId, mode: InfraredRuntimeMode): ProviderProfileId {
+        return when (mode) {
+            InfraredRuntimeMode.REAL_ABSDK -> realProfileId
+            InfraredRuntimeMode.FAKE -> ProviderProfileId("${realProfileId.value}:infrared-fake")
+        }
+    }
+}

android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/ui/InfraredControlScreen.kt

@@ -0,0 +1,466 @@
+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.layout.width
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.Button
+import androidx.compose.material3.Card
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.ExperimentalMaterial3Api
+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.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.platform.testTag
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import androidx.hilt.navigation.compose.hiltViewModel
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.flagship.abox.manager.designsystem.ABoxButton
+import com.flagship.abox.manager.designsystem.ABoxSurface
+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 com.flagship.abox.manager.infrared.R
+import com.flagship.abox.manager.infrared.runtime.InfraredRuntimeMode
+
+@Composable
+fun InfraredControlRoute(
+    onBack: () -> Unit,
+    onSessionInvalid: () -> Unit,
+    viewModel: InfraredControlViewModel = hiltViewModel(),
+) {
+    val state by viewModel.state.collectAsStateWithLifecycle()
+
+    InfraredControlScreen(
+        state = state,
+        nextSlot = viewModel.nextAvailableKeySlot(),
+        onBack = onBack,
+        onSessionInvalid = onSessionInvalid,
+        onDeviceNameChanged = viewModel::onDeviceNameChanged,
+        onSaveDeviceName = viewModel::saveDeviceName,
+        onLearn = viewModel::learnKey,
+        onRetry = viewModel::retryLearning,
+        onSend = viewModel::sendKey,
+        onRename = viewModel::renameKey,
+        onDelete = viewModel::deleteKey,
+        onModeChanged = viewModel::setRuntimeMode,
+        onMessageShown = viewModel::clearMessage,
+    )
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+internal fun InfraredControlScreen(
+    state: InfraredControlUiState,
+    nextSlot: Int,
+    onBack: () -> Unit,
+    onSessionInvalid: () -> Unit,
+    onDeviceNameChanged: (String) -> Unit,
+    onSaveDeviceName: () -> Unit,
+    onLearn: (String, String?) -> Unit,
+    onRetry: (InfraredKeyId) -> Unit,
+    onSend: (InfraredKeyId) -> Unit,
+    onRename: (InfraredKeyId, String) -> Unit,
+    onDelete: (InfraredKeyId) -> Unit,
+    onModeChanged: (InfraredRuntimeMode) -> Unit,
+    onMessageShown: () -> Unit,
+) {
+    val snackbarHostState = remember { SnackbarHostState() }
+
+    var showLearnDialog by remember { mutableStateOf(false) }
+    var keyToRename by remember { mutableStateOf<SavedInfraredKey?>(null) }
+    var keyToDelete by remember { mutableStateOf<SavedInfraredKey?>(null) }
+
+    LaunchedEffect(state.message) {
+        state.message?.let { msg ->
+            when (msg) {
+                is InfraredUiMessage.Info -> {
+                    snackbarHostState.showSnackbar(msg.text)
+                    onMessageShown()
+                }
+                is InfraredUiMessage.Error -> {
+                    snackbarHostState.showSnackbar(msg.text)
+                    onMessageShown()
+                }
+                is InfraredUiMessage.SessionInvalid -> {
+                    onSessionInvalid()
+                    onMessageShown()
+                }
+            }
+        }
+    }
+
+    Scaffold(
+        topBar = {
+            TopAppBar(
+                title = { Text(stringResource(R.string.infrared_title)) },
+                navigationIcon = {
+                    TextButton(onClick = onBack) {
+                        Text(stringResource(R.string.infrared_back))
+                    }
+                },
+            )
+        },
+        snackbarHost = { SnackbarHost(snackbarHostState) },
+    ) { innerPadding ->
+        ABoxSurface(
+            modifier = Modifier
+                .fillMaxSize()
+                .padding(innerPadding),
+        ) {
+            Column(
+                modifier = Modifier
+                    .fillMaxSize()
+                    .padding(16.dp),
+                verticalArrangement = Arrangement.spacedBy(16.dp),
+            ) {
+                // Mode indicator and toggle
+                Row(
+                    modifier = Modifier.fillMaxWidth(),
+                    horizontalArrangement = Arrangement.SpaceBetween,
+                    verticalAlignment = Alignment.CenterVertically,
+                ) {
+                    val modeText = if (state.runtimeMode == InfraredRuntimeMode.FAKE) {
+                        stringResource(R.string.infrared_mode_fake)
+                    } else {
+                        stringResource(R.string.infrared_mode_real)
+                    }
+                    Text(
+                        text = modeText,
+                        style = MaterialTheme.typography.bodyMedium,
+                        modifier = Modifier.testTag("infrared_mode_label"),
+                    )
+                    OutlinedButton(
+                        onClick = {
+                            val target = if (state.runtimeMode == InfraredRuntimeMode.FAKE) {
+                                InfraredRuntimeMode.REAL_ABSDK
+                            } else {
+                                InfraredRuntimeMode.FAKE
+                            }
+                            onModeChanged(target)
+                        },
+                        enabled = !state.hasActiveLearning,
+                    ) {
+                        Text(stringResource(R.string.infrared_switch_mode))
+                    }
+                }
+
+                // Device name configuration card
+                Card(modifier = Modifier.fillMaxWidth()) {
+                    Column(
+                        modifier = Modifier.padding(12.dp),
+                        verticalArrangement = Arrangement.spacedBy(8.dp),
+                    ) {
+                        val saved = state.savedDeviceName
+                        Text(
+                            text = if (saved != null) {
+                                stringResource(R.string.infrared_saved_device, saved.value)
+                            } else {
+                                stringResource(R.string.infrared_no_device_saved)
+                            },
+                            style = MaterialTheme.typography.titleMedium,
+                        )
+
+                        Row(
+                            modifier = Modifier.fillMaxWidth(),
+                            verticalAlignment = Alignment.CenterVertically,
+                            horizontalArrangement = Arrangement.spacedBy(8.dp),
+                        ) {
+                            OutlinedTextField(
+                                value = state.deviceNameInput,
+                                onValueChange = onDeviceNameChanged,
+                                label = { Text(stringResource(R.string.infrared_device_name_label)) },
+                                placeholder = { Text(stringResource(R.string.infrared_device_name_hint)) },
+                                singleLine = true,
+                                modifier = Modifier
+                                    .weight(1f)
+                                    .testTag("infrared_device_name_input"),
+                            )
+                            ABoxButton(
+                                onClick = onSaveDeviceName,
+                                modifier = Modifier.testTag("infrared_save_device"),
+                            ) {
+                                Text(stringResource(R.string.infrared_save_device))
+                            }
+                        }
+                    }
+                }
+
+                // Learned Keys Section
+                Row(
+                    modifier = Modifier.fillMaxWidth(),
+                    horizontalArrangement = Arrangement.SpaceBetween,
+                    verticalAlignment = Alignment.CenterVertically,
+                ) {
+                    Text(
+                        text = stringResource(R.string.infrared_keys_title),
+                        style = MaterialTheme.typography.titleMedium,
+                    )
+                    ABoxButton(
+                        onClick = { showLearnDialog = true },
+                        enabled = state.savedDeviceName != null,
+                        modifier = Modifier.testTag("infrared_learn_new_key"),
+                    ) {
+                        Text(stringResource(R.string.infrared_learn_new_key))
+                    }
+                }
+
+                if (state.keys.isEmpty()) {
+                    Box(
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .weight(1f),
+                        contentAlignment = Alignment.Center,
+                    ) {
+                        Text(
+                            text = stringResource(R.string.infrared_no_keys),
+                            style = MaterialTheme.typography.bodyMedium,
+                        )
+                    }
+                } else {
+                    LazyColumn(
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .weight(1f),
+                        verticalArrangement = Arrangement.spacedBy(8.dp),
+                    ) {
+                        items(state.keys, key = { it.id.value }) { key ->
+                            InfraredKeyRow(
+                                key = key,
+                                isSending = state.sendingKeyIds.contains(key.id),
+                                onSend = { onSend(key.id) },
+                                onRetry = { onRetry(key.id) },
+                                onRename = { keyToRename = key },
+                                onDelete = { keyToDelete = key },
+                            )
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    if (showLearnDialog) {
+        var keyName by remember { mutableStateOf("") }
+        var keySlot by remember { mutableStateOf(nextSlot.toString()) }
+
+        AlertDialog(
+            onDismissRequest = { showLearnDialog = false },
+            title = { Text(stringResource(R.string.infrared_learn_dialog_title)) },
+            text = {
+                Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                    Text(stringResource(R.string.infrared_learn_dialog_prompt))
+                    OutlinedTextField(
+                        value = keyName,
+                        onValueChange = { keyName = it },
+                        label = { Text(stringResource(R.string.infrared_learn_dialog_input_label)) },
+                        singleLine = true,
+                        modifier = Modifier.fillMaxWidth(),
+                    )
+                    OutlinedTextField(
+                        value = keySlot,
+                        onValueChange = { keySlot = it },
+                        label = { Text(stringResource(R.string.infrared_learn_dialog_slot_label)) },
+                        singleLine = true,
+                        modifier = Modifier.fillMaxWidth(),
+                    )
+                }
+            },
+            confirmButton = {
+                Button(
+                    onClick = {
+                        onLearn(keyName, keySlot)
+                        showLearnDialog = false
+                    },
+                    enabled = keyName.isNotBlank() && keySlot.isNotBlank(),
+                ) {
+                    Text(stringResource(R.string.infrared_learn_dialog_start))
+                }
+            },
+            dismissButton = {
+                TextButton(onClick = { showLearnDialog = false }) {
+                    Text(stringResource(R.string.infrared_dialog_cancel))
+                }
+            },
+        )
+    }
+
+    keyToRename?.let { targetKey ->
+        var newName by remember { mutableStateOf(targetKey.displayName) }
+        AlertDialog(
+            onDismissRequest = { keyToRename = null },
+            title = { Text(stringResource(R.string.infrared_rename_dialog_title)) },
+            text = {
+                OutlinedTextField(
+                    value = newName,
+                    onValueChange = { newName = it },
+                    label = { Text(stringResource(R.string.infrared_rename_dialog_input_label)) },
+                    singleLine = true,
+                    modifier = Modifier.fillMaxWidth(),
+                )
+            },
+            confirmButton = {
+                Button(
+                    onClick = {
+                        onRename(targetKey.id, newName)
+                        keyToRename = null
+                    },
+                    enabled = newName.isNotBlank(),
+                ) {
+                    Text(stringResource(R.string.infrared_dialog_confirm))
+                }
+            },
+            dismissButton = {
+                TextButton(onClick = { keyToRename = null }) {
+                    Text(stringResource(R.string.infrared_dialog_cancel))
+                }
+            },
+        )
+    }
+
+    keyToDelete?.let { targetKey ->
+        AlertDialog(
+            onDismissRequest = { keyToDelete = null },
+            title = { Text(stringResource(R.string.infrared_delete_dialog_title)) },
+            text = { Text(stringResource(R.string.infrared_delete_dialog_message)) },
+            confirmButton = {
+                Button(
+                    onClick = {
+                        onDelete(targetKey.id)
+                        keyToDelete = null
+                    },
+                ) {
+                    Text(stringResource(R.string.infrared_dialog_confirm))
+                }
+            },
+            dismissButton = {
+                TextButton(onClick = { keyToDelete = null }) {
+                    Text(stringResource(R.string.infrared_dialog_cancel))
+                }
+            },
+        )
+    }
+}
+
+@Composable
+private fun InfraredKeyRow(
+    key: SavedInfraredKey,
+    isSending: Boolean,
+    onSend: () -> Unit,
+    onRetry: () -> Unit,
+    onRename: () -> Unit,
+    onDelete: () -> Unit,
+) {
+    Card(
+        modifier = Modifier
+            .fillMaxWidth()
+            .testTag("infrared_key_${key.id.value}"),
+    ) {
+        Column(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(12.dp),
+            verticalArrangement = Arrangement.spacedBy(8.dp),
+        ) {
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                horizontalArrangement = Arrangement.SpaceBetween,
+                verticalAlignment = Alignment.CenterVertically,
+            ) {
+                Column {
+                    Text(
+                        text = key.displayName,
+                        style = MaterialTheme.typography.titleMedium,
+                    )
+                    Text(
+                        text = stringResource(R.string.infrared_key_slot_label, key.sdkKey),
+                        style = MaterialTheme.typography.bodySmall,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant,
+                    )
+                }
+
+                val statusLabel = when (key.status) {
+                    InfraredKeyStatus.LEARNING -> stringResource(R.string.infrared_status_learning)
+                    InfraredKeyStatus.READY -> stringResource(R.string.infrared_status_ready)
+                    InfraredKeyStatus.FAILED -> stringResource(R.string.infrared_status_failed)
+                }
+                Text(
+                    text = statusLabel,
+                    style = MaterialTheme.typography.bodyMedium,
+                    color = when (key.status) {
+                        InfraredKeyStatus.LEARNING -> MaterialTheme.colorScheme.primary
+                        InfraredKeyStatus.READY -> MaterialTheme.colorScheme.tertiary
+                        InfraredKeyStatus.FAILED -> MaterialTheme.colorScheme.error
+                    },
+                )
+            }
+
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                horizontalArrangement = Arrangement.End,
+                verticalAlignment = Alignment.CenterVertically,
+            ) {
+                if (key.status == InfraredKeyStatus.READY) {
+                    Button(
+                        onClick = onSend,
+                        enabled = !isSending,
+                        modifier = Modifier.testTag("infrared_send_${key.id.value}"),
+                    ) {
+                        if (isSending) {
+                            Text(stringResource(R.string.infrared_sending))
+                        } else {
+                            Text(stringResource(R.string.infrared_send))
+                        }
+                    }
+                    Spacer(modifier = Modifier.width(8.dp))
+                }
+
+                if (key.status == InfraredKeyStatus.FAILED) {
+                    Button(
+                        onClick = onRetry,
+                        modifier = Modifier.testTag("infrared_retry_${key.id.value}"),
+                    ) {
+                        Text(stringResource(R.string.infrared_retry))
+                    }
+                    Spacer(modifier = Modifier.width(8.dp))
+                }
+
+                if (key.status != InfraredKeyStatus.LEARNING) {
+                    OutlinedButton(onClick = onRename) {
+                        Text(stringResource(R.string.infrared_rename))
+                    }
+                    Spacer(modifier = Modifier.width(8.dp))
+                    OutlinedButton(onClick = onDelete) {
+                        Text(stringResource(R.string.infrared_delete))
+                    }
+                } else {
+                    CircularProgressIndicator(modifier = Modifier.height(24.dp).width(24.dp))
+                }
+            }
+        }
+    }
+}

android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/ui/InfraredControlUiState.kt

@@ -0,0 +1,27 @@
+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.infrared.InfraredKeyId
+import com.flagship.abox.manager.domain.infrared.InfraredKeyStatus
+import com.flagship.abox.manager.domain.infrared.SavedInfraredKey
+import com.flagship.abox.manager.infrared.runtime.InfraredRuntimeMode
+
+sealed interface InfraredUiMessage {
+    data class Info(val text: String) : InfraredUiMessage
+    data class Error(val text: String) : InfraredUiMessage
+    data object SessionInvalid : InfraredUiMessage
+}
+
+data class InfraredControlUiState(
+    val runtimeMode: InfraredRuntimeMode = InfraredRuntimeMode.FAKE,
+    val effectiveProfileId: ProviderProfileId? = null,
+    val deviceNameInput: String = "",
+    val savedDeviceName: DeviceName? = null,
+    val keys: List<SavedInfraredKey> = emptyList(),
+    val loading: Boolean = true,
+    val sendingKeyIds: Set<InfraredKeyId> = emptySet(),
+    val message: InfraredUiMessage? = null,
+) {
+    val hasActiveLearning: Boolean get() = keys.any { it.status == InfraredKeyStatus.LEARNING }
+}

android/feature/infrared/src/main/kotlin/com/flagship/abox/manager/infrared/ui/InfraredControlViewModel.kt

@@ -0,0 +1,342 @@
+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.infrared.DeleteInfraredKey
+import com.flagship.abox.manager.domain.infrared.EpochMillisClock
+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.RecoverInterruptedInfraredLearning
+import com.flagship.abox.manager.domain.infrared.RenameInfraredKey
+import com.flagship.abox.manager.domain.infrared.SavedInfraredKey
+import com.flagship.abox.manager.domain.infrared.SendInfraredKey
+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.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 keyRepository: InfraredKeyRepository,
+    private val deviceConfigurationRepository: InfraredDeviceConfigurationRepository,
+    private val runtimeModeStore: InfraredRuntimeModeStore,
+    private val profileResolver: InfraredRuntimeProfileResolver,
+    private val learningCoordinator: InfraredLearningCoordinator,
+    private val sendInfraredKey: SendInfraredKey,
+    private val renameInfraredKey: RenameInfraredKey,
+    private val deleteInfraredKey: DeleteInfraredKey,
+    private val recoverInterruptedInfraredLearning: RecoverInterruptedInfraredLearning,
+    private val clock: EpochMillisClock,
+) : ViewModel() {
+
+    private val rawProfileId: String? = savedStateHandle["profileId"]
+    private val authenticatedProfileId: ProviderProfileId? = rawProfileId?.takeIf { it.isNotBlank() }?.let { ProviderProfileId(it) }
+
+    private val deviceNameInputFlow = MutableStateFlow("")
+    private val sendingKeyIdsFlow = MutableStateFlow<Set<InfraredKeyId>>(emptySet())
+    private val messageFlow = MutableStateFlow<InfraredUiMessage?>(null)
+
+    private val effectiveProfileAndMode: Flow<Pair<ProviderProfileId?, InfraredRuntimeMode>> =
+        runtimeModeStore.mode.mapModeToProfile()
+
+    private fun Flow<InfraredRuntimeMode>.mapModeToProfile(): Flow<Pair<ProviderProfileId?, InfraredRuntimeMode>> {
+        return flatMapLatest { mode ->
+            if (authenticatedProfileId == null) {
+                flowOf(Pair(null, mode))
+            } else {
+                val effectiveProfile = profileResolver.resolve(authenticatedProfileId, mode)
+                flowOf(Pair(effectiveProfile, mode))
+            }
+        }
+    }
+
+    private val deviceNameFlow: Flow<DomainResult<DeviceName?>> =
+        effectiveProfileAndMode.flatMapLatest { (profile, _) ->
+            if (profile == null) {
+                flowOf(DomainResult.Success(null))
+            } else {
+                deviceConfigurationRepository.observeDeviceName(profile)
+            }
+        }
+
+    private val keysFlow: Flow<DomainResult<List<SavedInfraredKey>>> =
+        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))
+                    }
+                }
+            }
+        }
+
+    private data class ServerState(
+        val profile: ProviderProfileId?,
+        val mode: InfraredRuntimeMode,
+        val deviceResult: DomainResult<DeviceName?>,
+        val keysResult: DomainResult<List<SavedInfraredKey>>,
+    )
+
+    private val serverStateFlow: Flow<ServerState> = combine(
+        effectiveProfileAndMode,
+        deviceNameFlow,
+        keysFlow,
+    ) { profileAndMode, deviceResult, keysResult ->
+        ServerState(
+            profile = profileAndMode.first,
+            mode = profileAndMode.second,
+            deviceResult = deviceResult,
+            keysResult = keysResult,
+        )
+    }
+
+    val state: StateFlow<InfraredControlUiState> = combine(
+        serverStateFlow,
+        deviceNameInputFlow,
+        sendingKeyIdsFlow,
+        messageFlow,
+    ) { serverState, input, sendingIds, msg ->
+        val savedDevice = (serverState.deviceResult as? DomainResult.Success<DeviceName?>)?.value
+        val keys = (serverState.keysResult as? DomainResult.Success<List<SavedInfraredKey>>)?.value ?: emptyList()
+        val loading = serverState.profile == null ||
+            serverState.deviceResult !is DomainResult.Success ||
+            serverState.keysResult !is DomainResult.Success
+
+        InfraredControlUiState(
+            runtimeMode = serverState.mode,
+            effectiveProfileId = serverState.profile,
+            deviceNameInput = input,
+            savedDeviceName = savedDevice,
+            keys = keys,
+            loading = loading,
+            sendingKeyIds = sendingIds,
+            message = if (authenticatedProfileId == null) {
+                InfraredUiMessage.Error("Invalid or missing profile ID")
+            } else {
+                msg
+            },
+        )
+    }.stateIn(
+        scope = viewModelScope,
+        started = SharingStarted.WhileSubscribed(5_000),
+        initialValue = InfraredControlUiState(
+            runtimeMode = InfraredRuntimeMode.FAKE,
+            effectiveProfileId = null,
+            loading = true,
+        ),
+    )
+
+    init {
+        if (authenticatedProfileId != null) {
+            viewModelScope.launch {
+                val currentMode = runtimeModeStore.currentMode()
+                val effectiveProfile = profileResolver.resolve(authenticatedProfileId, currentMode)
+                recoverInterruptedInfraredLearning(effectiveProfile)
+            }
+        }
+    }
+
+    fun onDeviceNameChanged(value: String) {
+        deviceNameInputFlow.value = value
+    }
+
+    fun saveDeviceName() {
+        val currentProfile = state.value.effectiveProfileId ?: return
+        val trimmed = deviceNameInputFlow.value.trim()
+        if (trimmed.isBlank()) {
+            messageFlow.value = InfraredUiMessage.Error("Device name cannot be blank")
+            return
+        }
+        viewModelScope.launch {
+            when (val result = deviceConfigurationRepository.setDeviceName(currentProfile, DeviceName(trimmed))) {
+                is DomainResult.Success -> {
+                    messageFlow.value = InfraredUiMessage.Info("Device name saved")
+                    deviceNameInputFlow.value = ""
+                }
+                is DomainResult.Failure -> {
+                    handleDomainError(result.error)
+                }
+            }
+        }
+    }
+
+    fun nextAvailableKeySlot(): Int {
+        val usedSlots = state.value.keys.mapNotNull { it.sdkKey.toIntOrNull() }.toSet()
+        return (1..100).firstOrNull { it !in usedSlots } ?: 1
+    }
+
+    fun learnKey(displayName: String, keySlotInput: String? = null) {
+        val currentProfile = state.value.effectiveProfileId ?: return
+        val savedDevice = state.value.savedDeviceName
+        if (savedDevice == null) {
+            messageFlow.value = InfraredUiMessage.Error("Please set and save a device name first")
+            return
+        }
+        val trimmedName = displayName.trim()
+        if (trimmedName.isBlank()) {
+            messageFlow.value = InfraredUiMessage.Error("Key name cannot be blank")
+            return
+        }
+        val slotString = if (keySlotInput != null && keySlotInput.isNotBlank()) {
+            val slotInt = keySlotInput.trim().toIntOrNull()
+            if (slotInt == null || slotInt !in 1..100) {
+                messageFlow.value = InfraredUiMessage.Error("Key slot must be an integer between 1 and 100")
+                return
+            }
+            slotInt.toString()
+        } else {
+            nextAvailableKeySlot().toString()
+        }
+        learningCoordinator.learn(currentProfile, savedDevice, trimmedName, slotString)
+    }
+
+    fun retryLearning(keyId: InfraredKeyId) {
+        val currentProfile = state.value.effectiveProfileId ?: return
+        learningCoordinator.retry(InfraredKeyRef(currentProfile, keyId))
+    }
+
+    fun sendKey(keyId: InfraredKeyId) {
+        val currentProfile = state.value.effectiveProfileId ?: return
+        if (state.value.sendingKeyIds.contains(keyId)) return
+
+        val key = state.value.keys.find { it.id == keyId }
+        if (key == null || key.status != InfraredKeyStatus.READY) {
+            messageFlow.value = InfraredUiMessage.Error("Key is not ready to send")
+            return
+        }
+
+        sendingKeyIdsFlow.value = sendingKeyIdsFlow.value + keyId
+        viewModelScope.launch {
+            try {
+                when (val result = sendInfraredKey(InfraredKeyRef(currentProfile, keyId))) {
+                    is DomainResult.Success -> {
+                        messageFlow.value = InfraredUiMessage.Info("Signal sent successfully")
+                    }
+                    is DomainResult.Failure -> {
+                        handleDomainError(result.error)
+                    }
+                }
+            } finally {
+                sendingKeyIdsFlow.value = sendingKeyIdsFlow.value - keyId
+            }
+        }
+    }
+
+    fun renameKey(keyId: InfraredKeyId, displayName: String) {
+        val currentProfile = state.value.effectiveProfileId ?: return
+        val trimmed = displayName.trim()
+        if (trimmed.isBlank()) {
+            messageFlow.value = InfraredUiMessage.Error("Name cannot be blank")
+            return
+        }
+        viewModelScope.launch {
+            when (val result = renameInfraredKey(InfraredKeyRef(currentProfile, keyId), trimmed)) {
+                is DomainResult.Success -> {
+                    messageFlow.value = InfraredUiMessage.Info("Key renamed")
+                }
+                is DomainResult.Failure -> {
+                    handleDomainError(result.error)
+                }
+            }
+        }
+    }
+
+    fun deleteKey(keyId: InfraredKeyId) {
+        val currentProfile = state.value.effectiveProfileId ?: return
+        viewModelScope.launch {
+            when (val result = deleteInfraredKey(InfraredKeyRef(currentProfile, keyId))) {
+                is DomainResult.Success -> {
+                    messageFlow.value = InfraredUiMessage.Info("Key removed locally")
+                }
+                is DomainResult.Failure -> {
+                    handleDomainError(result.error)
+                }
+            }
+        }
+    }
+
+    fun setRuntimeMode(mode: InfraredRuntimeMode) {
+        if (state.value.hasActiveLearning) {
+            messageFlow.value = InfraredUiMessage.Error("Cannot change mode while learning is active")
+            return
+        }
+        viewModelScope.launch {
+            when (val result = runtimeModeStore.setMode(mode)) {
+                is DomainResult.Success -> {
+                    if (authenticatedProfileId != null) {
+                        val newEffectiveProfile = profileResolver.resolve(authenticatedProfileId, mode)
+                        recoverInterruptedInfraredLearning(newEffectiveProfile)
+                    }
+                }
+                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("Infrared controller is offline (code: ${error.externalCode ?: "20206"})")
+            }
+            is DomainError.DeviceNotFound -> {
+                messageFlow.value = InfraredUiMessage.Error("Device not found (code: ${error.externalCode ?: "20203"})")
+            }
+            is DomainError.InvalidRequest -> {
+                messageFlow.value = InfraredUiMessage.Error(error.detail ?: "Invalid request")
+            }
+            is DomainError.OperationFailed -> {
+                messageFlow.value = InfraredUiMessage.Error(error.detail ?: "Operation failed (code: ${error.externalCode ?: "unknown"})")
+            }
+            is DomainError.Network -> {
+                messageFlow.value = InfraredUiMessage.Error("Network error: ${error.detail ?: "connection failed"}")
+            }
+            is DomainError.NoData -> {
+                messageFlow.value = InfraredUiMessage.Error(error.detail ?: "No data found")
+            }
+            is DomainError.Unknown -> {
+                messageFlow.value = InfraredUiMessage.Error(error.detail ?: "Unknown error")
+            }
+        }
+    }
+}

android/feature/infrared/src/main/res/values-zh-rCN/strings.xml

@@ -0,0 +1,35 @@
+<resources>
+    <string name="infrared_title">红外控制</string>
+    <string name="infrared_mode_fake">模式：模拟 / Fake</string>
+    <string name="infrared_mode_real">模式：真实 ABSDK</string>
+    <string name="infrared_switch_mode">切换模式</string>
+    <string name="infrared_device_name_label">红外设备名称</string>
+    <string name="infrared_device_name_hint">例如：ir-living</string>
+    <string name="infrared_saved_device">已保存设备：%1$s</string>
+    <string name="infrared_no_device_saved">未配置红外设备</string>
+    <string name="infrared_save_device">保存设备名</string>
+    <string name="infrared_keys_title">已学习按键</string>
+    <string name="infrared_no_keys">暂无保存的红外按键</string>
+    <string name="infrared_learn_new_key">学习新按键</string>
+    <string name="infrared_status_learning">学习中…</string>
+    <string name="infrared_status_ready">就绪</string>
+    <string name="infrared_status_failed">失败</string>
+    <string name="infrared_send">发射</string>
+    <string name="infrared_sending">发射中…</string>
+    <string name="infrared_retry">重试</string>
+    <string name="infrared_rename">重命名</string>
+    <string name="infrared_delete">删除</string>
+    <string name="infrared_learn_dialog_title">学习红外按键</string>
+    <string name="infrared_learn_dialog_prompt">请准备好实体遥控器。点击开始后，请将遥控器对准红外控制器并按下目标按键。</string>
+    <string name="infrared_learn_dialog_input_label">按键名称（如：电源）</string>
+    <string name="infrared_learn_dialog_slot_label">按键编号（1-100）</string>
+    <string name="infrared_key_slot_label">按键编号：%1$s</string>
+    <string name="infrared_learn_dialog_start">开始学习</string>
+    <string name="infrared_rename_dialog_title">重命名按键</string>
+    <string name="infrared_rename_dialog_input_label">新按键名称</string>
+    <string name="infrared_delete_dialog_title">删除按键</string>
+    <string name="infrared_delete_dialog_message">仅从本机列表移除，ABox 服务端可能仍保留该按键。</string>
+    <string name="infrared_dialog_cancel">取消</string>
+    <string name="infrared_dialog_confirm">确认</string>
+    <string name="infrared_back">返回</string>
+</resources>

android/feature/infrared/src/main/res/values/strings.xml

@@ -0,0 +1,35 @@
+<resources>
+    <string name="infrared_title">Infrared Control</string>
+    <string name="infrared_mode_fake">Mode: Fake / Simulated</string>
+    <string name="infrared_mode_real">Mode: Real ABSDK</string>
+    <string name="infrared_switch_mode">Switch Mode</string>
+    <string name="infrared_device_name_label">Infrared Device Name</string>
+    <string name="infrared_device_name_hint">e.g. ir-living</string>
+    <string name="infrared_saved_device">Saved Device: %1$s</string>
+    <string name="infrared_no_device_saved">No infrared device configured</string>
+    <string name="infrared_save_device">Save Device</string>
+    <string name="infrared_keys_title">Learned Keys</string>
+    <string name="infrared_no_keys">No infrared keys saved</string>
+    <string name="infrared_learn_new_key">Learn New Key</string>
+    <string name="infrared_status_learning">Learning…</string>
+    <string name="infrared_status_ready">Ready</string>
+    <string name="infrared_status_failed">Failed</string>
+    <string name="infrared_send">Send</string>
+    <string name="infrared_sending">Sending…</string>
+    <string name="infrared_retry">Retry</string>
+    <string name="infrared_rename">Rename</string>
+    <string name="infrared_delete">Delete</string>
+    <string name="infrared_learn_dialog_title">Learn Infrared Key</string>
+    <string name="infrared_learn_dialog_prompt">Prepare the physical remote. After starting, point it at the infrared controller and press the target button.</string>
+    <string name="infrared_learn_dialog_input_label">Key Name (e.g. Power)</string>
+    <string name="infrared_learn_dialog_slot_label">Key Slot (1-100)</string>
+    <string name="infrared_key_slot_label">Key Slot: %1$s</string>
+    <string name="infrared_learn_dialog_start">Start Learning</string>
+    <string name="infrared_rename_dialog_title">Rename Key</string>
+    <string name="infrared_rename_dialog_input_label">New Display Name</string>
+    <string name="infrared_delete_dialog_title">Delete Key</string>
+    <string name="infrared_delete_dialog_message">Only removes the key locally from this app. ABox server may retain the learned key.</string>
+    <string name="infrared_dialog_cancel">Cancel</string>
+    <string name="infrared_dialog_confirm">Confirm</string>
+    <string name="infrared_back">Back</string>
+</resources>

android/feature/infrared/src/test/kotlin/com/flagship/abox/manager/infrared/application/InfraredLearningCoordinatorTest.kt

@@ -0,0 +1,76 @@
+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.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)
+
+    @Test
+    fun learnRunsAsynchronouslyInExternalScope() = runTest {
+        val coordinator = InfraredLearningCoordinator(learn, retry, 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, 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)
+    }
+}

android/feature/infrared/src/test/kotlin/com/flagship/abox/manager/infrared/remote/InfraredRemoteViewModelTest.kt

@@ -0,0 +1,139 @@
+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.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.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
+
+private class TestModeStore : InfraredRuntimeModeStore {
+    private val modeFlow = MutableStateFlow(InfraredRuntimeMode.FAKE)
+    override val mode: Flow<InfraredRuntimeMode> = modeFlow
+    override suspend fun currentMode(): InfraredRuntimeMode = modeFlow.value
+    override suspend fun setMode(mode: InfraredRuntimeMode): DomainResult<Unit> {
+        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("01J5MOLERABC123") }, 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()
+    }
+}

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

android/feature/infrared/src/test/kotlin/com/flagship/abox/manager/infrared/runtime/InfraredRuntimeProfileResolverTest.kt

@@ -0,0 +1,21 @@
+package com.flagship.abox.manager.infrared.runtime
+
+import com.flagship.abox.manager.domain.ProviderProfileId
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class InfraredRuntimeProfileResolverTest {
+
+    @Test
+    fun realModeUsesAuthenticatedProfileAndFakeModeUsesIsolatedProfile() {
+        val resolver = InfraredRuntimeProfileResolver()
+        assertEquals(
+            ProviderProfileId("abox"),
+            resolver.resolve(ProviderProfileId("abox"), InfraredRuntimeMode.REAL_ABSDK),
+        )
+        assertEquals(
+            ProviderProfileId("abox:infrared-fake"),
+            resolver.resolve(ProviderProfileId("abox"), InfraredRuntimeMode.FAKE),
+        )
+    }
+}

android/feature/infrared/src/test/kotlin/com/flagship/abox/manager/infrared/ui/InfraredControlViewModelTest.kt

@@ -0,0 +1,294 @@
+package com.flagship.abox.manager.infrared.ui
+
+import androidx.lifecycle.SavedStateHandle
+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.DeleteInfraredKey
+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.RecoverInterruptedInfraredLearning
+import com.flagship.abox.manager.domain.infrared.RenameInfraredKey
+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.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.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
+
+class FakeRuntimeModeStore : InfraredRuntimeModeStore {
+    private val modeFlow = MutableStateFlow(InfraredRuntimeMode.FAKE)
+    override val mode: Flow<InfraredRuntimeMode> = modeFlow
+    override suspend fun currentMode(): InfraredRuntimeMode = modeFlow.value
+    override suspend fun setMode(mode: InfraredRuntimeMode): DomainResult<Unit> {
+        modeFlow.value = mode
+        return DomainResult.Success(Unit)
+    }
+}
+
+@OptIn(ExperimentalCoroutinesApi::class)
+class InfraredControlViewModelTest {
+
+    private val testDispatcher = StandardTestDispatcher()
+    private val testScope = TestScope(testDispatcher)
+
+    private val baseProfile = ProviderProfileId("abox")
+    private val fakeProfile = ProviderProfileId("abox:infrared-fake")
+    private val device = DeviceName("ir-living")
+    private val clock = EpochMillisClock { 10_000L }
+
+    private val keyRepository = FakeInfraredKeyRepository()
+    private val deviceConfigRepository = FakeInfraredDeviceConfigurationRepository()
+    private val runtimeModeStore = FakeRuntimeModeStore()
+    private val profileResolver = InfraredRuntimeProfileResolver()
+    private val gateway = FakeInfraredGateway()
+    private val factory = InfraredKeyFactory({ InfraredKeyId("01J5MOLERABC123") }, clock)
+
+    private val learnUseCase = LearnInfraredKey(keyRepository, gateway, factory, clock)
+    private val retryUseCase = RetryInfraredKeyLearning(keyRepository, gateway, clock)
+    private val sendUseCase = SendInfraredKey(keyRepository, gateway)
+    private val renameUseCase = RenameInfraredKey(keyRepository, clock)
+    private val deleteUseCase = DeleteInfraredKey(keyRepository)
+    private val recoverUseCase = RecoverInterruptedInfraredLearning(keyRepository, clock)
+
+    private lateinit var coordinator: InfraredLearningCoordinator
+
+    @Before
+    fun setup() {
+        Dispatchers.setMain(testDispatcher)
+        coordinator = InfraredLearningCoordinator(learnUseCase, retryUseCase, testScope)
+    }
+
+    @After
+    fun teardown() {
+        Dispatchers.resetMain()
+    }
+
+    private fun createViewModel(profileId: String? = "abox"): InfraredControlViewModel {
+        val handle = SavedStateHandle(if (profileId != null) mapOf("profileId" to profileId) else emptyMap())
+        return InfraredControlViewModel(
+            savedStateHandle = handle,
+            keyRepository = keyRepository,
+            deviceConfigurationRepository = deviceConfigRepository,
+            runtimeModeStore = runtimeModeStore,
+            profileResolver = profileResolver,
+            learningCoordinator = coordinator,
+            sendInfraredKey = sendUseCase,
+            renameInfraredKey = renameUseCase,
+            deleteInfraredKey = deleteUseCase,
+            recoverInterruptedInfraredLearning = recoverUseCase,
+            clock = clock,
+        )
+    }
+
+    @Test
+    fun resolvesEffectiveProfileByRuntimeMode() = testScope.runTest {
+        val vm = createViewModel()
+        val job = launch { vm.state.collect {} }
+        advanceUntilIdle()
+
+        assertEquals(fakeProfile, vm.state.value.effectiveProfileId)
+        assertEquals(InfraredRuntimeMode.FAKE, vm.state.value.runtimeMode)
+
+        vm.setRuntimeMode(InfraredRuntimeMode.REAL_ABSDK)
+        advanceUntilIdle()
+
+        assertEquals(baseProfile, vm.state.value.effectiveProfileId)
+        assertEquals(InfraredRuntimeMode.REAL_ABSDK, vm.state.value.runtimeMode)
+
+        job.cancel()
+    }
+
+    @Test
+    fun blankDeviceNameReturnsValidationError() = testScope.runTest {
+        val vm = createViewModel()
+        val job = launch { vm.state.collect {} }
+        advanceUntilIdle()
+
+        vm.onDeviceNameChanged("   ")
+        vm.saveDeviceName()
+        advanceUntilIdle()
+
+        val msg = vm.state.value.message
+        assertTrue(msg is InfraredUiMessage.Error)
+        assertEquals("Device name cannot be blank", (msg as InfraredUiMessage.Error).text)
+
+        job.cancel()
+    }
+
+    @Test
+    fun saveDeviceNamePersistsAndTrims() = testScope.runTest {
+        val vm = createViewModel()
+        val job = launch { vm.state.collect {} }
+        advanceUntilIdle()
+
+        vm.onDeviceNameChanged("  ir-main  ")
+        vm.saveDeviceName()
+        advanceUntilIdle()
+
+        assertEquals(DeviceName("ir-main"), vm.state.value.savedDeviceName)
+        assertEquals("", vm.state.value.deviceNameInput)
+        assertTrue(vm.state.value.message is InfraredUiMessage.Info)
+
+        job.cancel()
+    }
+
+    @Test
+    fun learnWithoutSavedDeviceFails() = testScope.runTest {
+        val vm = createViewModel()
+        val job = launch { vm.state.collect {} }
+        advanceUntilIdle()
+
+        vm.learnKey("Power")
+        advanceUntilIdle()
+
+        val msg = vm.state.value.message
+        assertTrue(msg is InfraredUiMessage.Error)
+        assertEquals("Please set and save a device name first", (msg as InfraredUiMessage.Error).text)
+
+        job.cancel()
+    }
+
+    @Test
+    fun learnWithSavedDeviceSucceeds() = testScope.runTest {
+        val vm = createViewModel()
+        val job = launch { vm.state.collect {} }
+        advanceUntilIdle()
+
+        vm.onDeviceNameChanged("ir-1")
+        vm.saveDeviceName()
+        advanceUntilIdle()
+
+        vm.learnKey("Air Conditioner")
+        advanceUntilIdle()
+
+        val keys = vm.state.value.keys
+        assertEquals(1, keys.size)
+        assertEquals("Air Conditioner", keys.first().displayName)
+        assertEquals(InfraredKeyStatus.READY, keys.first().status)
+
+        job.cancel()
+    }
+
+    @Test
+    fun sendReadyKeySendsSignalAndClearsSendingSet() = testScope.runTest {
+        val vm = createViewModel()
+        val job = launch { vm.state.collect {} }
+        advanceUntilIdle()
+
+        deviceConfigRepository.setDeviceName(fakeProfile, device)
+        val key = SavedInfraredKey(
+            id = InfraredKeyId("k1"),
+            profileId = fakeProfile,
+            deviceName = device,
+            displayName = "Power",
+            sdkKey = "app_ir_k1",
+            status = InfraredKeyStatus.READY,
+            lastErrorCode = null,
+            lastErrorDetail = null,
+            createdAtEpochMillis = 100L,
+            updatedAtEpochMillis = 100L,
+        )
+        keyRepository.insert(key)
+        advanceUntilIdle()
+
+        vm.sendKey(InfraredKeyId("k1"))
+        advanceUntilIdle()
+
+        assertTrue(vm.state.value.sendingKeyIds.isEmpty())
+        assertTrue(vm.state.value.message is InfraredUiMessage.Info)
+        assertEquals(1, gateway.sentKeys.size)
+
+        job.cancel()
+    }
+
+    @Test
+    fun sendFailurePreservesReadyStatus() = testScope.runTest {
+        val vm = createViewModel()
+        val job = launch { vm.state.collect {} }
+        advanceUntilIdle()
+
+        deviceConfigRepository.setDeviceName(fakeProfile, device)
+        val key = SavedInfraredKey(
+            id = InfraredKeyId("k1"),
+            profileId = fakeProfile,
+            deviceName = device,
+            displayName = "Power",
+            sdkKey = "app_ir_k1",
+            status = InfraredKeyStatus.READY,
+            lastErrorCode = null,
+            lastErrorDetail = null,
+            createdAtEpochMillis = 100L,
+            updatedAtEpochMillis = 100L,
+        )
+        keyRepository.insert(key)
+        gateway.sendResult = DomainResult.Failure(DomainError.DeviceOffline("20206"))
+        advanceUntilIdle()
+
+        vm.sendKey(InfraredKeyId("k1"))
+        advanceUntilIdle()
+
+        val fetched = vm.state.value.keys.single()
+        assertEquals(InfraredKeyStatus.READY, fetched.status)
+        assertTrue(vm.state.value.message is InfraredUiMessage.Error)
+
+        job.cancel()
+    }
+
+    @Test
+    fun setModeBlockedWhileLearningIsActive() = testScope.runTest {
+        val vm = createViewModel()
+        val job = launch { vm.state.collect {} }
+        advanceUntilIdle()
+
+        deviceConfigRepository.setDeviceName(fakeProfile, device)
+        val key = SavedInfraredKey(
+            id = InfraredKeyId("k1"),
+            profileId = fakeProfile,
+            deviceName = device,
+            displayName = "Power",
+            sdkKey = "app_ir_k1",
+            status = InfraredKeyStatus.LEARNING,
+            lastErrorCode = null,
+            lastErrorDetail = null,
+            createdAtEpochMillis = 100L,
+            updatedAtEpochMillis = 100L,
+        )
+        keyRepository.insert(key)
+        advanceUntilIdle()
+
+        assertTrue(vm.state.value.hasActiveLearning)
+        vm.setRuntimeMode(InfraredRuntimeMode.REAL_ABSDK)
+        advanceUntilIdle()
+
+        assertEquals(InfraredRuntimeMode.FAKE, vm.state.value.runtimeMode)
+        assertTrue(vm.state.value.message is InfraredUiMessage.Error)
+
+        job.cancel()
+    }
+}

build.gradle.kts

@@ -6,3 +6,4 @@ plugins {
     alias(libs.plugins.kotlin.kapt) apply false
     alias(libs.plugins.hilt.android) apply false
 }
+

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<InfraredRemoteUiState>` 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<InfraredRuntimeMode> = modeFlow
+    override suspend fun currentMode(): InfraredRuntimeMode = modeFlow.value
+    override suspend fun setMode(mode: InfraredRuntimeMode): DomainResult<Unit> {
+        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<String, SavedInfraredKey> = 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<String?>(null)
+    private val activeLearningSlotFlow = MutableStateFlow<String?>(null)
+    private val messageFlow = MutableStateFlow<RemoteUiMessage?>(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<InfraredRemoteUiState> = 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<DeviceName?>)?.value
+        val keys = (keysResult as? DomainResult.Success<List<SavedInfraredKey>>)?.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
+```

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<IrInfo> irInfos)
+```
+
+现有领域层已将其隔离为 `InfraredGateway`：
+
+```kotlin
+interface InfraredGateway {
+    suspend fun sendKey(
+        profileId: ProviderProfileId,
+        deviceName: DeviceName,
+        key: String,
+    ): DomainResult<Unit>
+
+    suspend fun learnKey(
+        profileId: ProviderProfileId,
+        deviceName: DeviceName,
+        key: String,
+    ): DomainResult<Unit>
+
+    suspend fun downloadCodes(
+        profileId: ProviderProfileId,
+        codes: List<InfraredCode>,
+    ): DomainResult<List<InfraredCodeDownloadResult>>
+}
+```
+
+本设计必须遵守以下事实：
+
+- 学习接口只确认返回成功码和消息，没有已确认的原始红外码返回值；
+- 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_<normalized-infrared-key-id>
+```
+
+实际长度上限尚未由 ABSDK 文档确认，实现前需选择保守长度，并列入真机验证。
+
+## 6. 本地持久化
+
+采用 Room。Repository 边界至少支持：
+
+```kotlin
+interface InfraredKeyRepository {
+    fun observeKeys(
+        profileId: ProviderProfileId,
+        deviceName: DeviceName,
+    ): Flow<DomainResult<List<SavedInfraredKey>>>
+
+    suspend fun getKey(
+        ref: InfraredKeyRef,
+    ): DomainResult<SavedInfraredKey?>
+
+    suspend fun insertLearningKey(
+        key: SavedInfraredKey,
+    ): DomainResult<Unit>
+
+    suspend fun updateStatus(
+        ref: InfraredKeyRef,
+        status: InfraredKeyStatus,
+        lastErrorCode: String?,
+        updatedAtEpochMillis: Long,
+    ): DomainResult<Unit>
+
+    suspend fun renameKey(
+        ref: InfraredKeyRef,
+        displayName: String,
+        updatedAtEpochMillis: Long,
+    ): DomainResult<Unit>
+
+    suspend fun deleteKey(
+        ref: InfraredKeyRef,
+    ): DomainResult<Unit>
+
+    suspend fun findInterruptedLearning(
+        profileId: ProviderProfileId,
+    ): DomainResult<List<SavedInfraredKey>>
+}
+```
+
+具体签名可在实施计划中按项目既有风格调整，但必须保持职责和语义。
+
+### 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<Unit>
+}
+```
+
+本阶段只定义或保证稳定引用边界，不实现 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. 真机验证后对学习语义、超时和错误模型的修订。

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<String, SavedInfraredKey>`（已在 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 编号学习与发射。

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` 安全阻断。

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<SavedInfraredKey> {
+        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}$",
+        )
+    }
+}

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,
+)

domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/InfraredKeyRepository.kt

@@ -0,0 +1,52 @@
+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<DomainResult<List<SavedInfraredKey>>>
+
+    suspend fun getKey(ref: InfraredKeyRef): DomainResult<SavedInfraredKey?>
+
+    suspend fun insert(key: SavedInfraredKey): DomainResult<Unit>
+
+    suspend fun transitionStatus(
+        ref: InfraredKeyRef,
+        expectedStatuses: Set<InfraredKeyStatus>,
+        targetStatus: InfraredKeyStatus,
+        lastErrorCode: String?,
+        lastErrorDetail: String?,
+        updatedAtEpochMillis: Long,
+    ): DomainResult<Unit>
+
+    suspend fun rename(
+        ref: InfraredKeyRef,
+        displayName: String,
+        updatedAtEpochMillis: Long,
+    ): DomainResult<Unit>
+
+    suspend fun deleteIfNotLearning(ref: InfraredKeyRef): DomainResult<Unit>
+
+    /**
+     * Atomically marks this profile's interrupted LEARNING keys as FAILED, clears the vendor
+     * error code, stores [INTERRUPTED_LEARNING_ERROR_DETAIL], and updates their timestamp.
+     */
+    suspend fun failInterruptedLearning(
+        profileId: ProviderProfileId,
+        updatedAtEpochMillis: Long,
+    ): DomainResult<Int>
+}
+
+interface InfraredDeviceConfigurationRepository {
+    fun observeDeviceName(profileId: ProviderProfileId): Flow<DomainResult<DeviceName?>>
+
+    suspend fun setDeviceName(
+        profileId: ProviderProfileId,
+        deviceName: DeviceName,
+    ): DomainResult<Unit>
+}

domain/src/main/kotlin/com/flagship/abox/manager/domain/infrared/LearnInfraredKey.kt

@@ -0,0 +1,138 @@
+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
+
+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<InfraredKeyId> {
+        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
+        }
+
+        return when (
+            val result = gateway.learnKey(
+                profileId = key.profileId,
+                deviceName = key.deviceName,
+                key = key.sdkKey,
+            )
+        ) {
+            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<Unit> {
+        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,
+                    InfraredKeyStatus.READY,
+                ),
+                targetStatus = InfraredKeyStatus.LEARNING,
+                lastErrorCode = null,
+                lastErrorDetail = null,
+                updatedAtEpochMillis = clock.now(),
+            )
+        ) {
+            is DomainResult.Success -> Unit
+            is DomainResult.Failure -> return result
+        }
+
+        return when (
+            val result = gateway.learnKey(
+                profileId = key.profileId,
+                deviceName = key.deviceName,
+                key = key.sdkKey,
+            )
+        ) {
+            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,
+)

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<Unit> {
+        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<Unit> {
+        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<Unit> =
+        repository.deleteIfNotLearning(ref)
+}
+
+class RecoverInterruptedInfraredLearning(
+    private val repository: InfraredKeyRepository,
+    private val clock: EpochMillisClock,
+) {
+    suspend operator fun invoke(profileId: ProviderProfileId): DomainResult<Int> =
+        repository.failInterruptedLearning(profileId, clock.now())
+}

domain/src/test/kotlin/com/flagship/abox/manager/domain/infrared/InMemoryInfraredTestDoubles.kt

@@ -0,0 +1,232 @@
+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<InfraredKeyStatus>,
+    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<InfraredKeyRef, SavedInfraredKey>()
+    private val state = MutableStateFlow<List<SavedInfraredKey>>(emptyList())
+
+    var getError: DomainError? = null
+    var insertError: DomainError? = null
+    var renameError: DomainError? = null
+    var deleteError: DomainError? = null
+    var recoveryError: DomainError? = null
+    val transitionErrors = mutableMapOf<InfraredKeyStatus, DomainError>()
+
+    var onInsert: ((SavedInfraredKey) -> Unit)? = null
+    var onTransition: ((InfraredStatusTransitionCall) -> Unit)? = null
+
+    val insertedKeys = mutableListOf<SavedInfraredKey>()
+    val getCalls = mutableListOf<InfraredKeyRef>()
+    val transitionCalls = mutableListOf<InfraredStatusTransitionCall>()
+    val renameCalls = mutableListOf<InfraredRenameCall>()
+    val deleteCalls = mutableListOf<InfraredKeyRef>()
+    val recoveryCalls = mutableListOf<InfraredRecoveryCall>()
+
+    override fun observeKeys(
+        profileId: ProviderProfileId,
+        deviceName: DeviceName,
+    ): Flow<DomainResult<List<SavedInfraredKey>>> = state.map { values ->
+        DomainResult.Success(
+            values.filter { it.profileId == profileId && it.deviceName == deviceName },
+        )
+    }
+
+    override suspend fun getKey(ref: InfraredKeyRef): DomainResult<SavedInfraredKey?> {
+        getCalls += ref
+        getError?.let { return DomainResult.Failure(it) }
+        return DomainResult.Success(keys[ref])
+    }
+
+    override suspend fun insert(key: SavedInfraredKey): DomainResult<Unit> {
+        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<InfraredKeyStatus>,
+        targetStatus: InfraredKeyStatus,
+        lastErrorCode: String?,
+        lastErrorDetail: String?,
+        updatedAtEpochMillis: Long,
+    ): DomainResult<Unit> {
+        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<Unit> {
+        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<Unit> {
+        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,
+        updatedAtEpochMillis: Long,
+    ): DomainResult<Int> {
+        recoveryCalls += InfraredRecoveryCall(profileId, updatedAtEpochMillis)
+        recoveryError?.let { return DomainResult.Failure(it) }
+        var changed = 0
+        keys.replaceAll { _, key ->
+            if (key.profileId == profileId && key.status == InfraredKeyStatus.LEARNING) {
+                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<SavedInfraredKey> = keys.values.toList()
+
+    private fun publish() {
+        state.value = keys.values.toList()
+    }
+}
+
+class RecordingInfraredGateway : InfraredGateway {
+    var learnResult: DomainResult<Unit> = DomainResult.Success(Unit)
+    var sendResult: DomainResult<Unit> = DomainResult.Success(Unit)
+    var onLearn: ((ProviderProfileId, DeviceName, String) -> DomainResult<Unit>)? = null
+    val learnedKeys = mutableListOf<InfraredLearningCall>()
+    val sentKeys = mutableListOf<InfraredSendCall>()
+
+    override suspend fun learnKey(
+        profileId: ProviderProfileId,
+        deviceName: DeviceName,
+        key: String,
+    ): DomainResult<Unit> {
+        learnedKeys += InfraredLearningCall(profileId, deviceName, key)
+        return onLearn?.invoke(profileId, deviceName, key) ?: learnResult
+    }
+
+    override suspend fun sendKey(
+        profileId: ProviderProfileId,
+        deviceName: DeviceName,
+        key: String,
+    ): DomainResult<Unit> {
+        sentKeys += InfraredSendCall(profileId, deviceName, key)
+        return sendResult
+    }
+
+    override suspend fun downloadCodes(
+        profileId: ProviderProfileId,
+        codes: List<InfraredCode>,
+    ): DomainResult<List<InfraredCodeDownloadResult>> = DomainResult.Success(emptyList())
+}
+
+fun SavedInfraredKey.ref() = InfraredKeyRef(
+    profileId = profileId,
+    keyId = id,
+)

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

domain/src/test/kotlin/com/flagship/abox/manager/domain/infrared/LearnInfraredKeyTest.kt

@@ -0,0 +1,299 @@
+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)
+
+    @Test
+    fun persistsLearningBeforeCallingHardwareThenMarksReady() = runTest {
+        val events = mutableListOf<String>()
+        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, InfraredKeyStatus.READY),
+            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)
+    }
+
+    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++
+}

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

gradle.properties

@@ -3,3 +3,4 @@ org.gradle.configuration-cache=false
 android.useAndroidX=true
 android.nonTransitiveRClass=true
 kotlin.code.style=official
+android.overridePathCheck=true

gradle/libs.versions.toml

@@ -17,6 +17,7 @@ espresso = "3.6.1"
 [libraries]
 androidx-activity-compose = { module = "androidx.activity:activity-compose", version.ref = "activityCompose" }
 androidx-lifecycle-runtime-compose = { module = "androidx.lifecycle:lifecycle-runtime-compose", version.ref = "lifecycle" }
+androidx-lifecycle-viewmodel-ktx = { module = "androidx.lifecycle:lifecycle-viewmodel-ktx", version.ref = "lifecycle" }
 androidx-navigation-compose = { module = "androidx.navigation:navigation-compose", version.ref = "navigationCompose" }
 androidx-hilt-navigation-compose = { module = "androidx.hilt:hilt-navigation-compose", version = "1.2.0" }
 compose-bom = { module = "androidx.compose:compose-bom", version.ref = "composeBom" }
@@ -32,6 +33,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" }

settings.gradle.kts

@@ -26,4 +26,5 @@ include(":domain")
 include(":absdk-bridge")
 include(":testing:fakes")
 include(":android:core:designsystem")
+include(":android:feature:infrared")
 include(":android:app")

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<DeviceKey, SocketPowerState>()
@@ -78,10 +78,11 @@ class FakeTemperatureHumidityGateway : TemperatureHumidityGateway {
 }
 
 class FakeInfraredGateway : InfraredGateway {
-    val sentKeys: MutableList<InfraredCall> = Collections.synchronizedList(mutableListOf())
+    val sentKeys = CopyOnWriteArrayList<InfraredCall>()
-    val learnedKeys: MutableList<InfraredCall> = Collections.synchronizedList(mutableListOf())
+    val learnedKeys = CopyOnWriteArrayList<InfraredCall>()
-    val downloadCalls: MutableList<InfraredDownloadCall> =
+    val downloadCalls = CopyOnWriteArrayList<InfraredDownloadCall>()
-        Collections.synchronizedList(mutableListOf())
+    private val sendResults = ConcurrentHashMap<InfraredOperationKey, DomainResult<Unit>>()
+    private val learnResults = ConcurrentHashMap<InfraredOperationKey, DomainResult<Unit>>()
 
     @Volatile
     var sendResult: DomainResult<Unit> = DomainResult.Success(Unit)
@@ -98,7 +99,7 @@ class FakeInfraredGateway : InfraredGateway {
         key: String,
     ): DomainResult<Unit> {
         sentKeys += InfraredCall(profileId, deviceName, key)
-        return sendResult
+        return sendResults[InfraredOperationKey(profileId, deviceName, key)] ?: sendResult
     }
 
     override suspend fun learnKey(
@@ -107,16 +108,37 @@ class FakeInfraredGateway : InfraredGateway {
         key: String,
     ): DomainResult<Unit> {
         learnedKeys += InfraredCall(profileId, deviceName, key)
-        return learnResult
+        return learnResults[InfraredOperationKey(profileId, deviceName, key)] ?: learnResult
+    }
+
+    fun setSendResult(
+        profileId: ProviderProfileId,
+        deviceName: DeviceName,
+        key: String,
+        result: DomainResult<Unit>,
+    ) {
+        sendResults[InfraredOperationKey(profileId, deviceName, key)] = result
+    }
+
+    fun setLearnResult(
+        profileId: ProviderProfileId,
+        deviceName: DeviceName,
+        key: String,
+        result: DomainResult<Unit>,
+    ) {
+        learnResults[InfraredOperationKey(profileId, deviceName, key)] = result
     }
 
     override suspend fun downloadCodes(
         profileId: ProviderProfileId,
         codes: List<InfraredCode>,
     ): DomainResult<List<InfraredCodeDownloadResult>> {
+        val codesSnapshot = codes.toList()
         downloadError?.let { return DomainResult.Failure(it) }
-        downloadCalls += InfraredDownloadCall(profileId, codes)
+        downloadCalls += InfraredDownloadCall(profileId, codesSnapshot)
-        return DomainResult.Success(codes.map { InfraredCodeDownloadResult(it, successful = true) })
+        return DomainResult.Success(
+            codesSnapshot.map { InfraredCodeDownloadResult(it, successful = true) },
+        )
     }
 }
 
@@ -131,6 +153,12 @@ data class InfraredDownloadCall(
     val codes: List<InfraredCode>,
 )
 
+private data class InfraredOperationKey(
+    val profileId: ProviderProfileId,
+    val deviceName: DeviceName,
+    val key: String,
+)
+
 private data class DeviceKey(
     val profileId: ProviderProfileId,
     val deviceName: DeviceName,

testing/fakes/src/main/kotlin/com/flagship/abox/manager/testing/fakes/FakeInfraredKeyRepository.kt

@@ -0,0 +1,162 @@
+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<InfraredKeyRef, SavedInfraredKey>()
+    private val state = MutableStateFlow<List<SavedInfraredKey>>(emptyList())
+
+    override fun observeKeys(
+        profileId: ProviderProfileId,
+        deviceName: DeviceName,
+    ): Flow<DomainResult<List<SavedInfraredKey>>> = state.map { values ->
+        DomainResult.Success(
+            values.filter { it.profileId == profileId && it.deviceName == deviceName },
+        )
+    }
+
+    override suspend fun getKey(ref: InfraredKeyRef): DomainResult<SavedInfraredKey?> =
+        synchronized(lock) {
+            DomainResult.Success(keys[ref])
+        }
+
+    override suspend fun insert(key: SavedInfraredKey): DomainResult<Unit> = 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<InfraredKeyStatus>,
+        targetStatus: InfraredKeyStatus,
+        lastErrorCode: String?,
+        lastErrorDetail: String?,
+        updatedAtEpochMillis: Long,
+    ): DomainResult<Unit> = 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<Unit> = 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<Unit> =
+        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,
+        updatedAtEpochMillis: Long,
+    ): DomainResult<Int> = synchronized(lock) {
+        var changed = 0
+        keys.replaceAll { _, key ->
+            if (key.profileId == profileId && key.status == InfraredKeyStatus.LEARNING) {
+                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<Map<ProviderProfileId, DeviceName>>(emptyMap())
+
+    override fun observeDeviceName(
+        profileId: ProviderProfileId,
+    ): Flow<DomainResult<DeviceName?>> = deviceNames.map { values ->
+        DomainResult.Success(values[profileId])
+    }
+
+    override suspend fun setDeviceName(
+        profileId: ProviderProfileId,
+        deviceName: DeviceName,
+    ): DomainResult<Unit> = 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,
+)

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<Throwable>()
+        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"),
+        )
+    }
 }

testing/fakes/src/test/kotlin/com/flagship/abox/manager/testing/fakes/FakeInfraredKeyRepositoryTest.kt

@@ -0,0 +1,264 @@
+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<SavedInfraredKey>()),
+                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 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<SavedInfraredKey?>).value
+
+    private fun assertInvalidRequest(result: DomainResult<*>) {
+        assertTrue(result is DomainResult.Failure)
+        assertTrue((result as DomainResult.Failure).error is DomainError.InvalidRequest)
+    }
+}