Refactor WebViewActivity path handling

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

@@ -0,0 +1,76 @@
+package io.homeassistant.companion.android.util.compose.webview
+
+import android.net.Uri
+import android.webkit.WebView
+import androidx.core.net.toUri
+import io.homeassistant.companion.android.util.hasNonRootPath
+import io.homeassistant.companion.android.util.hasSameOrigin
+
+/**
+ * Determines the appropriate back action based on the [WebView]'s back/forward list
+ * and the current loaded URL.
+ *
+ * The resolution logic:
+ * 1. If the previous back-stack entry is a same-origin HTTP URL, returns
+ *    [BackAction.GoBack] so the user can navigate back normally.
+ * 2. If there is a previous back-stack entry that is not same-origin HTTP 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, pop the navigation stack, or let the system
+ *    handle back to show the predictive-back animation).
+ *
+ * @param webView the WebView whose back/forward list is inspected
+ * @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)
+ */
+fun resolveBackAction(webView: WebView, loadedUrl: Uri?): BackAction {
+    val previousUrl = if (webView.canGoBack()) {
+        val backForwardList = webView.copyBackForwardList()
+        val previousIndex = backForwardList.currentIndex - 1
+        if (previousIndex >= 0) {
+            backForwardList.getItemAtIndex(previousIndex).url.toUri()
+        } else {
+            null
+        }
+    } else {
+        null
+    }
+    return resolveBackAction(previousUrl, loadedUrl)
+}
+
+private fun resolveBackAction(previousUrl: Uri?, loadedUrl: Uri?): BackAction {
+    if (previousUrl != null &&
+        loadedUrl != null &&
+        previousUrl.scheme?.startsWith("http") == true &&
+        previousUrl.hasSameOrigin(loadedUrl)
+    ) {
+        return BackAction.GoBack
+    }
+
+    if (previousUrl != null && 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

@@ -138,10 +138,13 @@ 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.BLANK_URL
+import io.homeassistant.companion.android.util.compose.webview.BackAction
+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,14 @@ 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. Without the non-root check,
+                    // pressing back on e.g. /history with empty history would skip
+                    // the NavigateToRoot step and exit the app directly.
+                    // It also keeps predictive back animations working on Android 14+,
+                    // since the system needs to know upfront that we'll handle the gesture.
+                    onBackPressed.isEnabled = canGoBack() ||
+                        url?.toUri()?.hasNonRootPath() == true
                     presenter.stopScanningForImprov(false)
                 }
             }
@@ -1559,12 +1587,15 @@ 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
@@ -1580,6 +1611,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,40 @@ 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
+            // baseUrlChanged is only true from the second emission onwards; the first emission
+            // establishes lastBaseUrl and is therefore not considered a change.
+            val baseUrlChanged = currentBaseUrl != null && lastBaseUrl?.let { it != currentBaseUrl } == true
+            if (currentBaseUrl != null) lastBaseUrl = currentBaseUrl
+
+            val effectiveRelativeUrl = if (!pathConsumed && path != null) {
+                pathConsumed = true
+                path
+            } else if (baseUrlChanged && !isNewServer) {
+                // On internal/external URL switches on the same server, 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.
+                // Skipped for server switches where the path may not exist and would leak
+                // navigation context from 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 +199,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 +220,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 +246,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,