Migrate PC mouse repeat to PC protocol

- Parse PC repeat capabilities and send repeat start/stop commands
- Mirror PC-side repeat state for switch-stop behavior
- Move PC repeat settings source of truth out of Android

🤖 Auto-generated

Author: OwenMcGirr

app/src/main/java/com/enaboapps/switchify/pc/PcConnector.kt

@@ -16,6 +16,8 @@ sealed class PcPingResult {
 sealed class PcControlCommand {
     data class Move(val dx: Int, val dy: Int) : PcControlCommand()
     data class Scroll(val dx: Int, val dy: Int) : PcControlCommand()
+    data class RepeatStart(val command: PcControlCommand) : PcControlCommand()
+    data object RepeatStop : PcControlCommand()
     data class DragStart(val button: String = "left") : PcControlCommand()
     data class DragEnd(val button: String = "left") : PcControlCommand()
     data class TypeText(val text: String) : PcControlCommand()

app/src/main/java/com/enaboapps/switchify/pc/PcMouseRepeatManager.kt

@@ -19,6 +19,10 @@ class PcMouseRepeatManager internal constructor(
     private var repeatedCommand: PcControlCommand? = null
     private var repeatArmed = false
     private var pausedForReconnect = false
+    private var pcSideRepeatActive = false
+    private var pcSideRepeatPending = false
+    private var stopPcSideRepeat: (suspend () -> PcCommandResult)? = null
+    private var pcSideScope: CoroutineScope? = null
 
     companion object {
         internal const val RECONNECT_GRACE_MS = 5_000L
@@ -30,7 +34,7 @@ class PcMouseRepeatManager internal constructor(
     }
 
     fun init(context: Context) {
-        settings = PreferencePcMouseRepeatSettings(context.applicationContext)
+        settings = DefaultPcMouseRepeatSettings
     }
 
     fun canRepeat(command: PcControlCommand): Boolean {
@@ -47,6 +51,43 @@ class PcMouseRepeatManager internal constructor(
         return true
     }
 
+    fun armPcSideRepeat(
+        command: PcControlCommand,
+        scope: CoroutineScope,
+        stopRepeatedCommand: suspend () -> PcCommandResult
+    ): Boolean {
+        if (!isRepeatable(command)) return false
+
+        stop(showMessage = false)
+        pcSideRepeatPending = true
+        pcSideRepeatActive = false
+        pcSideScope = scope
+        stopPcSideRepeat = stopRepeatedCommand
+        repeatedCommand = command
+        repeatArmed = true
+        showMessage(R.string.pc_mouse_repeat_started, MessageSeverity.Success)
+        return true
+    }
+
+    fun confirmPcSideStarted(command: PcControlCommand): Boolean {
+        if (!pcSideRepeatPending || repeatedCommand != command) return false
+
+        pcSideRepeatPending = false
+        pcSideRepeatActive = true
+        repeatArmed = true
+        return true
+    }
+
+    fun cancelPcSidePending(showMessage: Boolean = false): Boolean {
+        if (!pcSideRepeatPending && !pcSideRepeatActive) return false
+
+        clearPcSideRepeatState()
+        if (showMessage) {
+            showMessage(R.string.pc_mouse_repeat_stopped, MessageSeverity.Info)
+        }
+        return true
+    }
+
     fun startAfterInitialSend(
         command: PcControlCommand,
         scope: CoroutineScope,
@@ -159,10 +200,28 @@ class PcMouseRepeatManager internal constructor(
         return true
     }
 
-    fun stopForSwitchPress(): Boolean = stop()
+    fun stopForSwitchPress(): Boolean {
+        if (stopPcSideForSwitchPress()) return true
+        return stop()
+    }
+
+    private fun stopPcSideForSwitchPress(): Boolean {
+        if (!pcSideRepeatPending && !pcSideRepeatActive) return false
+
+        val stop = stopPcSideRepeat
+        val scope = pcSideScope
+        clearPcSideRepeatState()
+        showMessage(R.string.pc_mouse_repeat_stopped, MessageSeverity.Info)
+        if (stop != null && scope != null) {
+            scope.launch {
+                stop()
+            }
+        }
+        return true
+    }
 
     fun isRepeating(): Boolean {
-        return repeatArmed && repeatedCommand != null
+        return (repeatArmed && repeatedCommand != null) || pcSideRepeatPending || pcSideRepeatActive
     }
 
     fun clearServiceState(showMessage: Boolean = false) {
@@ -207,6 +266,20 @@ class PcMouseRepeatManager internal constructor(
         repeatedCommand = null
         repeatArmed = false
         pausedForReconnect = false
+        clearPcSideState()
+    }
+
+    private fun clearPcSideRepeatState() {
+        repeatedCommand = null
+        repeatArmed = false
+        clearPcSideState()
+    }
+
+    private fun clearPcSideState() {
+        pcSideRepeatActive = false
+        pcSideRepeatPending = false
+        stopPcSideRepeat = null
+        pcSideScope = null
     }
 
     private fun showMessage(messageResId: Int, severity: MessageSeverity) {
@@ -221,6 +294,7 @@ class PcMouseRepeatManager internal constructor(
         repeatedCommand = null
         repeatArmed = false
         pausedForReconnect = false
+        clearPcSideState()
         settings = null
         showHudMessage = defaultHudMessageHandler()
     }
@@ -234,6 +308,11 @@ class PcMouseRepeatManager internal constructor(
     }
 }
 
+private object DefaultPcMouseRepeatSettings : PcMouseRepeatSettings {
+    override fun isEnabled(): Boolean = true
+    override fun intervalMs(): Long = PcMouseRepeatDefaults.DEFAULT_INTERVAL_MS
+}
+
 private fun defaultHudMessageHandler(): (Int, MessageSeverity) -> Unit = { messageResId, severity ->
     ServiceMessageHUD.instance.showMessage(
         messageResId,

app/src/main/java/com/enaboapps/switchify/pc/PcPointerProfile.kt

@@ -12,7 +12,16 @@ data class PcPointerMovementProfile(
 data class PcPointerCapabilities(
     val noAckMouseMove: Boolean = false,
     val noAckCommands: Set<String> = emptySet(),
-    val supportedCommands: Set<String> = emptySet()
+    val supportedCommands: Set<String> = emptySet(),
+    val mouseRepeat: PcMouseRepeatCapabilities = PcMouseRepeatCapabilities()
+)
+
+data class PcMouseRepeatCapabilities(
+    val supported: Boolean = false,
+    val enabled: Boolean = false,
+    val intervalMs: Long = 250L,
+    val minIntervalMs: Long = 100L,
+    val maxIntervalMs: Long = 2000L
 )
 
 data class PcPointerBounds(

app/src/main/java/com/enaboapps/switchify/pc/PcProtocol.kt

@@ -178,6 +178,41 @@ object PcProtocol {
         return authenticatedCommand(id, deviceId, token, timestamp, "mouse.scroll", JSONObject().put("dx", dx).put("dy", dy), responseMode)
     }
 
+    fun mouseRepeatStart(
+        id: String,
+        deviceId: String,
+        token: String,
+        timestamp: Long,
+        command: PcControlCommand
+    ): String {
+        val nested = when (command) {
+            is PcControlCommand.Move -> JSONObject()
+                .put("type", "mouse.move")
+                .put("payload", JSONObject().put("dx", command.dx).put("dy", command.dy))
+            is PcControlCommand.Scroll -> JSONObject()
+                .put("type", "mouse.scroll")
+                .put("payload", JSONObject().put("dx", command.dx).put("dy", command.dy))
+            else -> throw IllegalArgumentException("Unsupported repeat command.")
+        }
+        return authenticatedCommand(
+            id,
+            deviceId,
+            token,
+            timestamp,
+            "mouse.repeat.start",
+            JSONObject().put("command", nested)
+        )
+    }
+
+    fun mouseRepeatStop(
+        id: String,
+        deviceId: String,
+        token: String,
+        timestamp: Long
+    ): String {
+        return authenticatedCommand(id, deviceId, token, timestamp, "mouse.repeat.stop", JSONObject())
+    }
+
     fun mouseDragStart(
         id: String,
         deviceId: String,
@@ -494,7 +529,8 @@ object PcProtocol {
         val capabilities = PcPointerCapabilities(
             noAckMouseMove = capabilitiesJson?.optBoolean("noAckMouseMove", false) ?: false,
             noAckCommands = noAckCommands,
-            supportedCommands = supportedCommands
+            supportedCommands = supportedCommands,
+            mouseRepeat = parseMouseRepeatCapabilities(capabilitiesJson) ?: return PcProtocolResponse.Invalid
         )
         val bounds = PcPointerBounds(
             x = boundsJson.optInt("x"),
@@ -532,6 +568,26 @@ object PcProtocol {
         )
     }
 
+    private fun parseMouseRepeatCapabilities(capabilitiesJson: JSONObject?): PcMouseRepeatCapabilities? {
+        val repeatJson = capabilitiesJson?.opt("mouseRepeat") ?: return PcMouseRepeatCapabilities()
+        if (repeatJson !is JSONObject) return null
+
+        val intervalMs = repeatJson.optLong("intervalMs", 250L)
+        val minIntervalMs = repeatJson.optLong("minIntervalMs", 100L)
+        val maxIntervalMs = repeatJson.optLong("maxIntervalMs", 2000L)
+        if (intervalMs <= 0L || minIntervalMs <= 0L || maxIntervalMs < minIntervalMs) return null
+        if (repeatJson.has("supported") && repeatJson.opt("supported") !is Boolean) return null
+        if (repeatJson.has("enabled") && repeatJson.opt("enabled") !is Boolean) return null
+
+        return PcMouseRepeatCapabilities(
+            supported = repeatJson.optBoolean("supported", false),
+            enabled = repeatJson.optBoolean("enabled", false),
+            intervalMs = intervalMs,
+            minIntervalMs = minIntervalMs,
+            maxIntervalMs = maxIntervalMs
+        )
+    }
+
     private fun parseNoAckCommands(capabilitiesJson: JSONObject?): Set<String>? {
         if (capabilitiesJson == null || !capabilitiesJson.has("noAckCommands")) return emptySet()
         val commandsJson = capabilitiesJson.opt("noAckCommands")
@@ -585,6 +641,8 @@ object PcProtocol {
         "connection.ping",
         "connection.disconnecting",
         "pointer.profile",
+        "mouse.repeat.start",
+        "mouse.repeat.stop",
         "keyboard.textStream.open",
         "keyboard.textStream.chunk",
         "keyboard.textStream.close"

app/src/main/java/com/enaboapps/switchify/pc/bluetooth/SwitchifyPcBleClient.kt

@@ -280,6 +280,8 @@ class SwitchifyPcBleClient(
         return when (this) {
             is PcControlCommand.Move -> PcProtocol.mouseMove(id, deviceId, token, timestamp, dx, dy, responseMode)
             is PcControlCommand.Scroll -> PcProtocol.mouseScroll(id, deviceId, token, timestamp, dx, dy, responseMode)
+            is PcControlCommand.RepeatStart -> PcProtocol.mouseRepeatStart(id, deviceId, token, timestamp, command)
+            PcControlCommand.RepeatStop -> PcProtocol.mouseRepeatStop(id, deviceId, token, timestamp)
             is PcControlCommand.DragStart -> PcProtocol.mouseDragStart(id, deviceId, token, timestamp, button, responseMode)
             is PcControlCommand.DragEnd -> PcProtocol.mouseDragEnd(id, deviceId, token, timestamp, button, responseMode)
             PcControlCommand.LeftClick -> PcProtocol.mouseClick(id, deviceId, token, timestamp, responseMode = responseMode)
@@ -385,6 +387,8 @@ private fun PcControlCommand.protocolType(): String {
     return when (this) {
         is PcControlCommand.Move -> "mouse.move"
         is PcControlCommand.Scroll -> "mouse.scroll"
+        is PcControlCommand.RepeatStart -> "mouse.repeat.start"
+        PcControlCommand.RepeatStop -> "mouse.repeat.stop"
         is PcControlCommand.DragStart -> "mouse.dragStart"
         is PcControlCommand.DragEnd -> "mouse.dragEnd"
         PcControlCommand.LeftClick -> "mouse.click"

app/src/main/java/com/enaboapps/switchify/screens/pc/PcMouseControlViewModel.kt

@@ -143,13 +143,53 @@ class PcMouseControlViewModel(
     }
 
     fun sendMouseCommand(command: PcControlCommand, repeatable: Boolean) {
+        val mouseRepeat = currentMouseRepeatCapabilities()
+        if (repeatable && mouseRepeat?.supported == true) {
+            if (mouseRepeat.enabled) {
+                sendPcSideRepeatCommand(command)
+            } else {
+                send(command)
+            }
+            return
+        }
+
         if (repeatable && mouseRepeatManager.armForInitialSend(command)) {
             sendRepeatableMouseCommand(command)
             return
         }
         send(command)
     }
 
+    private fun sendPcSideRepeatCommand(command: PcControlCommand) {
+        val controller = serviceControllerProvider()
+        if (controller == null || !mouseRepeatManager.armPcSideRepeat(
+            command = command,
+            scope = viewModelScope,
+            stopRepeatedCommand = { controller.sendControlCommand(PcControlCommand.RepeatStop) }
+        )) {
+            send(command)
+            return
+        }
+
+        viewModelScope.launch(start = CoroutineStart.UNDISPATCHED) {
+            when (sendNoAckCommandNow(PcControlCommand.RepeatStart(command)) {
+                it.copy(
+                    isBusy = false,
+                    busyCommand = null,
+                    message = null
+                )
+            }) {
+                PcCommandResult.Ack -> {
+                    mouseRepeatManager.confirmPcSideStarted(command)
+                }
+                is PcCommandResult.AuthFailed,
+                is PcCommandResult.Failed -> {
+                    mouseRepeatManager.cancelPcSidePending(showMessage = false)
+                }
+            }
+        }
+    }
+
     private fun sendRepeatableMouseCommand(command: PcControlCommand) {
         viewModelScope.launch(start = CoroutineStart.UNDISPATCHED) {
             when (sendRepeatCommand(command)) {
@@ -567,6 +607,12 @@ class PcMouseControlViewModel(
             ?: false
     }
 
+    private fun currentMouseRepeatCapabilities() =
+        ((serviceControllerProvider()?.state?.value as? PcServiceConnectionState.Connected)?.pointerProfile
+            ?: serviceControllerProvider()?.currentPointerProfile())
+            ?.capabilities
+            ?.mouseRepeat
+
     private suspend fun sendEnterAfterTypedText(controller: PcServiceConnectionController) {
         when (val keyResult = controller.sendRealtimeControlCommand(PcControlCommand.PressKey(PcKeyboardKey.Enter))) {
             PcCommandResult.Ack -> clearTypingSendAfterEnter()