Add error screen no connection on Automotive

app/src/main/kotlin/io/homeassistant/companion/android/vehicle/ConnectionAvailabilityMonitor.kt

@@ -0,0 +1,88 @@
+package io.homeassistant.companion.android.vehicle
+
+import dagger.Binds
+import dagger.Module
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import io.homeassistant.companion.android.common.data.servers.ServerManager
+import javax.inject.Inject
+import javax.inject.Singleton
+import kotlin.coroutines.cancellation.CancellationException
+import kotlin.time.Duration
+import kotlin.time.Duration.Companion.seconds
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.currentCoroutineContext
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.transformLatest
+import kotlinx.coroutines.isActive
+import timber.log.Timber
+
+sealed interface ConnectionAvailability {
+    data object Available : ConnectionAvailability
+    data object Unavailable : ConnectionAvailability
+}
+
+interface ConnectionAvailabilityMonitor {
+    fun observeAvailability(): Flow<ConnectionAvailability>
+}
+
+internal val GRACE_PERIOD: Duration = 10.seconds
+
+internal val HEALTHY_POLL_INTERVAL: Duration = 15.seconds
+
+internal val DEGRADED_POLL_INTERVAL: Duration = 1.seconds
+
+@Singleton
+internal class ConnectionAvailabilityMonitorImpl @Inject constructor(private val serverManager: ServerManager) :
+    ConnectionAvailabilityMonitor {
+
+    @OptIn(ExperimentalCoroutinesApi::class)
+    override fun observeAvailability(): Flow<ConnectionAvailability> {
+        return haReachableFlow()
+            .transformLatest { reachable ->
+                if (reachable) {
+                    emit(ConnectionAvailability.Available)
+                } else {
+                    delay(GRACE_PERIOD)
+                    emit(ConnectionAvailability.Unavailable)
+                }
+            }
+            .distinctUntilChanged()
+    }
+
+    private fun haReachableFlow(): Flow<Boolean> = flow {
+        while (currentCoroutineContext().isActive) {
+            val reachable = isHaReachable()
+            emit(reachable)
+            delay(if (reachable) HEALTHY_POLL_INTERVAL else DEGRADED_POLL_INTERVAL)
+        }
+    }.distinctUntilChanged()
+
+    private suspend fun isHaReachable(): Boolean {
+        return try {
+            if (!serverManager.isRegistered()) {
+                true
+            } else {
+                serverManager.webSocketRepository().sendPing()
+            }
+        } catch (e: CancellationException) {
+            throw e
+        } catch (e: Exception) {
+            Timber.w(e, "Failed to ping WebSocket")
+            false
+        }
+    }
+}
+
+@Module
+@InstallIn(SingletonComponent::class)
+internal abstract class ConnectionAvailabilityMonitorModule {
+    @Binds
+    @Singleton
+    abstract fun bindConnectionAvailabilityMonitor(
+        impl: ConnectionAvailabilityMonitorImpl,
+    ): ConnectionAvailabilityMonitor
+}

app/src/main/kotlin/io/homeassistant/companion/android/vehicle/HaCarAppService.kt

@@ -45,6 +45,9 @@ class HaCarAppService : CarAppService() {
     @Inject
     lateinit var prefsRepository: PrefsRepository
 
+    @Inject
+    lateinit var connectionAvailabilityMonitor: ConnectionAvailabilityMonitor
+
     private val serverId = MutableStateFlow(0)
     private val allEntities = MutableStateFlow<Map<String, Entity>>(emptyMap())
     private var allEntitiesJob: Job? = null
@@ -67,6 +70,9 @@ class HaCarAppService : CarAppService() {
                         loadEntities(this, it.id)
                     }
                 }
+                lifecycleScope.launch {
+                    observeConnectionAvailability()
+                }
             }
 
             val serverIdFlow = serverId.asStateFlow()
@@ -123,6 +129,21 @@ class HaCarAppService : CarAppService() {
                     )
                 }
             }
+
+            private suspend fun observeConnectionAvailability() {
+                connectionAvailabilityMonitor.observeAvailability().collect { state ->
+                    val screenManager = carContext.getCarService(ScreenManager::class.java)
+                    val topIsNoConnection = screenManager.top is NoConnectionScreen
+                    when (state) {
+                        ConnectionAvailability.Unavailable -> if (!topIsNoConnection) {
+                            screenManager.push(NoConnectionScreen(carContext))
+                        }
+                        ConnectionAvailability.Available -> if (topIsNoConnection) {
+                            screenManager.pop()
+                        }
+                    }
+                }
+            }
         }
     }
 

app/src/main/kotlin/io/homeassistant/companion/android/vehicle/NoConnectionScreen.kt

@@ -0,0 +1,38 @@
+package io.homeassistant.companion.android.vehicle
+
+import androidx.car.app.CarContext
+import androidx.car.app.Screen
+import androidx.car.app.model.Action
+import androidx.car.app.model.CarColor
+import androidx.car.app.model.CarIcon
+import androidx.car.app.model.MessageTemplate
+import androidx.car.app.model.Template
+import com.mikepenz.iconics.IconicsDrawable
+import com.mikepenz.iconics.typeface.library.community.material.CommunityMaterial
+import com.mikepenz.iconics.utils.sizeDp
+import com.mikepenz.iconics.utils.toAndroidIconCompat
+import io.homeassistant.companion.android.common.R
+import io.homeassistant.companion.android.util.vehicle.getHeaderBuilder
+
+class NoConnectionScreen(context: CarContext) : Screen(context) {
+
+    override fun onGetTemplate(): Template {
+        val icon = CarIcon.Builder(
+            IconicsDrawable(carContext, CommunityMaterial.Icon3.cmd_wifi_off).apply {
+                sizeDp = 64
+            }.toAndroidIconCompat(),
+        )
+            .setTint(CarColor.DEFAULT)
+            .build()
+
+        return MessageTemplate.Builder(carContext.getString(R.string.error_connection_failed_no_network))
+            .setHeader(
+                carContext.getHeaderBuilder(
+                    title = R.string.aa_no_connection_title,
+                    action = Action.APP_ICON,
+                ).build(),
+            )
+            .setIcon(icon)
+            .build()
+    }
+}

app/src/test/kotlin/io/homeassistant/companion/android/vehicle/ConnectionAvailabilityMonitorTest.kt

@@ -0,0 +1,111 @@
+package io.homeassistant.companion.android.vehicle
+
+import app.cash.turbine.test
+import io.homeassistant.companion.android.common.data.servers.ServerManager
+import io.homeassistant.companion.android.common.data.websocket.WebSocketRepository
+import io.homeassistant.companion.android.testing.unit.ConsoleLogExtension
+import io.homeassistant.companion.android.testing.unit.MainDispatcherJUnit5Extension
+import io.mockk.coEvery
+import io.mockk.mockk
+import kotlin.time.Duration.Companion.seconds
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.advanceTimeBy
+import kotlinx.coroutines.test.runTest
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.extension.ExtendWith
+
+@OptIn(ExperimentalCoroutinesApi::class)
+@ExtendWith(MainDispatcherJUnit5Extension::class, ConsoleLogExtension::class)
+class ConnectionAvailabilityMonitorTest {
+
+    private val serverManager: ServerManager = mockk(relaxed = true)
+
+    private fun createMonitor(): ConnectionAvailabilityMonitor = ConnectionAvailabilityMonitorImpl(serverManager)
+
+    private fun stubPings(vararg results: Boolean) {
+        val webSocketRepository = mockk<WebSocketRepository>()
+        coEvery { webSocketRepository.sendPing() } returnsMany results.toList()
+        coEvery { serverManager.webSocketRepository() } returns webSocketRepository
+    }
+
+    @Test
+    fun `Given no server registered when observing then emits Available`() = runTest {
+        coEvery { serverManager.isRegistered() } returns false
+
+        createMonitor().observeAvailability().test {
+            assertEquals(ConnectionAvailability.Available, awaitItem())
+            cancelAndConsumeRemainingEvents()
+        }
+    }
+
+    @Test
+    fun `Given server registered and ping succeeds when observing then emits Available`() = runTest {
+        coEvery { serverManager.isRegistered() } returns true
+        stubPings(true)
+
+        createMonitor().observeAvailability().test {
+            assertEquals(ConnectionAvailability.Available, awaitItem())
+            cancelAndConsumeRemainingEvents()
+        }
+    }
+
+    @Test
+    fun `Given server registered and ping fails when grace period elapses then emits Unavailable`() = runTest {
+        coEvery { serverManager.isRegistered() } returns true
+        stubPings(false)
+
+        createMonitor().observeAvailability().test {
+            advanceTimeBy(GRACE_PERIOD - 1.seconds)
+            expectNoEvents()
+            advanceTimeBy(2.seconds)
+            assertEquals(ConnectionAvailability.Unavailable, awaitItem())
+            cancelAndConsumeRemainingEvents()
+        }
+    }
+
+    @Test
+    fun `Given ping recovers during grace period when polling then emits Available without Unavailable`() = runTest {
+        coEvery { serverManager.isRegistered() } returns true
+        stubPings(false, true)
+
+        createMonitor().observeAvailability().test {
+            advanceTimeBy(DEGRADED_POLL_INTERVAL + 1.seconds)
+            assertEquals(ConnectionAvailability.Available, awaitItem())
+            advanceTimeBy(GRACE_PERIOD)
+            expectNoEvents()
+            cancelAndConsumeRemainingEvents()
+        }
+    }
+
+    @Test
+    fun `Given ping goes from success to failure when grace elapses then emits Unavailable`() = runTest {
+        coEvery { serverManager.isRegistered() } returns true
+        stubPings(true, false, false)
+
+        createMonitor().observeAvailability().test {
+            assertEquals(ConnectionAvailability.Available, awaitItem())
+            advanceTimeBy(HEALTHY_POLL_INTERVAL + GRACE_PERIOD + 1.seconds)
+            assertEquals(ConnectionAvailability.Unavailable, awaitItem())
+            cancelAndConsumeRemainingEvents()
+        }
+    }
+
+    @Test
+    fun `Given monitor is Unavailable when ping recovers then emits Available`() = runTest {
+        coEvery { serverManager.isRegistered() } returns true
+        val webSocketRepository = mockk<WebSocketRepository>()
+        coEvery { webSocketRepository.sendPing() } returns false
+        coEvery { serverManager.webSocketRepository() } returns webSocketRepository
+
+        createMonitor().observeAvailability().test {
+            advanceTimeBy(GRACE_PERIOD + 1.seconds)
+            assertEquals(ConnectionAvailability.Unavailable, awaitItem())
+
+            coEvery { webSocketRepository.sendPing() } returns true
+            advanceTimeBy(DEGRADED_POLL_INTERVAL + 1.seconds)
+            assertEquals(ConnectionAvailability.Available, awaitItem())
+            cancelAndConsumeRemainingEvents()
+        }
+    }
+}

common/src/main/res/values/strings.xml

@@ -3,6 +3,7 @@
     <string name="aa_launch_native">Native mode</string>
     <string name="aa_driving_optimized_change">Use Home Assistant in drive mode?</string>
     <string name="aa_navigation">Navigation</string>
+    <string name="aa_no_connection_title">No connection</string>
     <string name="aa_no_entities_with_locations">No entities with locations found</string>
     <string name="aa_change_server">Change server</string>
     <string name="account">Account</string>