Merge pull request #2596 from switchifyapp/feature/pc-default-picker-last-connection-2595

Add PC default picker with last connection option

Author: enaboapps

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

@@ -26,6 +26,9 @@ data class PcConnectionUiState(
     val permissionRequired: Boolean = false,
     val discoveryStatus: PcDiscoveryStatus = PcDiscoveryStatus.Empty,
     val discoveryStatusText: String = "Searching for Switchify PC...",
+    val defaultPreference: PcDefaultPcPreference = PcDefaultPcPreference.LastConnection,
+    val lastConnectedDesktopId: String? = null,
+    val defaultPcChoices: List<PcDefaultPcChoice> = emptyList(),
     val pcRows: List<PcConnectionRowState> = emptyList(),
     val discoveredPcs: List<PcRowState> = emptyList(),
     val savedPairings: List<PcSavedPairingRowState> = emptyList(),
@@ -37,6 +40,12 @@ data class PcConnectionUiState(
     val pendingUnpair: PcUnpairConfirmationState? = null
 )
 
+data class PcDefaultPcChoice(
+    val preference: PcDefaultPcPreference,
+    val title: String,
+    val description: String
+)
+
 data class PcRowState(
     val pc: DiscoveredPc,
     val title: String,
@@ -129,11 +138,18 @@ class PcConnectionViewModel(
                 val hasTokenByDesktopId = withContext(backgroundDispatcher) {
                     inputs.pcs.associate { pc -> pc.desktopId to !tokenStore.getToken(pc.desktopId).isNullOrBlank() }
                 }
+                val allPairings = withContext(backgroundDispatcher) {
+                    tokenStore.listPairings()
+                }
                 val savedPairings = withContext(backgroundDispatcher) {
-                    savedPairings(discoveredDesktopIds)
+                    savedPairings(allPairings, discoveredDesktopIds)
+                }
+                val defaultPreference = withContext(backgroundDispatcher) {
+                    tokenStore.getDefaultPcPreference()
                 }
-                val defaultDesktopId = withContext(backgroundDispatcher) {
-                    tokenStore.getDefaultDesktopId()
+                val defaultDesktopId = (defaultPreference as? PcDefaultPcPreference.SpecificPc)?.desktopId
+                val lastConnectedDesktopId = withContext(backgroundDispatcher) {
+                    tokenStore.getLastConnectedDesktopId()
                 }
                 val pcRows = buildPcRows(
                     pcs = inputs.pcs,
@@ -148,6 +164,9 @@ class PcConnectionViewModel(
                     current.copy(
                         discoveryStatus = inputs.status,
                         discoveryStatusText = discoveryStatusText(inputs.status, inputs.pcs.isEmpty()),
+                        defaultPreference = defaultPreference,
+                        lastConnectedDesktopId = lastConnectedDesktopId,
+                        defaultPcChoices = buildDefaultPcChoices(allPairings, inputs.pcs, lastConnectedDesktopId),
                         pcRows = pcRows,
                         discoveredPcs = inputs.pcs.map { pc ->
                             rowState(
@@ -252,17 +271,38 @@ class PcConnectionViewModel(
     }
 
     fun setDefaultPc(desktopId: String, displayName: String) {
-        if (tokenStore.getToken(desktopId).isNullOrBlank()) return
-        tokenStore.setDefaultDesktopId(desktopId)
-        tokenRevision.update { it + 1 }
-        _uiState.update {
-            it.copy(message = "Default PC set to $displayName.")
-        }
+        setDefaultPcPreference(PcDefaultPcPreference.SpecificPc(desktopId), displayName)
     }
 
     fun clearDefaultPc() {
-        tokenStore.clearDefaultDesktopId()
+        setDefaultPcPreference(PcDefaultPcPreference.LastConnection)
+    }
+
+    fun setDefaultPcPreference(preference: PcDefaultPcPreference) {
+        val displayName = (preference as? PcDefaultPcPreference.SpecificPc)?.desktopId?.let { desktopId ->
+            _uiState.value.pcRows.firstOrNull { it.desktopId == desktopId }?.title
+                ?: tokenStore.getServiceName(desktopId)
+                ?: desktopId
+        }
+        setDefaultPcPreference(preference, displayName)
+    }
+
+    private fun setDefaultPcPreference(
+        preference: PcDefaultPcPreference,
+        displayName: String? = null
+    ) {
+        if (preference is PcDefaultPcPreference.SpecificPc && tokenStore.getToken(preference.desktopId).isNullOrBlank()) {
+            return
+        }
+        tokenStore.setDefaultPcPreference(preference)
         tokenRevision.update { it + 1 }
+        _uiState.update {
+            val message = when (preference) {
+                PcDefaultPcPreference.LastConnection -> "Default set to last connection."
+                is PcDefaultPcPreference.SpecificPc -> "Default PC set to ${displayName ?: preference.desktopId}."
+            }
+            it.copy(message = message)
+        }
     }
 
     fun stopPcBluetooth() {
@@ -309,7 +349,7 @@ class PcConnectionViewModel(
         }
         return PcRowState(
             pc = pc,
-            title = pc.displayName,
+            title = pc.controlDeviceName,
             summary = summary,
             actionText = actionText,
             enabled = !connected && !isBusy,
@@ -320,8 +360,11 @@ class PcConnectionViewModel(
         )
     }
 
-    private fun savedPairings(discoveredDesktopIds: Set<String>): List<PcSavedPairingRowState> {
-        return tokenStore.listPairings()
+    private fun savedPairings(
+        pairings: List<PcStoredPairing>,
+        discoveredDesktopIds: Set<String>
+    ): List<PcSavedPairingRowState> {
+        return pairings
             .filterNot { it.desktopId in discoveredDesktopIds }
             .map { pairing ->
                 PcSavedPairingRowState(
@@ -334,6 +377,33 @@ class PcConnectionViewModel(
             }
     }
 
+    private fun buildDefaultPcChoices(
+        pairings: List<PcStoredPairing>,
+        discoveredPcs: List<DiscoveredPc>,
+        lastConnectedDesktopId: String?
+    ): List<PcDefaultPcChoice> {
+        val discoveredNames = discoveredPcs.associate { it.desktopId to it.controlDeviceName }
+        val lastConnectionDisplayName = pairings.firstOrNull {
+            it.desktopId == lastConnectedDesktopId
+        }?.let { pairing -> discoveredNames[pairing.desktopId] ?: pairing.serviceName ?: pairing.desktopId }
+        val lastConnectionDescription = lastConnectionDisplayName?.let {
+            "Currently: $it"
+        } ?: "Switchify will use the most recently connected PC."
+        return listOf(
+            PcDefaultPcChoice(
+                preference = PcDefaultPcPreference.LastConnection,
+                title = "Use last connection",
+                description = lastConnectionDescription
+            )
+        ) + pairings.map { pairing ->
+            PcDefaultPcChoice(
+                preference = PcDefaultPcPreference.SpecificPc(pairing.desktopId),
+                title = discoveredNames[pairing.desktopId] ?: pairing.serviceName ?: pairing.desktopId,
+                description = "Always connect to this PC when it is available."
+            )
+        }
+    }
+
     private fun buildPcRows(
         pcs: List<DiscoveredPc>,
         statuses: Map<String, PcRowStatus>,
@@ -383,7 +453,7 @@ class PcConnectionViewModel(
         }
         return PcConnectionRowState(
             desktopId = pc.desktopId,
-            title = pc.displayName,
+            title = pc.controlDeviceName,
             summary = summary,
             source = PcConnectionRowSource.Discovered,
             status = rowStatus,
@@ -440,7 +510,7 @@ class PcConnectionViewModel(
             desktopId = pc.desktopId,
             status = PcRowStatus.WaitingApproval,
             message = null,
-            approvalCode = PcApprovalCodeState(pc.displayName, verificationCode)
+            approvalCode = PcApprovalCodeState(pc.controlDeviceName, verificationCode)
         )
         when (val pairing = connector.requestApproval(pc, requestNonce)) {
             is PcPairingResult.Paired -> {
@@ -449,11 +519,12 @@ class PcConnectionViewModel(
                     isAuthFailure = { it is PcPingResult.AuthFailed }
                 )) {
                     is PcPingResult.Connected -> {
-                        tokenStore.saveToken(pc.desktopId, pairing.token, ping.endpointId, pc.displayName)
+                        tokenStore.saveToken(pc.desktopId, pairing.token, ping.endpointId, pc.controlDeviceName)
+                        tokenStore.recordSuccessfulConnection(pc.desktopId)
                         tokenRevision.update { it + 1 }
                         PcConnectionStateHolder.setConnected(
                             PcAuthenticatedSession(pc.desktopId, identityRepository.getDeviceId(), ping.endpointId),
-                            pc.displayName
+                            pc.controlDeviceName
                         )
                         setIdle(pc.desktopId, PcRowStatus.Connected, null)
                     }
@@ -480,11 +551,12 @@ class PcConnectionViewModel(
             isAuthFailure = { it is PcPingResult.AuthFailed }
         )) {
             is PcPingResult.Connected -> {
-                tokenStore.saveToken(pc.desktopId, token, result.endpointId, pc.displayName)
+                tokenStore.saveToken(pc.desktopId, token, result.endpointId, pc.controlDeviceName)
+                tokenStore.recordSuccessfulConnection(pc.desktopId)
                 tokenRevision.update { it + 1 }
                 PcConnectionStateHolder.setConnected(
                     PcAuthenticatedSession(pc.desktopId, identityRepository.getDeviceId(), result.endpointId),
-                    pc.displayName
+                    pc.controlDeviceName
                 )
                 setIdle(pc.desktopId, PcRowStatus.Connected, null)
             }

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

@@ -253,12 +253,12 @@ class PcServiceConnectionController(
             deviceId = identityRepository.getDeviceId(),
             requestNonce = requestNonce
         )
-        onWaitingForApproval(PcApprovalCodeState(pc.displayName, verificationCode))
+        onWaitingForApproval(PcApprovalCodeState(pc.controlDeviceName, verificationCode))
         return when (val result = connector.requestApproval(pc, requestNonce)) {
             is PcPairingResult.Paired -> {
-                tokenStore.saveToken(result.desktopId, result.token, result.endpointId, pc.displayName)
+                tokenStore.saveToken(result.desktopId, result.token, result.endpointId, pc.controlDeviceName)
                 val session = PcAuthenticatedSession(result.desktopId, identityRepository.getDeviceId(), result.endpointId)
-                openLiveControlSession(session, pc.displayName, pc.controlDeviceName)
+                openLiveControlSession(session, pc.controlDeviceName, pc.controlDeviceName)
             }
             is PcPairingResult.Failed -> PcServiceConnectResult.Failed(result.reason, result.message)
         }
@@ -274,9 +274,9 @@ class PcServiceConnectionController(
             isAuthFailure = { it is PcPingResult.AuthFailed }
         )) {
             is PcPingResult.Connected -> {
-                tokenStore.saveToken(pc.desktopId, token, result.endpointId, pc.displayName)
+                tokenStore.saveToken(pc.desktopId, token, result.endpointId, pc.controlDeviceName)
                 val session = PcAuthenticatedSession(pc.desktopId, identityRepository.getDeviceId(), result.endpointId)
-                openLiveControlSession(session, pc.displayName, pc.controlDeviceName)
+                openLiveControlSession(session, pc.controlDeviceName, pc.controlDeviceName)
             }
             is PcPingResult.AuthFailed -> {
                 PcConnectionStateHolder.setDisconnected()
@@ -335,6 +335,7 @@ class PcServiceConnectionController(
         liveDisplayName = displayName
         liveControlDeviceName = controlDeviceName
         pointerProfile = connection.pointerProfile
+        tokenStore.recordSuccessfulConnection(session.desktopId)
         observeLiveConnection(connection, session)
         startLiveHeartbeatIfNeeded()
         _state.value = PcServiceConnectionState.Connected(session, displayName, pointerProfile)

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

@@ -10,11 +10,28 @@ interface PcPairingTokenStore {
     fun listPairings(): List<PcStoredPairing>
     fun getLastEndpointId(desktopId: String): String?
     fun getServiceName(desktopId: String): String?
+    fun getDefaultPcPreference(): PcDefaultPcPreference {
+        return getDefaultDesktopId()?.let { PcDefaultPcPreference.SpecificPc(it) }
+            ?: PcDefaultPcPreference.LastConnection
+    }
+    fun setDefaultPcPreference(preference: PcDefaultPcPreference) {
+        when (preference) {
+            PcDefaultPcPreference.LastConnection -> clearDefaultDesktopId()
+            is PcDefaultPcPreference.SpecificPc -> setDefaultDesktopId(preference.desktopId)
+        }
+    }
+    fun getLastConnectedDesktopId(): String? = null
+    fun recordSuccessfulConnection(desktopId: String) = Unit
     fun getDefaultDesktopId(): String?
     fun setDefaultDesktopId(desktopId: String)
     fun clearDefaultDesktopId()
 }
 
+sealed class PcDefaultPcPreference {
+    data object LastConnection : PcDefaultPcPreference()
+    data class SpecificPc(val desktopId: String) : PcDefaultPcPreference()
+}
+
 data class PcStoredPairing(
     val desktopId: String,
     val serviceName: String?,
@@ -55,6 +72,10 @@ class PcTokenStore(context: Context) : PcPairingTokenStore {
             remove(serviceNameKey(desktopId))
             if (preferences.getString(defaultDesktopIdKey, null) == desktopId) {
                 remove(defaultDesktopIdKey)
+                putString(defaultPreferenceModeKey, defaultPreferenceModeLastConnection)
+            }
+            if (preferences.getString(lastConnectedDesktopIdKey, null) == desktopId) {
+                remove(lastConnectedDesktopIdKey)
             }
         }
     }
@@ -80,24 +101,68 @@ class PcTokenStore(context: Context) : PcPairingTokenStore {
         return preferences.getString(serviceNameKey(desktopId), null)?.takeIf { it.isNotBlank() }
     }
 
-    override fun getDefaultDesktopId(): String? {
-        val desktopId = preferences.getString(defaultDesktopIdKey, null)?.takeIf { it.isNotBlank() } ?: return null
+    override fun getDefaultPcPreference(): PcDefaultPcPreference {
+        val mode = preferences.getString(defaultPreferenceModeKey, null)
+        val desktopId = preferences.getString(defaultDesktopIdKey, null)?.takeIf { it.isNotBlank() }
+        if (mode == null) {
+            if (desktopId != null && getToken(desktopId) != null) {
+                return PcDefaultPcPreference.SpecificPc(desktopId)
+            }
+            setDefaultPcPreference(PcDefaultPcPreference.LastConnection)
+            return PcDefaultPcPreference.LastConnection
+        }
+        if (mode == defaultPreferenceModeSpecificPc) {
+            if (desktopId != null && getToken(desktopId) != null) {
+                return PcDefaultPcPreference.SpecificPc(desktopId)
+            }
+            setDefaultPcPreference(PcDefaultPcPreference.LastConnection)
+            return PcDefaultPcPreference.LastConnection
+        }
+        return PcDefaultPcPreference.LastConnection
+    }
+
+    override fun setDefaultPcPreference(preference: PcDefaultPcPreference) {
+        when (preference) {
+            PcDefaultPcPreference.LastConnection -> preferences.edit {
+                putString(defaultPreferenceModeKey, defaultPreferenceModeLastConnection)
+                remove(defaultDesktopIdKey)
+            }
+            is PcDefaultPcPreference.SpecificPc -> {
+                if (getToken(preference.desktopId) == null) return
+                preferences.edit {
+                    putString(defaultPreferenceModeKey, defaultPreferenceModeSpecificPc)
+                    putString(defaultDesktopIdKey, preference.desktopId)
+                }
+            }
+        }
+    }
+
+    override fun getLastConnectedDesktopId(): String? {
+        val desktopId = preferences.getString(lastConnectedDesktopIdKey, null)?.takeIf { it.isNotBlank() } ?: return null
         if (getToken(desktopId) != null) return desktopId
-        clearDefaultDesktopId()
+        preferences.edit {
+            remove(lastConnectedDesktopIdKey)
+        }
         return null
     }
 
-    override fun setDefaultDesktopId(desktopId: String) {
+    override fun recordSuccessfulConnection(desktopId: String) {
         if (getToken(desktopId) == null) return
         preferences.edit {
-            putString(defaultDesktopIdKey, desktopId)
+            putString(lastConnectedDesktopIdKey, desktopId)
         }
     }
 
+    override fun getDefaultDesktopId(): String? {
+        return (getDefaultPcPreference() as? PcDefaultPcPreference.SpecificPc)?.desktopId
+    }
+
+    override fun setDefaultDesktopId(desktopId: String) {
+        setDefaultPcPreference(PcDefaultPcPreference.SpecificPc(desktopId))
+    }
+
     override fun clearDefaultDesktopId() {
-        preferences.edit {
-            remove(defaultDesktopIdKey)
-        }
+        setDefaultPcPreference(PcDefaultPcPreference.LastConnection)
     }
 
     private fun tokenKey(desktopId: String) = "token:$desktopId"
@@ -117,7 +182,11 @@ class PcTokenStore(context: Context) : PcPairingTokenStore {
 
     private companion object {
         const val pairingIdsKey = "paired_desktop_ids"
+        const val defaultPreferenceModeKey = "default_preference_mode"
         const val defaultDesktopIdKey = "default_desktop_id"
+        const val lastConnectedDesktopIdKey = "last_connected_desktop_id"
+        const val defaultPreferenceModeLastConnection = "last_connection"
+        const val defaultPreferenceModeSpecificPc = "specific_pc"
         const val tokenPrefix = "token:"
     }
 }