Merge pull request #2339 from switchifyapp/feature/pc-medium-pointer-profile-movement-2338

OwenMcGirr · web-flow · commit 80acf2cb8717 · 2026-06-07T15:30:37.000+01:00
Add PC mouse movement size selection
diff --git a/app/src/main/java/com/enaboapps/switchify/backend/preferences/PreferenceManager.kt b/app/src/main/java/com/enaboapps/switchify/backend/preferences/PreferenceManager.kt
@@ -25,6 +25,7 @@ class PreferenceManager(context: Context) {
         const val PREFERENCE_KEY_PAUSE_TIMEOUT = "pause_timeout"
         const val PREFERENCE_KEY_MOVE_REPEAT = "move_repeat"
         const val PREFERENCE_KEY_MOVE_REPEAT_DELAY = "move_repeat_delay"
+        const val PREFERENCE_KEY_PC_MOUSE_MOVEMENT_SIZE = "pc_mouse_movement_size"
         const val PREFERENCE_KEY_AUTOMATICALLY_START_SCAN_AFTER_SELECTION =
             "automatically_start_scan_after_selection"
         const val PREFERENCE_KEY_PAUSE_ON_FIRST_ITEM = "pause_on_first_item"
diff --git a/app/src/main/java/com/enaboapps/switchify/screens/pc/PcMouseCommandGrid.kt b/app/src/main/java/com/enaboapps/switchify/screens/pc/PcMouseCommandGrid.kt
@@ -10,6 +10,10 @@ import androidx.compose.foundation.lazy.grid.GridCells
 import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
 import androidx.compose.foundation.lazy.grid.items
 import androidx.compose.material3.Button
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.SegmentedButton
+import androidx.compose.material3.SegmentedButtonDefaults
+import androidx.compose.material3.SingleChoiceSegmentedButtonRow
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
@@ -20,7 +24,7 @@ import com.enaboapps.switchify.R
 import com.enaboapps.switchify.pc.PcMouseCommand
 
 data class PcMouseControlSpec(
-    @StringRes val labelResId: Int,
+    @param:StringRes val labelResId: Int,
     val command: PcMouseCommand
 )
 
@@ -56,6 +60,36 @@ fun PcMouseCommandGrid(
     }
 }
 
+@Composable
+fun PcMouseMovementSizeSelector(
+    selectedSize: PcMouseMovementSize,
+    onSizeSelected: (PcMouseMovementSize) -> Unit,
+    modifier: Modifier = Modifier
+) {
+    val sizes = PcMouseMovementSize.entries
+    val colors = SegmentedButtonDefaults.colors(
+        activeContainerColor = MaterialTheme.colorScheme.primary,
+        activeContentColor = MaterialTheme.colorScheme.onPrimary,
+        activeBorderColor = MaterialTheme.colorScheme.primary,
+        inactiveContainerColor = MaterialTheme.colorScheme.surface,
+        inactiveContentColor = MaterialTheme.colorScheme.onSurface,
+        inactiveBorderColor = MaterialTheme.colorScheme.outline
+    )
+
+    SingleChoiceSegmentedButtonRow(modifier = modifier.fillMaxWidth()) {
+        sizes.forEachIndexed { index, size ->
+            SegmentedButton(
+                selected = selectedSize == size,
+                onClick = { onSizeSelected(size) },
+                shape = SegmentedButtonDefaults.itemShape(index = index, count = sizes.size),
+                colors = colors
+            ) {
+                Text(text = stringResource(size.labelResId))
+            }
+        }
+    }
+}
+
 fun pcMouseControlSpecs(moveStep: Int): List<PcMouseControlSpec> {
     val step = moveStep.coerceAtLeast(1)
     val scrollStep = 5
diff --git a/app/src/main/java/com/enaboapps/switchify/screens/pc/PcMouseControlActivity.kt b/app/src/main/java/com/enaboapps/switchify/screens/pc/PcMouseControlActivity.kt
@@ -116,6 +116,15 @@ private fun PcMouseControlScreen(
                         color = MaterialTheme.colorScheme.onSurfaceVariant
                     )
                 }
+                Text(
+                    text = stringResource(R.string.pc_mouse_movement_size),
+                    style = MaterialTheme.typography.titleMedium,
+                    color = MaterialTheme.colorScheme.onSurface
+                )
+                PcMouseMovementSizeSelector(
+                    selectedSize = uiState.selectedMovementSize,
+                    onSizeSelected = viewModel::selectMovementSize
+                )
                 PcMouseCommandGrid(
                     connected = uiState.connectedDisplayName != null,
                     movementStep = uiState.movementStep,
diff --git a/app/src/main/java/com/enaboapps/switchify/screens/pc/PcMouseControlViewModel.kt b/app/src/main/java/com/enaboapps/switchify/screens/pc/PcMouseControlViewModel.kt
@@ -13,7 +13,6 @@ import com.enaboapps.switchify.pc.PcDeviceIdentityRepository
 import com.enaboapps.switchify.pc.PcMouseCommand
 import com.enaboapps.switchify.pc.PcAuthenticatedSession
 import com.enaboapps.switchify.pc.PcPairingTokenStore
-import com.enaboapps.switchify.pc.PcPointerMovementProfile
 import com.enaboapps.switchify.pc.PcTokenStore
 import com.enaboapps.switchify.pc.SwitchifyPcClient
 import kotlinx.coroutines.CompletableDeferred
@@ -28,37 +27,52 @@ import kotlinx.coroutines.launch
 
 data class PcMouseControlUiState(
     val connectedDisplayName: String? = null,
-    val movementStep: Int = PcMouseControlViewModel.DEFAULT_MOVE_STEP,
+    val selectedMovementSize: PcMouseMovementSize = PcMouseMovementSize.Small,
+    val movementStep: Int = PcMouseControlViewModel.FALLBACK_MOVEMENT_STEPS.small,
     val isBusy: Boolean = false,
     val busyCommand: PcMouseCommand? = null,
     val message: String? = null
 )
 
 class PcMouseControlViewModel(
     private val tokenStore: PcPairingTokenStore,
-    private val connector: PcConnector
+    private val connector: PcConnector,
+    private val movementSizeStore: PcMouseMovementSizeStore
 ) : ViewModel() {
     constructor(context: Context) : this(
         tokenStore = PcTokenStore(context.applicationContext),
         connector = SwitchifyPcClient(
             PcDeviceIdentityRepository(context.applicationContext),
             PcTokenStore(context.applicationContext)
-        )
+        ),
+        movementSizeStore = PcMouseMovementPreferenceStore(context.applicationContext)
     )
 
     private val _uiState = MutableStateFlow(PcMouseControlUiState())
     val uiState: StateFlow<PcMouseControlUiState> = _uiState.asStateFlow()
     private var liveConnection: PcMouseControlConnection? = null
     private var liveSession: PcAuthenticatedSession? = null
     private var liveConnectionDeferred: Deferred<PcMouseControlConnection?>? = null
+    private var movementSteps = FALLBACK_MOVEMENT_STEPS
 
     init {
+        val selectedSize = movementSizeStore.getSelectedSize()
+        _uiState.update {
+            it.copy(
+                selectedMovementSize = selectedSize,
+                movementStep = movementSteps.stepFor(selectedSize)
+            )
+        }
         viewModelScope.launch {
             PcConnectionStateHolder.connectionState.collect { state ->
                 _uiState.update {
                     it.copy(
                         connectedDisplayName = (state as? PcConnectionState.Connected)?.displayName,
-                        movementStep = if (state is PcConnectionState.Connected) it.movementStep else DEFAULT_MOVE_STEP
+                        movementStep = if (state is PcConnectionState.Connected) {
+                            it.movementStep
+                        } else {
+                            fallbackStepFor(it.selectedMovementSize)
+                        }
                     )
                 }
                 when (state) {
@@ -69,6 +83,16 @@ class PcMouseControlViewModel(
         }
     }
 
+    fun selectMovementSize(size: PcMouseMovementSize) {
+        movementSizeStore.setSelectedSize(size)
+        _uiState.update {
+            it.copy(
+                selectedMovementSize = size,
+                movementStep = movementSteps.stepFor(size)
+            )
+        }
+    }
+
     fun send(command: PcMouseCommand) {
         val connected = PcConnectionStateHolder.connectionState.value as? PcConnectionState.Connected
         if (connected == null) {
@@ -134,18 +158,20 @@ class PcMouseControlViewModel(
             when (val result = connector.openMouseControlSession(session)) {
                 is PcLiveControlResult.Connected -> {
                     liveConnection = result.connection
+                    movementSteps = result.connection.pointerProfile?.toMouseMovementSteps() ?: FALLBACK_MOVEMENT_STEPS
                     _uiState.update {
-                        it.copy(movementStep = result.connection.pointerProfile?.smallMovementStep() ?: DEFAULT_MOVE_STEP)
+                        it.copy(movementStep = movementSteps.stepFor(it.selectedMovementSize))
                     }
                     result.connection
                 }
                 is PcLiveControlResult.AuthFailed -> {
                     tokenStore.clearToken(session.desktopId)
                     PcConnectionStateHolder.setDisconnected()
+                    movementSteps = FALLBACK_MOVEMENT_STEPS
                     _uiState.update {
                         it.copy(
                             connectedDisplayName = null,
-                            movementStep = DEFAULT_MOVE_STEP,
+                            movementStep = movementSteps.stepFor(it.selectedMovementSize),
                             isBusy = false,
                             busyCommand = null,
                             message = CONNECT_FIRST_MESSAGE
@@ -173,12 +199,17 @@ class PcMouseControlViewModel(
         liveConnectionDeferred = null
     }
 
-    private fun PcPointerMovementProfile.smallMovementStep(): Int {
-        return recommendedDeltas.small.coerceIn(1, maxDelta)
+    private fun fallbackStepFor(size: PcMouseMovementSize): Int {
+        movementSteps = FALLBACK_MOVEMENT_STEPS
+        return movementSteps.stepFor(size)
     }
 
     companion object {
-        const val DEFAULT_MOVE_STEP = 40
+        val FALLBACK_MOVEMENT_STEPS = PcMouseMovementSteps(
+            small = 40,
+            medium = 80,
+            large = 160
+        )
         const val CONNECT_FIRST_MESSAGE = "Connect to PC from Switchify first."
         const val COMMAND_FAILED_MESSAGE = "Could not send command to PC."
     }
diff --git a/app/src/main/java/com/enaboapps/switchify/screens/pc/PcMouseMovementSize.kt b/app/src/main/java/com/enaboapps/switchify/screens/pc/PcMouseMovementSize.kt
@@ -0,0 +1,66 @@
+package com.enaboapps.switchify.screens.pc
+
+import android.content.Context
+import androidx.annotation.StringRes
+import com.enaboapps.switchify.R
+import com.enaboapps.switchify.backend.preferences.PreferenceManager
+import com.enaboapps.switchify.pc.PcPointerMovementProfile
+
+enum class PcMouseMovementSize(
+    val preferenceValue: String,
+    @param:StringRes val labelResId: Int
+) {
+    Small("small", R.string.pc_mouse_movement_small),
+    Medium("medium", R.string.pc_mouse_movement_medium),
+    Large("large", R.string.pc_mouse_movement_large);
+
+    companion object {
+        fun fromPreferenceValue(value: String): PcMouseMovementSize {
+            return entries.firstOrNull { it.preferenceValue == value } ?: Small
+        }
+    }
+}
+
+data class PcMouseMovementSteps(
+    val small: Int,
+    val medium: Int,
+    val large: Int
+) {
+    fun stepFor(size: PcMouseMovementSize): Int {
+        return when (size) {
+            PcMouseMovementSize.Small -> small
+            PcMouseMovementSize.Medium -> medium
+            PcMouseMovementSize.Large -> large
+        }
+    }
+}
+
+interface PcMouseMovementSizeStore {
+    fun getSelectedSize(): PcMouseMovementSize
+    fun setSelectedSize(size: PcMouseMovementSize)
+}
+
+class PcMouseMovementPreferenceStore(context: Context) : PcMouseMovementSizeStore {
+    private val preferenceManager = PreferenceManager(context.applicationContext)
+
+    override fun getSelectedSize(): PcMouseMovementSize {
+        return PcMouseMovementSize.fromPreferenceValue(
+            preferenceManager.getStringValue(PreferenceManager.PREFERENCE_KEY_PC_MOUSE_MOVEMENT_SIZE)
+        )
+    }
+
+    override fun setSelectedSize(size: PcMouseMovementSize) {
+        preferenceManager.setStringValue(
+            PreferenceManager.PREFERENCE_KEY_PC_MOUSE_MOVEMENT_SIZE,
+            size.preferenceValue
+        )
+    }
+}
+
+fun PcPointerMovementProfile.toMouseMovementSteps(): PcMouseMovementSteps {
+    return PcMouseMovementSteps(
+        small = recommendedDeltas.small.coerceIn(1, maxDelta),
+        medium = recommendedDeltas.medium.coerceIn(1, maxDelta),
+        large = recommendedDeltas.large.coerceIn(1, maxDelta)
+    )
+}
diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml
@@ -277,6 +277,10 @@
     <string name="pc_control_could_not_connect">Could not connect to PC.</string>
     <string name="pc_control_command_failed">Could not send command to PC.</string>
     <string name="pc_mouse_control_connected">Connected to %1$s.</string>
+    <string name="pc_mouse_movement_size">Movement size</string>
+    <string name="pc_mouse_movement_small">Small</string>
+    <string name="pc_mouse_movement_medium">Medium</string>
+    <string name="pc_mouse_movement_large">Large</string>
     <string name="request_rejected">Request rejected.</string>
     <string name="request_expired_try_again">Request expired. Try again.</string>
     <string name="pc_mouse_up_left">Up left</string>
diff --git a/app/src/test/java/com/enaboapps/switchify/screens/pc/PcMouseCommandGridTest.kt b/app/src/test/java/com/enaboapps/switchify/screens/pc/PcMouseCommandGridTest.kt
@@ -6,17 +6,31 @@ import org.junit.Test
 
 class PcMouseCommandGridTest {
     @Test
-    fun movementCommandsUseProvidedStep() {
-        val commands = pcMouseControlSpecs(130).map { it.command }
+    fun movementCommandsUseSmallFallbackStep() {
+        val commands = pcMouseControlSpecs(40).map { it.command }
+
+        assertEquals(PcMouseCommand.Move(-40, -40), commands[0])
+        assertEquals(PcMouseCommand.Move(0, -40), commands[1])
+        assertEquals(PcMouseCommand.Move(40, -40), commands[2])
+        assertEquals(PcMouseCommand.Move(-40, 0), commands[3])
+        assertEquals(PcMouseCommand.Move(40, 0), commands[5])
+        assertEquals(PcMouseCommand.Move(-40, 40), commands[6])
+        assertEquals(PcMouseCommand.Move(0, 40), commands[7])
+        assertEquals(PcMouseCommand.Move(40, 40), commands[8])
+    }
+
+    @Test
+    fun movementCommandsUseMediumFallbackStep() {
+        val commands = pcMouseControlSpecs(80).map { it.command }
+
+        assertEquals(PcMouseCommand.Move(80, 0), commands[5])
+    }
+
+    @Test
+    fun movementCommandsUseLargeFallbackStep() {
+        val commands = pcMouseControlSpecs(160).map { it.command }
 
-        assertEquals(PcMouseCommand.Move(-130, -130), commands[0])
-        assertEquals(PcMouseCommand.Move(0, -130), commands[1])
-        assertEquals(PcMouseCommand.Move(130, -130), commands[2])
-        assertEquals(PcMouseCommand.Move(-130, 0), commands[3])
-        assertEquals(PcMouseCommand.Move(130, 0), commands[5])
-        assertEquals(PcMouseCommand.Move(-130, 130), commands[6])
-        assertEquals(PcMouseCommand.Move(0, 130), commands[7])
-        assertEquals(PcMouseCommand.Move(130, 130), commands[8])
+        assertEquals(PcMouseCommand.Move(160, 0), commands[5])
     }
 
     @Test
diff --git a/app/src/test/java/com/enaboapps/switchify/screens/pc/PcMouseControlViewModelTest.kt b/app/src/test/java/com/enaboapps/switchify/screens/pc/PcMouseControlViewModelTest.kt
