Abstract the WebView request interception into a separate class, so it's more clear

Author: jayohms

turbo/src/main/kotlin/dev/hotwire/turbo/http/TurboWebViewRequestInterceptor.kt

@@ -0,0 +1,60 @@
+package dev.hotwire.turbo.http
+
+import android.webkit.WebResourceRequest
+import android.webkit.WebResourceResponse
+import dev.hotwire.turbo.session.TurboSession
+import dev.hotwire.turbo.util.logEvent
+
+internal class TurboWebViewRequestInterceptor(val session: TurboSession) {
+    private val offlineRequestHandler get() = session.offlineRequestHandler
+    private val httpRepository get() = session.httpRepository
+    private val currentVisit get() = session.currentVisit
+
+    fun interceptRequest(request: WebResourceRequest): WebResourceResponse? {
+        val requestHandler = offlineRequestHandler ?: return null
+
+        if (!shouldInterceptRequest(request)) {
+            return null
+        }
+
+        val url = request.url.toString()
+        val isCurrentVisitRequest = url == currentVisit?.location
+        val result = httpRepository.fetch(requestHandler, request)
+
+        return if (isCurrentVisitRequest) {
+            logCurrentVisitResult(url, result)
+            currentVisit?.completedOffline = result.offline
+
+            // If the request resulted in a redirect, don't return the response. This
+            // lets the WebView handle the request/response and Turbo can see the redirect,
+            // so a redirect "replace" visit can be proposed.
+            when (result.redirectToLocation) {
+                null -> result.response
+                else -> null
+            }
+        } else {
+            result.response
+        }
+    }
+
+    private fun shouldInterceptRequest(request: WebResourceRequest): Boolean {
+        return request.method.equals("GET", ignoreCase = true) &&
+            request.url.scheme?.startsWith("HTTP", ignoreCase = true) == true
+    }
+
+    private fun logCurrentVisitResult(url: String, result: TurboHttpRepository.Result) {
+        logEvent(
+            "location" to url,
+            "redirectToLocation" to result.redirectToLocation.toString(),
+            "statusCode" to (result.response?.statusCode ?: "<none>"),
+            "completedOffline" to result.offline
+        )
+    }
+
+    private fun logEvent(vararg params: Pair<String, Any>) {
+        val attributes = params.toMutableList().apply {
+            add(0, "session" to session.sessionName)
+        }
+        logEvent("interceptRequest", attributes)
+    }
+}

turbo/src/main/kotlin/dev/hotwire/turbo/session/TurboSession.kt

@@ -17,10 +17,7 @@ import androidx.webkit.WebViewFeature.*
 import dev.hotwire.turbo.config.TurboPathConfiguration
 import dev.hotwire.turbo.config.screenshotsEnabled
 import dev.hotwire.turbo.delegates.TurboFileChooserDelegate
-import dev.hotwire.turbo.http.TurboHttpClient
-import dev.hotwire.turbo.http.TurboHttpRepository
-import dev.hotwire.turbo.http.TurboOfflineRequestHandler
-import dev.hotwire.turbo.http.TurboPreCacheRequest
+import dev.hotwire.turbo.http.*
 import dev.hotwire.turbo.nav.TurboNavDestination
 import dev.hotwire.turbo.util.*
 import dev.hotwire.turbo.views.TurboWebView
@@ -54,6 +51,7 @@ class TurboSession internal constructor(
     internal var restorationIdentifiers = SparseArray<String>()
     internal val context: Context = activity.applicationContext
     internal val httpRepository = TurboHttpRepository(activity.lifecycleScope)
+    internal val requestInterceptor = TurboWebViewRequestInterceptor(this)
     internal val fileChooserDelegate = TurboFileChooserDelegate(this)
 
     // User accessible
@@ -648,37 +646,7 @@ class TurboSession internal constructor(
         }
 
         override fun shouldInterceptRequest(view: WebView, request: WebResourceRequest): WebResourceResponse? {
-            val requestHandler = offlineRequestHandler ?: return null
-
-            if (!request.method.equals("GET", ignoreCase = true) ||
-                request.url.scheme?.startsWith("HTTP", ignoreCase = true) != true
-            ) {
-                return null
-            }
-
-            val url = request.url.toString()
-            val isCurrentVisitRequest = url == currentVisit?.location
-            val result = httpRepository.fetch(requestHandler, request)
-
-            return if (isCurrentVisitRequest && result.redirectToLocation != null) {
-                // Let Turbo see the redirect, so a redirect "replace" visit can be proposed
-                logEvent("shouldInterceptRequest",
-                    "location" to url,
-                    "redirectToLocation" to result.redirectToLocation,
-                    "statusCode" to (result.response?.statusCode ?: "<none>")
-                )
-                null
-            } else if (isCurrentVisitRequest) {
-                logEvent("shouldInterceptRequest",
-                    "location" to url,
-                    "statusCode" to (result.response?.statusCode ?: "<none>"),
-                    "completedOffline" to result.offline
-                )
-                currentVisit?.completedOffline = result.offline
-                result.response
-            } else {
-                result.response
-            }
+            return requestInterceptor.interceptRequest(request)
         }
 
         override fun onReceivedError(view: WebView, request: WebResourceRequest, error: WebResourceErrorCompat) {