fix: system bridge autostarter uses correct time for cooldown

Author: sds100

base/src/main/java/io/github/sds100/keymapper/base/promode/SystemBridgeAutoStarter.kt

@@ -128,6 +128,8 @@ class SystemBridgeAutoStarter @Inject constructor(
     private val autoStartFlow: Flow<AutoStartType?> =
         connectionManager.connectionState.flatMapLatest { connectionState ->
 
+            Timber.i("LATEST CONNECTION STATE: $connectionState")
+
             // Do not autostart if it is connected or it was killed from the user
             if (connectionState !is SystemBridgeConnectionState.Disconnected ||
                 connectionState.isStoppedByUser ||
@@ -137,7 +139,7 @@ class SystemBridgeAutoStarter @Inject constructor(
                 !isAutoStartEnabled()
             ) {
                 flowOf(null)
-            } else if (diedAfterAutostart(connectionState.time)) {
+            } else if (isWithinAutoStartCooldown()) {
                 // Do not autostart if the system bridge was killed shortly after.
                 // This prevents infinite loops happening.
                 Timber.w(
@@ -293,9 +295,10 @@ class SystemBridgeAutoStarter @Inject constructor(
      * Whether the system bridge died less than 5 minutes after the previous time it was
      * auto started.
      */
-    private suspend fun diedAfterAutostart(disconnectionTime: Long): Boolean {
+    private suspend fun isWithinAutoStartCooldown(): Boolean {
         val lastAutoStartTime = preferences.get(Keys.systemBridgeLastAutoStartTime).first()
-        return lastAutoStartTime != null && disconnectionTime - lastAutoStartTime < (5 * 60_000)
+        return lastAutoStartTime != null &&
+            clock.elapsedRealtime() - lastAutoStartTime < (5 * 60_000)
     }
 
     private suspend fun isAutoStartEnabled(): Boolean {

base/src/test/java/io/github/sds100/keymapper/base/promode/SystemBridgeAutoStarterTest.kt

@@ -62,17 +62,27 @@ class SystemBridgeAutoStarterTest {
     private lateinit var mockResourceProvider: ResourceProvider
     private lateinit var testBuildConfig: TestBuildConfigProvider
 
-    private val isRootGrantedFlow = MutableStateFlow(false)
-    private val shizukuIsStartedFlow = MutableStateFlow(false)
-    private val connectionStateFlow = MutableStateFlow<SystemBridgeConnectionState>(
-        SystemBridgeConnectionState.Disconnected(time = 0, isStoppedByUser = false),
-    )
-    private val isWifiConnectedFlow = MutableStateFlow(false)
-    private val writeSecureSettingsGrantedFlow = MutableStateFlow(false)
-    private val shizukuPermissionGrantedFlow = MutableStateFlow(false)
+    private lateinit var isRootGrantedFlow: MutableStateFlow<Boolean>
+    private lateinit var shizukuIsStartedFlow: MutableStateFlow<Boolean>
+    private lateinit var connectionStateFlow: MutableStateFlow<SystemBridgeConnectionState>
+    private lateinit var isWifiConnectedFlow: MutableStateFlow<Boolean>
+    private lateinit var writeSecureSettingsGrantedFlow: MutableStateFlow<Boolean>
+    private lateinit var shizukuPermissionGrantedFlow: MutableStateFlow<Boolean>
 
     @Before
     fun init() {
+        isRootGrantedFlow = MutableStateFlow(false)
+        shizukuIsStartedFlow = MutableStateFlow(false)
+        connectionStateFlow = MutableStateFlow(
+            SystemBridgeConnectionState.Disconnected(
+                time = testCoroutineScope.testScheduler.currentTime,
+                isStoppedByUser = false,
+            ),
+        )
+        isWifiConnectedFlow = MutableStateFlow(false)
+        writeSecureSettingsGrantedFlow = MutableStateFlow(false)
+        shizukuPermissionGrantedFlow = MutableStateFlow(false)
+
         mockSuAdapter = mock {
             on { isRootGranted } doReturn isRootGrantedFlow
         }
@@ -521,15 +531,14 @@ class SystemBridgeAutoStarterTest {
     }
 
     @Test
-    fun `show killed and not restarting notification if system bridge dies less than 30 seconds after auto starting`() =
+    fun `show killed and not restarting notification if want to autostart again within the cooldown`() =
         runTest(testDispatcher) {
             fakePreferences.set(Keys.isSystemBridgeKeepAliveEnabled, true)
             fakePreferences.set(Keys.isSystemBridgeUsed, true)
 
             whenever(
                 mockResourceProvider.getString(R.string.system_bridge_died_notification_title),
             ).thenReturn("died")
-
             whenever(mockSetupController.isAdbPaired()).thenReturn(true)
             isWifiConnectedFlow.value = true
             writeSecureSettingsGrantedFlow.value = true
@@ -542,10 +551,11 @@ class SystemBridgeAutoStarterTest {
                 verify(mockNotificationAdapter).showNotification(any())
                 connectionStateFlow.value = SystemBridgeConnectionState.Connected(time = 10000)
 
-                // Set the state as connected within the timeout
+                // Set the state as disconnected within the timeout
                 connectionStateFlow.value =
                     SystemBridgeConnectionState.Disconnected(time = 11000, isStoppedByUser = false)
                 advanceUntilIdle()
+
                 // Show notification
                 val argument = argumentCaptor<NotificationModel>()
                 verify(mockNotificationAdapter).showNotification(argument.capture())

sysbridge/src/main/java/io/github/sds100/keymapper/sysbridge/service/SystemBridge.kt

@@ -436,7 +436,7 @@ class SystemBridge : ISystemBridge.Stub() {
         return inputManager.injectInputEvent(event, mode)
     }
 
-    override fun getEvdevInputDevices(): Array<out EvdevDeviceInfo?>? {
+    override fun getEvdevInputDevices(): Array<out EvdevDeviceInfo?> {
         return getEvdevDevicesNative()
     }
 
@@ -757,11 +757,14 @@ class SystemBridge : ISystemBridge.Stub() {
             tetheringConnector.registerTetheringEventCallback(callback, processPackageName)
 
             // Wait for callback with timeout using Handler
-            mainHandler.postDelayed({
-                synchronized(lock) {
-                    lock.notify()
-                }
-            }, timeoutMillis)
+            mainHandler.postDelayed(
+                {
+                    synchronized(lock) {
+                        lock.notify()
+                    }
+                },
+                timeoutMillis,
+            )
 
             synchronized(lock) {
                 lock.wait(timeoutMillis)