Refactor WebViewActivity path handling

app/src/main/kotlin/io/homeassistant/companion/android/util/compose/webview/WebViewBackNavigation.kt

@@ -0,0 +1,79 @@
+package io.homeassistant.companion.android.util.compose.webview
+
+import android.net.Uri
+import android.webkit.WebView
+import androidx.annotation.VisibleForTesting
+import androidx.core.net.toUri
+import io.homeassistant.companion.android.util.hasNonRootPath
+import io.homeassistant.companion.android.util.hasSameOrigin
+
+/**
+ * Convenience overload that extracts the previous URL from the [WebView]'s
+ * back/forward list and delegates to the pure [resolveBackAction] function.
+ */
+fun resolveBackAction(webView: WebView, loadedUrl: Uri?): BackAction {
+    val previousUrl = if (webView.canGoBack()) {
+        val backForwardList = webView.copyBackForwardList()
+        backForwardList.currentIndex
+            .takeIf { it > 0 }
+            ?.let { backForwardList.getItemAtIndex(it - 1).url }
+            ?.toUri()
+    } else {
+        null
+    }
+    return resolveBackAction(previousUrl, loadedUrl)
+}
+
+/**
+ * Determines the appropriate back action based on the previous and current URL.
+ *
+ * The resolution logic:
+ * 1. If [previousUrl] is a same-origin HTTP entry relative to [loadedUrl],
+ *    returns [BackAction.GoBack] so the user can navigate back normally.
+ * 2. If there is no valid previous URL and the current URL has a non-root path,
+ *    returns [BackAction.NavigateToRoot] so the user is taken to the home page first.
+ * 3. Otherwise returns [BackAction.None] — the caller decides what to do
+ *    (e.g. exit the activity or pop the navigation stack).
+ *
+ * @param previousUrl the URL of the previous entry in the WebView's back stack,
+ *        or `null` if the history is empty or the WebView cannot go back
+ * @param loadedUrl the current URL shown in the WebView (as tracked by the caller,
+ *        not necessarily [WebView.getUrl] which can be `about:blank` during loads)
+ * @return the [BackAction] that the caller should execute
+ */
+@VisibleForTesting
+internal fun resolveBackAction(previousUrl: Uri?, loadedUrl: Uri?): BackAction {
+    if (previousUrl != null &&
+        loadedUrl != null &&
+        previousUrl.scheme?.startsWith("http") == true &&
+        previousUrl.hasSameOrigin(loadedUrl)
+    ) {
+        return BackAction.GoBack
+    }
+
+    if (loadedUrl != null && loadedUrl.hasNonRootPath()) {
+        val rootUrl = loadedUrl.buildUpon()
+            .path("/")
+            .clearQuery()
+            .appendQueryParameter("external_auth", "1")
+            .fragment(null)
+            .build()
+        return BackAction.NavigateToRoot(rootUrl)
+    }
+
+    return BackAction.None
+}
+
+/**
+ * Represents the action to take when the user presses back in a WebView.
+ */
+sealed interface BackAction {
+    /** Navigate back in the WebView history. */
+    data object GoBack : BackAction
+
+    /** Clear history and navigate to the root URL of the current server. */
+    data class NavigateToRoot(val rootUrl: Uri) : BackAction
+
+    /** No more back navigation possible — the caller decides what to do. */
+    data object None : BackAction
+}

app/src/main/kotlin/io/homeassistant/companion/android/webview/WebView.kt

@@ -35,6 +35,14 @@ interface WebView {
      */
     fun loadUrl(url: Uri, keepHistory: Boolean, openInApp: Boolean, serverHandleInsets: Boolean)
 
+    /**
+     * Returns the relative part (path, query parameters, fragment) of the currently loaded
+     * WebView URL, or `null` if the URL has no meaningful path (empty or root `/`).
+     *
+     * The `external_auth` query parameter is stripped since the presenter re-adds it on every load.
+     */
+    fun getCurrentWebViewRelativeUrl(): String?
+
     fun setStatusBarAndBackgroundColor(statusBarColor: Int, backgroundColor: Int)
 
     fun setExternalAuth(script: String)

app/src/main/kotlin/io/homeassistant/companion/android/webview/WebViewActivity.kt

@@ -137,11 +137,14 @@ import io.homeassistant.companion.android.util.LifecycleHandler
 import io.homeassistant.companion.android.util.OnSwipeListener
 import io.homeassistant.companion.android.util.TLSWebViewClient
 import io.homeassistant.companion.android.util.applyInsets
+import io.homeassistant.companion.android.util.compose.webview.BackAction
 import io.homeassistant.companion.android.util.compose.webview.BLANK_URL
+import io.homeassistant.companion.android.util.compose.webview.resolveBackAction
 import io.homeassistant.companion.android.util.hasNonRootPath
 import io.homeassistant.companion.android.util.hasSameOrigin
 import io.homeassistant.companion.android.util.isStarted
 import io.homeassistant.companion.android.util.sensitive
+import io.homeassistant.companion.android.util.toRelativeUrl
 import io.homeassistant.companion.android.websocket.WebsocketManager
 import io.homeassistant.companion.android.webview.WebView.ErrorType
 import io.homeassistant.companion.android.webview.addto.EntityAddToHandler
@@ -455,7 +458,25 @@ class WebViewActivity :
 
         val onBackPressed = object : OnBackPressedCallback(webView.canGoBack()) {
             override fun handleOnBackPressed() {
-                if (webView.canGoBack()) webView.goBack()
+                when (val action = resolveBackAction(webView, loadedUrl)) {
+                    BackAction.GoBack -> webView.goBack()
+                    is BackAction.NavigateToRoot -> {
+                        clearHistory = true
+                        loadedUrl = action.rootUrl
+                        webView.loadUrl(action.rootUrl.toString())
+                    }
+                    BackAction.None -> {
+                        // Already on root — let the system handle back (exit app).
+                        // We must temporarily disable this callback so that the
+                        // dispatcher invokes the next handler in the chain (the
+                        // default Activity handler which finishes the activity).
+                        // Re-enabling afterwards keeps the callback functional in
+                        // case the activity is not destroyed (e.g. multi-window).
+                        isEnabled = false
+                        onBackPressedDispatcher.onBackPressed()
+                        isEnabled = true
+                    }
+                }
             }
         }
 
@@ -646,7 +667,12 @@ class WebViewActivity :
 
                 override fun doUpdateVisitedHistory(view: WebView?, url: String?, isReload: Boolean) {
                     super.doUpdateVisitedHistory(view, url, isReload)
-                    onBackPressed.isEnabled = canGoBack()
+                    // Enable the callback when there's browser history OR when the
+                    // current URL has a non-root path, so pressing back navigates to
+                    // root before exiting. This keeps predictive back animations working
+                    // correctly on Android 14+.
+                    onBackPressed.isEnabled = canGoBack() ||
+                        url?.toUri()?.hasNonRootPath() == true
                     presenter.stopScanningForImprov(false)
                 }
             }
@@ -1559,17 +1585,21 @@ class WebViewActivity :
                     showSystemUI()
                 }
 
-                var path = intent.getStringExtra(EXTRA_PATH)
-                if (path?.startsWith("entityId:") == true) {
+                val intentPath = intent.getStringExtra(EXTRA_PATH)
+                // Let the presenter handle falling back to the current WebView path
+                // when no explicit navigation path is set. See https://github.com/home-assistant/android/issues/4983
+                var path: String? = intentPath
+                if (intentPath?.startsWith("entityId:") == true) {
                     // Get the entity ID from a string formatted "entityId:domain.entity"
                     // https://github.com/home-assistant/core/blob/dev/homeassistant/core.py#L159
                     val pattern = "(?<=^entityId:)((?!.+__)(?!_)[\\da-z_]+(?<!_)\\.(?!_)[\\da-z_]+(?<!_)$)".toRegex()
-                    val entity = pattern.find(path)?.value ?: ""
+                    val entity = pattern.find(intentPath)?.value ?: ""
                     if (
                         entity.isNotBlank() &&
                         serverManager.getServer(presenter.getActiveServer())?.version?.isAtLeast(2025, 6, 0) == true
                     ) {
                         path = "/?more-info-entity-id=$entity"
+                        moreInfoEntity = ""
                     } else {
                         moreInfoEntity = entity
                     }
@@ -1580,6 +1610,10 @@ class WebViewActivity :
         }
     }
 
+    override fun getCurrentWebViewRelativeUrl(): String? {
+        return webView.url?.toUri()?.toRelativeUrl(excludeParams = setOf("external_auth"))
+    }
+
     override suspend fun unlockAppIfNeeded() {
         appLocked.value = presenter.isAppLocked()
         if (appLocked.value) {

app/src/main/kotlin/io/homeassistant/companion/android/webview/WebViewPresenterImpl.kt

@@ -129,20 +129,39 @@ class WebViewPresenterImpl @Inject constructor(
         isNewServer: Boolean,
     ) {
         var pathConsumed = false
+        var lastBaseUrl: URL? = null
 
         if (isInternalOverride != null) {
             Timber.d("Using isInternalOverride to get URL")
         }
 
         serverManager.connectionStateProvider(serverId).urlFlow(isInternalOverride).collect { urlState ->
-            val shouldConsumePath = !pathConsumed && path != null
-            if (shouldConsumePath) pathConsumed = true
+            val currentBaseUrl = (urlState as? UrlState.HasUrl)?.url
+            val baseUrlChanged = lastBaseUrl != null && currentBaseUrl != null && lastBaseUrl != currentBaseUrl
+            if (currentBaseUrl != null) lastBaseUrl = currentBaseUrl
+
+            val effectiveRelativeUrl = if (!pathConsumed && path != null) {
+                pathConsumed = true
+                path
+            } else if (baseUrlChanged) {
+                // On internal/external URL switches, preserve the full relative URL
+                // (path + query params + fragment) so the user stays on the exact same
+                // page, including filtered views like history with date ranges.
+                // Only do this for connection type changes on the same server, not
+                // for server switches where the path may not exist and would leak
+                // information about the previous server.
+                withContext(Dispatchers.Main) { view.getCurrentWebViewRelativeUrl() }
+            } else {
+                null
+            }
 
             handleUrlState(
                 urlState = urlState,
-                path = path,
-                shouldConsumePath = shouldConsumePath,
-                isNewServer = isNewServer,
+                path = effectiveRelativeUrl,
+                shouldConsumePath = effectiveRelativeUrl != null,
+                // Clear history when the base URL changes (e.g. internal <-> external)
+                // because old URLs in the back stack would be unreachable on the new network.
+                keepHistory = !(isNewServer || baseUrlChanged),
             )
         }
     }
@@ -179,13 +198,13 @@ class WebViewPresenterImpl @Inject constructor(
         urlState: UrlState,
         path: String?,
         shouldConsumePath: Boolean,
-        isNewServer: Boolean,
+        keepHistory: Boolean,
     ) {
         when (urlState) {
             is UrlState.HasUrl -> loadUrl(
                 baseUrl = urlState.url,
                 path = if (shouldConsumePath) path else null,
-                isNewServer = isNewServer,
+                keepHistory = keepHistory,
             )
 
             UrlState.InsecureState -> view.showBlockInsecure(serverId = serverId)
@@ -200,9 +219,10 @@ class WebViewPresenterImpl @Inject constructor(
      *
      * @param baseUrl the base server URL
      * @param path optional path to append (ignored if starts with "entityId:")
-     * @param isNewServer whether this is a new server (affects history behavior)
+     * @param keepHistory whether to keep WebView history after loading. False when the
+     *        base URL changes (e.g. server or connection switch) so old entries become unreachable.
      */
-    private suspend fun loadUrl(baseUrl: URL?, path: String?, isNewServer: Boolean) {
+    private suspend fun loadUrl(baseUrl: URL?, path: String?, keepHistory: Boolean) {
         val urlToLoad = if (path != null && !path.startsWith("entityId:")) {
             UrlUtil.handle(baseUrl, path)
         } else {
@@ -225,7 +245,7 @@ class WebViewPresenterImpl @Inject constructor(
                 } else {
                     view.loadUrl(
                         url = urlWithAuth,
-                        keepHistory = !isNewServer,
+                        keepHistory = keepHistory,
                         openInApp = it.baseIsEqual(baseUrl),
                         // We need the frontend to notify us of the mode to use for the status bar https://github.com/home-assistant/frontend/issues/29125
                         serverHandleInsets = false,

app/src/test/kotlin/io/homeassistant/companion/android/util/compose/webview/WebViewBackNavigationTest.kt

@@ -0,0 +1,85 @@
+package io.homeassistant.companion.android.util.compose.webview
+
+import android.net.Uri
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+@RunWith(RobolectricTestRunner::class)
+class WebViewBackNavigationTest {
+
+    @Test
+    fun `given no previous url and root loaded url, when resolving back action, then returns None`() {
+        val loadedUrl = Uri.parse("https://ha.local:8123/?external_auth=1")
+
+        val action = resolveBackAction(previousUrl = null, loadedUrl = loadedUrl)
+
+        assertEquals(BackAction.None, action)
+    }
+
+    @Test
+    fun `given no previous url and null loaded url, when resolving back action, then returns None`() {
+        val action = resolveBackAction(previousUrl = null, loadedUrl = null)
+
+        assertEquals(BackAction.None, action)
+    }
+
+    @Test
+    fun `given no previous url and sub-path loaded url, when resolving back action, then returns NavigateToRoot`() {
+        val loadedUrl = Uri.parse("https://ha.local:8123/history?external_auth=1")
+
+        val action = resolveBackAction(previousUrl = null, loadedUrl = loadedUrl)
+
+        assertTrue(action is BackAction.NavigateToRoot)
+        val rootUrl = (action as BackAction.NavigateToRoot).rootUrl
+        assertEquals("/", rootUrl.path)
+        assertEquals("1", rootUrl.getQueryParameter("external_auth"))
+        assertEquals("ha.local", rootUrl.host)
+    }
+
+    @Test
+    fun `given sub-path loaded url with extra params, when resolving back action, then NavigateToRoot strips query and fragment`() {
+        val loadedUrl = Uri.parse("https://ha.local:8123/history?start_date=2026-01-01&external_auth=1#tab")
+
+        val action = resolveBackAction(previousUrl = null, loadedUrl = loadedUrl)
+
+        assertTrue(action is BackAction.NavigateToRoot)
+        val rootUrl = (action as BackAction.NavigateToRoot).rootUrl
+        assertEquals("/", rootUrl.path)
+        assertEquals("1", rootUrl.getQueryParameter("external_auth"))
+        assertEquals(null, rootUrl.getQueryParameter("start_date"))
+        assertEquals(null, rootUrl.fragment)
+    }
+
+    @Test
+    fun `given same-origin previous url, when resolving back action, then returns GoBack`() {
+        val previousUrl = Uri.parse("https://ha.local:8123/lovelace/0")
+        val loadedUrl = Uri.parse("https://ha.local:8123/history?external_auth=1")
+
+        val action = resolveBackAction(previousUrl = previousUrl, loadedUrl = loadedUrl)
+
+        assertEquals(BackAction.GoBack, action)
+    }
+
+    @Test
+    fun `given cross-origin previous url and sub-path loaded url, when resolving back action, then returns NavigateToRoot`() {
+        val previousUrl = Uri.parse("https://other.server:8123/lovelace/0")
+        val loadedUrl = Uri.parse("https://ha.local:8123/history?external_auth=1")
+
+        val action = resolveBackAction(previousUrl = previousUrl, loadedUrl = loadedUrl)
+
+        assertTrue(action is BackAction.NavigateToRoot)
+    }
+
+    @Test
+    fun `given non-http previous url, when resolving back action, then does not go back`() {
+        val previousUrl = Uri.parse("about:blank")
+        val loadedUrl = Uri.parse("https://ha.local:8123/history?external_auth=1")
+
+        val action = resolveBackAction(previousUrl = previousUrl, loadedUrl = loadedUrl)
+
+        assertTrue(action is BackAction.NavigateToRoot)
+    }
+}

app/src/test/kotlin/io/homeassistant/companion/android/webview/WebViewPresenterImplTest.kt

@@ -90,6 +90,10 @@ private class FakeWebViewContext(
     override fun showConnectionSecurityLevel(serverId: Int) {
         webViewDelegate.showConnectionSecurityLevel(serverId)
     }
+
+    override fun getCurrentWebViewRelativeUrl(): String? {
+        return webViewDelegate.getCurrentWebViewRelativeUrl()
+    }
 }
 
 @OptIn(ExperimentalCoroutinesApi::class)
@@ -123,6 +127,7 @@ class WebViewPresenterImplTest {
     fun setUp() {
         mockkStatic(Uri::class)
         mockUriParse()
+        every { webView.getCurrentWebViewRelativeUrl() } returns null
         fakeContext = FakeWebViewContext(mockk<Context>(), webView)
 
         lifecycleOwner = object : LifecycleOwner {