¿Cómo solucionar errores de redirección en WebView en Android e iOS?

opoinstall
2026-11-19
5 min read

webview-safe-fallback-loop-prevention.webp

¿Cómo se solucionan los errores de redirección en WebView en Android e iOS? Identifica si el fallo involucra una navegación HTTPS estándar, un esquema de URL personalizado, una URI intent:// de Android o una solicitud de ventana nueva; luego, inspecciona la navegación a través de Chrome DevTools o Safari Web Inspector y rastrea el delegado nativo correspondiente (shouldOverrideUrlLoading, onCreateWindow, decidePolicyForNavigationAction o createWebViewWith). Verifica la resolución de la aplicación de destino, las listas permitidas de URI, las políticas de marcos e interacción del usuario, y el enrutamiento de respaldo para aislar los errores a nivel de contenedor de los fallos de distribución del sistema operativo.

Se produce un error de redirección en WebView cuando un Chromium WebView integrado en Android o un WKWebView de WebKit en iOS no puede enrutar una solicitud de navegación hacia su destino previsto. Las causas típicas incluyen esquemas de URL personalizados no compatibles, solicitudes target="_blank" no manejadas, declaraciones faltantes de visibilidad de paquetes y redirecciones de respaldo rechazadas o en bucle.

Por qué los contenedores integrados Android WebView y iOS WKWebView descartan redirecciones

Layered WebView redirect architecture reveals native policy and operating system dispatch failures.

Al depurar fallos de redirección, los equipos de ingeniería deben separar el comportamiento del motor de WebView (cómo Chromium o WebKit analiza las URL, los destinos de marcos y los eventos emergentes) de la política de la aplicación host (cómo el WebViewClient, WebChromeClient, WKNavigationDelegate o WKUIDelegate proporcionados por la aplicación evalúan los tipos de interacción del usuario, las listas permitidas y las transferencias a aplicaciones externas). Los navegadores independientes incluyen despachadores de URI integrados y controladores de transferencia de enlaces, mientras que android.webkit.WebView y WKWebView de Apple son componentes de renderizado integrados que esperan respuestas de red estándar http:// o https:// de forma predeterminada.

Cuando una página web activa un esquema personalizado (como myapp://product/42) o un enlace intent:// de Android sin una anulación de delegado activa, el comportamiento predeterminado del contenedor diverge entre plataformas:

  • Android Chromium WebView: Según la especificación de WebViewClient de Android, si no se asigna un WebViewClient personalizado, WebView puede pedir al Administrador de Actividades que resuelva la URL a través de los controladores del sistema disponibles. Cuando sí se asigna un WebViewClient personalizado y shouldOverrideUrlLoading devuelve false para un esquema personalizado no compatible, WebView continúa cargándola dentro de Chromium y renderiza net::ERR_UNKNOWN_URL_SCHEME.
  • iOS WebKit WKWebView: WebKit rechaza internamente los esquemas que no son HTTP y anula la navegación a menos que el WKNavigationDelegate del host intercepte la solicitud y la reenvíe a UIApplication, fallando a menudo de forma silenciosa o generando NSURLErrorUnsupportedURL.

Tenga en cuenta también que la función Promoción de aplicaciones con banners de aplicaciones inteligentes de Apple es una función de soporte de Safari diseñada para la navegación independiente en Safari en lugar de una API de navegación integrada de WKWebView, y debe evaluarse por separado de las redirecciones de esquemas de URL personalizados dentro de la aplicación.

De un vistazo

  • Separar el comportamiento del motor de la política del host: Aísle si una navegación falló dentro del motor web (Chromium/WebKit), dentro de las anulaciones de delegados nativos o en el límite de resolución de paquetes del sistema operativo.
  • Inspeccionar redirecciones en vivo antes de programar: Utilice Chrome DevTools (chrome://inspect) y Safari Web Inspector (isInspectable = true) para capturar cadenas de redirección 3xx, estados de targetFrame e indicadores de gestos.
  • Aplicar validación de URI e intent adecuada para la plataforma: En Android, vincule esquemas personalizados y destinos intent:// 1 a 1 con paquetes verificados mediante IntentSanitizer sin indicadores de tareas proporcionados por la página web; en iOS, valide estructuras de URI personalizadas completas (confiando en Enlaces Universales donde se requiere identidad verificada de aplicación a dominio) y rechace claves de consulta duplicadas en ambas plataformas.
  • Aplicar defensa en profundidad para ventanas emergentes y condiciones de carrera: Confine el estado de sesión de las ventanas emergentes de Android estrictamente al hilo de la interfaz de usuario mientras comprende los límites de devolución de llamada en shouldInterceptRequest y shouldOverrideUrlLoading, y separe las comprobaciones de política pura de los efectos secundarios de despacho externo en WKWebView de iOS utilizando la deduplicación a nivel de acción y los tokens de generación de navegación.

Causas comunes y pasos de verificación para errores de redirección en WebView

Mapeo de errores de cliente observados a mecanismos subyacentes de fallo del contenedor

Utilice la matriz de diagnóstico a continuación para relacionar los síntomas observados en WebView con las causas raíz comunes de la plataforma, los pasos de verificación y las correcciones específicas:

Síntoma o error observado Plataforma de destino Causa raíz común Paso de verificación de diagnóstico Corrección específica
WebView muestra net::ERR_UNKNOWN_URL_SCHEME Android WebView Un WebViewClient personalizado devuelve false o carece de lista permitida de esquemas Inspeccionar request.url en shouldOverrideUrlLoading Interceptar URI en lista blanca y enviar Intent.ACTION_VIEW vinculado 1 a 1 al paquete
Bloqueo silencioso al tocar un enlace de esquema personalizado iOS WKWebView WebKit anula la URI que no es HTTP cuando WKNavigationDelegate devuelve .allow Registrar navigationAction.request.url en decidePolicyForNavigationAction Enrutar esquemas validados mediante UIApplication.shared.open y pasar .cancel
target="_blank" reemplaza la página actual en WebView Android WebView setSupportMultipleWindows(false) trata las nuevas ventanas como cargas de nivel superior Comprobar webView.settings.supportMultipleWindows() Habilitar setSupportMultipleWindows(true) solo si se necesitan contenedores emergentes separados
target="_blank" no hace nada o descarta redirecciones OAuth 302 Android WebView Falta onCreateWindow, o el cliente secundario bloquea saltos isRedirect que carecen de hasGesture() Comprobar registros de onCreateWindow, request.isRedirect y shouldInterceptRequest Adjuntar un WebView emergente alojado en vista con estado de sesión en el hilo de la interfaz de usuario y saltos isRedirect acotados
El enlace con target="_blank" o window.open() no hace nada iOS WKWebView La navegación de ventana nueva establece targetFrame == nil y requiere WKUIDelegate Comprobar navigationAction.targetFrame == nil Detectar targetFrame == nil en decidePolicyForNavigationAction y manejar mediante WKUIDelegate
La aplicación de destino está instalada, pero se abre la página de respaldo Android 11+ (targetSdk >= 30) Faltan declaraciones <queries> que hacen que resolveActivity() o queryIntentActivities() devuelvan resultados incompletos para paquetes invisibles Añadir registro a nivel de aplicación alrededor de resolveActivity() e inspeccionar la salida mediante adb logcat Declarar intents <queries> si se realiza una comprobación previa, o invocar startActivity directamente con captura de ActivityNotFoundException
La redirección del temporizador de JavaScript no abre la aplicación externa iOS / Android La redirección de scripts automatizados carece de una señal de interacción del usuario Comprobar request.hasGesture() (Android) o navigationType (iOS) Vincular las redirecciones a toques directos del usuario y definir una política explícita de gestos del host
El Enlace Universal se carga dentro de WKWebView en lugar de la aplicación de destino iOS WKWebView El contexto de navegación, la relación de dominio o la navegación JS mantienen la carga en WebKit Comprobar navigationType y host en decidePolicyForNavigationAction Llamar a UIApplication.shared.open con .universalLinksOnly: true para hosts externos permitidos

Lista de comprobación rápida de cinco minutos para redirecciones en WebView

  • Paso 1: Comprobar el esquema de protocolo en DevTools: Verifique si la página emitió una URI https://, un esquema personalizado o intent://, y confirme que no fue bloqueada por la Política de Seguridad de Contenido (CSP).
  • Paso 2: Inspeccionar la jerarquía de marcos: Compruebe si el activador se originó dentro de un <iframe> de terceros (!isMainFrame). Las aplicaciones host pueden bloquear intencionalmente lanzamientos de aplicaciones externas iniciados desde iframes de terceros.
  • Paso 3: Distinguir redirecciones de temporizadores: Compruebe si una navegación sin gestos es una redirección de servidor HTTP 3xx autorizada (request.isRedirect en Android) frente a un temporizador de JavaScript no solicitado.
  • Paso 4: Comprobar activadores de nuevas ventanas: Confirme si target="_blank" o window.open() creó una solicitud de ventana nueva (targetFrame == nil en iOS o onCreateWindow en Android).
  • Paso 5: Verificar la resolución de paquetes del sistema operativo: Para aplicaciones dirigidas a la API 30+ en Android 11+, confirme si las llamadas de pre-evaluación resolveActivity() están fallando debido a declaraciones <queries> faltantes.

El siguiente flujo de trabajo de diagnóstico ilustra la ruta de triaje secuencial para aislar los fallos de redirección del contenedor:

[WebView Navigation Failure]
          │
          ▼
[Inspect URL + Network + Console via Chrome DevTools / Safari Web Inspector]
          │
          ▼
[Identify Navigation Source]
          │
          ├── App loadUrl() or HTTP POST
          │       │
          │       └── shouldOverrideUrlLoading is NOT invoked; inspect host-side call path
          │
          ├── target="_blank" or window.open()
          │       │
          │       ├── Android (multiple-windows=false) ──> Replaces current WebView page
          │       ├── Android (multiple-windows=true)  ──> Inspect onCreateWindow + shouldInterceptRequest
          │       └── iOS (targetFrame == nil)         ──> Inspect WKNavigationDelegate + WKUIDelegate
          │
          ├── HTTP / HTTPS Navigation
          │       │
          │       └── Inspect Host + Port Allowlist, 3xx Redirects, Universal Link, or App Link matching
          │
          └── Custom Scheme or Chrome intent://
                  │
                  ├── Evaluate User Interaction + Main Frame policy
                  ├── Verify Full URI Structure (Scheme, Host, Port, Path, No Duplicate Query Keys)
                  ├── Sanitize Intent (Reject Explicit Components, Verify 1-to-1 Package, Zero Webpage Flags)
                  ├── Check Target-App Resolution (<queries> / ActivityNotFoundException)
                  └── Validate Fallback Path + Query Allowlist + Monotonic Chain Guard (elapsedRealtime)

Cómo inspeccionar eventos de navegación en WebView utilizando herramientas de depuración remota

Habilitación de la depuración remota mediante Chrome DevTools y ADB Logcat en Android

Antes de modificar los delegados nativos, verifique si la página web cargada emite la redirección esperada. Según la guía de depuración remota de Chrome DevTools para Android, habilite explícitamente la depuración remota de WebView en las compilaciones de desarrollo inspeccionando ApplicationInfo.FLAG_DEBUGGABLE e invocando WebView.setWebContentsDebuggingEnabled(true). Nunca envíe la depuración habilitada en versiones de producción:

// Android - Enable WebView debugging exclusively in debuggable builds
if (applicationInfo.flags and ApplicationInfo.FLAG_DEBUGGABLE != 0) {
    WebView.setWebContentsDebuggingEnabled(true)
}

Conecte el dispositivo mediante USB, abra chrome://inspect/#devices en el Chrome de escritorio y supervise la pestaña Network con Preserve log marcado. Filtre simultáneamente los registros de tiempo de ejecución nativos a través de adb logcat para capturar ActivityNotFoundException, SecurityException o registros de contenedor personalizados. Tenga en cuenta que las advertencias de obsolescencia para la firma heredada shouldOverrideUrlLoading(WebView, String) aparecen durante la compilación de Android Studio / Gradle en lugar de en el tiempo de ejecución de adb logcat:

# Terminal - Filter logcat for custom WebView tags and ActivityTaskManager intent resolution
adb logcat -s "WebViewDebug" "ActivityTaskManager" "PackageManager"

Configuración de isInspectable y conexión de Safari Web Inspector y la consola de Xcode en iOS

A partir de iOS 16.4 y macOS 13.3, Apple requiere que las aplicaciones opten por el uso de WKWebView.isInspectable, que por defecto es false. Habilite webView.isInspectable = true dentro de los bloques #if DEBUG:

// iOS - Enable Safari Web Inspector opt-in on iOS 16.4+ debug builds
#if DEBUG
if #available(iOS 16.4, *) {
    webView.isInspectable = true
}
#endif

En el dispositivo iOS físico, navegue a Configuración > Aplicaciones > Safari > Avanzado (en versiones de iOS anteriores, Configuración > Safari > Avanzado) y habilite Web Inspector. Conéctese mediante USB, abra el menú Develop de Safari de escritorio y supervise la Consola de Xcode simultáneamente para ver los resultados nativos de la finalización de decidePolicyForNavigationAction, createWebViewWith y UIApplication.shared.open.

Android WebView and iOS WKWebView use distinct native navigation and popup handlers.

Resolución de caídas silenciosas de nuevas ventanas y gestos de usuario faltantes en iOS WKWebView

Separación de la evaluación de políticas de los efectos secundarios en WKNavigationDelegate y WKUIDelegate

Cuando un enlace web especifica target="_blank" o window.open(), WebKit crea una solicitud de navegación de ventana nueva donde navigationAction.targetFrame es nil e involucra tanto a WKNavigationDelegate como a WKUIDelegate. Si la aplicación host no implementa webView(_:createWebViewWithConfiguration:for:windowFeatures:), WebKit no puede generar un WebView secundario y las navegaciones pueden parecer fallar en silencio.

Para evitar lanzamientos duplicados de aplicaciones externas o tokens de generación incrementados dobles cuando ambos delegados inspeccionan una solicitud, separe la evaluación de políticas puras (evaluateNavigationPolicy) de los efectos secundarios de ejecución, y deduplique por la instancia específica de WKNavigationAction (ObjectIdentifier(navigationAction)) en lugar de depender puramente de un umbral de tiempo aproximado que podría suprimir los clics rápidos repetidos intencionales de un usuario. Evalúe navigationAction.targetFrame == nil directamente en decidePolicyForNavigationAction: si la evaluación devuelve un plan de transferencia externo, ejecútelo una vez (registrando el identificador de WKNavigationAction) y pase .cancel; si devuelve .allowInWebView para una URL emergente en lista blanca, pase .allow para que createWebViewWith cargue la ventana emergente de forma segura. Verifique siempre el orden exacto de las devoluciones de llamada de los delegados en las versiones de iOS de destino.

Contexto de enlaces universales, seguridad contra carreras asíncronas e identidad de esquemas personalizados

La transferencia de enlaces universales depende del contexto de navegación de origen, la relación de dominio y la configuración de dominios asociados (verificada a través del archivo apple-app-site-association del servidor de destino). La nota técnica TN3155: Depuración de enlaces universales de Apple documenta cómo la navegación en el mismo dominio en Safari prefiere permanecer en el navegador, mientras que los subdominantes distintos alteran la elegibilidad. Pruebe siempre el comportamiento de los dominios asociados en las versiones de iOS de destino dentro de WKWebView.

Al llamar a UIApplication.shared.open(url, options: [.universalLinksOnly: true]), protéjase contra condiciones de carrera de navegación asíncronas: si un usuario inicia cualquier intento posterior de navegación en el marco principal mientras el sistema procesa la transferencia del enlace universal, un controlador de finalización no protegido que devuelva false podría sobrescribir el estado de navegación más nuevo del usuario. Incremente un token monotónico activeNavigationGeneration en cada nueva evaluación de navegación del marco principal (incluidos los intentos bloqueados o redirigidos) para que cualquier respaldo asincrónico anterior pendiente quede invalidado inmediatamente, y verifique self.activeNavigationGeneration == requestGeneration junto con self.isViewLoaded && self.view.window != nil antes de volver a cargar las URL de respaldo.

Observe dos límites estrictos de seguridad:

  • Clasificación de WKNavigationType: Según la documentación de WKNavigationType de Apple, formSubmitted representa una solicitud para enviar un formulario en lugar de un toque de enlace, y los scripts de página pueden enviar formularios mediante programación. Restrinja las transferencias de aplicaciones externas a eventos .linkActivated clasificados por WebKit combinados con sourceFrame.isMainFrame y listas completas de URI permitidas, en lugar de tratar .linkActivated como un token de gesto criptográfico aislado.
  • Unicidad de esquemas personalizados y contaminación de parámetros: Según la guía de Apple sobre Definición de un esquema de URL personalizado para su aplicación, varias aplicaciones pueden reclamar el mismo esquema personalizado. isAllowedCustomURL(_:) valida la estructura de la URI (esquema, host, puerto predeterminado nil, patrón de ruta, sin información de usuario/fragmento, y rechaza claves de consulta duplicadas), no la identidad del ID de paquete de destino. Utilice enlaces universales verificados por dominio siempre que se requiera la vinculación de la identidad de la aplicación.

Descargo de responsabilidad de la arquitectura de referencia: La siguiente implementación es una arquitectura de referencia defensiva. Valide la disponibilidad de la API, el orden de los delegados y el comportamiento del ciclo de vida frente a las versiones exactas de AndroidX e iOS utilizadas por su aplicación.

// iOS - WebViewContainerController.swift
// Reference architecture: compile and test against your specific project targets (iOS 15.0–18.0)
import UIKit
import WebKit

final class WebViewContainerController: UIViewController, WKNavigationDelegate, WKUIDelegate {

    private enum NavigationPlan: Equatable {
        case allowInWebView
        case launchCustomScheme(URL)
        case attemptUniversalLink(URL)
        case block
    }

    private var webView: WKWebView!

    // Explicit allowlist for external custom URL schemes, hosts, and query keys
    private let allowedCustomSchemes: Set<String> = ["myapp", "partnerapp"]
    private let allowedCustomHosts: Set<String> = ["open", "product", "promo"]
    private let allowedCustomQueryKeys: Set<String> = ["id", "ref", "promo"]

    // Explicit allowlist for HTTPS hosts permitted inside the primary WebView container
    private let allowedWebHosts: Set<String> = [
        "example.com",
        "m.example.com",
        "links.example.com"
    ]

    // Isolated allowlists specifically for child popup windows (target="_blank")
    private let allowedPopupHosts: Set<String> = ["example.com", "auth.example.com"]
    private let allowedPopupPathPrefixes: [String] = ["/oauth", "/popup", "/window"]

    // External Universal Link hosts that attempt native app handoff on link activation
    private let externalUniversalLinkHosts: Set<String> = ["links.example.com"]

    // Monotonic navigation generation token incremented on every new main-frame navigation attempt
    private var activeNavigationGeneration: UInt64 = 0

    // Action-level deduplication preventing duplicate dispatches for the same WKNavigationAction
    private var dispatchedActionIDs: [ObjectIdentifier] = []
    private let maxTrackedActionIDs = 16

    // Monotonic-uptime TTL-bounded bypass cache keyed by normalized Universal Link key
    private var bypassedUniversalLinkKeys: [String: TimeInterval] = [:]
    private let maxBypassedKeys = 10
    private let bypassTTLSeconds: TimeInterval = 300
    // Adapt significant query keys to match your application's actual routing parameters
    private let significantLoopQueryKeys: Set<String> = ["id"]

    override func viewDidLoad() {
        super.viewDidLoad()

        let configuration = WKWebViewConfiguration()
        webView = WKWebView(frame: view.bounds, configuration: configuration)
        webView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
        webView.navigationDelegate = self
        webView.uiDelegate = self

        #if DEBUG
        if #available(iOS 16.4, *) {
            webView.isInspectable = true
        }
        #endif

        view.addSubview(webView)
    }

    // MARK: - WKNavigationDelegate

    func webView(
        _ webView: WKWebView,
        decidePolicyFor navigationAction: WKNavigationAction,
        decisionHandler: @escaping (WKNavigationActionPolicy) -> Void
    ) {
        guard let url = navigationAction.request.url else {
            decisionHandler(.cancel)
            return
        }

        let isMainFrame = navigationAction.sourceFrame.isMainFrame
        let isNewWindow = (navigationAction.targetFrame == nil)

        // Increment generation token on every main-frame navigation attempt (including blocked attempts)
        // so any pending prior asynchronous Universal Link fallback is invalidated immediately.
        if isMainFrame && !isNewWindow {
            activeNavigationGeneration &+= 1
        }
        let requestGeneration = activeNavigationGeneration

        let plan = evaluateNavigationPolicy(
            url: url,
            navigationType: navigationAction.navigationType,
            isMainFrame: isMainFrame,
            isNewWindow: isNewWindow
        )

        switch plan {
        case .allowInWebView:
            decisionHandler(.allow)

        case .launchCustomScheme(let targetURL):
            if isMainFrame { activeNavigationGeneration &+= 1 }
            executeExternalDispatchOnce(
                action: navigationAction,
                url: targetURL,
                isUniversalLink: false,
                requestGeneration: activeNavigationGeneration
            )
            decisionHandler(.cancel)

        case .attemptUniversalLink(let targetURL):
            if isMainFrame { activeNavigationGeneration &+= 1 }
            let currentGen = activeNavigationGeneration
            executeExternalDispatchOnce(
                action: navigationAction,
                url: targetURL,
                isUniversalLink: true,
                requestGeneration: currentGen
            )
            decisionHandler(.cancel)

        case .block:
            decisionHandler(.cancel)
        }
    }

    // MARK: - WKUIDelegate (Handles target="_blank" and window.open)

    func webView(
        _ webView: WKWebView,
        createWebViewWith configuration: WKWebViewConfiguration,
        for navigationAction: WKNavigationAction,
        windowFeatures: WKWindowFeatures
    ) -> WKWebView? {
        guard navigationAction.targetFrame == nil,
              let url = navigationAction.request.url else {
            return nil
        }

        let isMainFrame = navigationAction.sourceFrame.isMainFrame
        if isMainFrame {
            activeNavigationGeneration &+= 1
        }
        let currentGen = activeNavigationGeneration

        let plan = evaluateNavigationPolicy(
            url: url,
            navigationType: navigationAction.navigationType,
            isMainFrame: isMainFrame,
            isNewWindow: true
        )

        switch plan {
        case .allowInWebView:
            webView.load(navigationAction.request)

        case .launchCustomScheme(let targetURL):
            executeExternalDispatchOnce(
                action: navigationAction,
                url: targetURL,
                isUniversalLink: false,
                requestGeneration: currentGen
            )

        case .attemptUniversalLink(let targetURL):
            executeExternalDispatchOnce(
                action: navigationAction,
                url: targetURL,
                isUniversalLink: true,
                requestGeneration: currentGen
            )

        case .block:
            break
        }

        return nil
    }

    // MARK: - Pure Navigation Policy Evaluation (Zero Side Effects)

    private func evaluateNavigationPolicy(
        url: URL,
        navigationType: WKNavigationType,
        isMainFrame: Bool,
        isNewWindow: Bool
    ) -> NavigationPlan {
        guard let scheme = url.scheme?.lowercased() else {
            return .block
        }

        let isLinkActivated = (navigationType == .linkActivated)

        // 1. Evaluate non-HTTP/HTTPS Custom URL Schemes
        // Note: Custom scheme allowlisting validates URI structure; it cannot guarantee target Bundle ID identity.
        if scheme != "http" && scheme != "https" {
            guard isMainFrame, isLinkActivated, isAllowedCustomURL(url) else {
                return .block
            }
            return .launchCustomScheme(url)
        }

        // 2. Enforce HTTPS-only, default port (nil or 443), and Host Allowlists
        let targetHost = url.host?.lowercased()
        if isNewWindow {
            guard isMainFrame, isLinkActivated, isAllowedPopupWebURL(url) else {
                return .block
            }
        } else {
            guard isAllowedWebURL(url), let host = targetHost, allowedWebHosts.contains(host) else {
                return .block
            }
        }

        // 3. Evaluate Universal Link Handoffs for designated external hosts on link activation
        if let host = targetHost,
           externalUniversalLinkHosts.contains(host),
           isMainFrame,
           isLinkActivated,
           let loopKey = universalLinkLoopKey(for: url),
           !isBypassedKeyActive(loopKey) {
            return .attemptUniversalLink(url)
        }

        return .allowInWebView
    }

    // MARK: - Action-Level Deduplicated External Dispatch Execution

    private func executeExternalDispatchOnce(
        action: WKNavigationAction,
        url: URL,
        isUniversalLink: Bool,
        requestGeneration: UInt64
    ) {
        let actionID = ObjectIdentifier(action)
        if dispatchedActionIDs.contains(actionID) {
            return
        }
        if dispatchedActionIDs.count >= maxTrackedActionIDs {
            dispatchedActionIDs.removeFirst()
        }
        dispatchedActionIDs.append(actionID)

        if isUniversalLink {
            guard let loopKey = universalLinkLoopKey(for: url) else { return }
            UIApplication.shared.open(url, options: [.universalLinksOnly: true]) { [weak self] success in
                // Verify view lifecycle AND generation token to prevent stale async fallback overwrites
                guard let self = self,
                      self.isViewLoaded,
                      self.view.window != nil,
                      self.activeNavigationGeneration == requestGeneration else {
                    return
                }
                if !success {
                    self.recordBypassedKey(loopKey)
                    self.webView.load(URLRequest(url: url))
                }
            }
        } else {
            UIApplication.shared.open(url, options: [:]) { success in
                if !success {
                    print("[WebViewDebug] Failed to launch custom scheme (app may not be installed)")
                }
            }
        }
    }

    private func isAllowedWebURL(_ url: URL) -> Bool {
        guard let components = URLComponents(url: url, resolvingAgainstBaseURL: false),
              let scheme = components.scheme?.lowercased(),
              scheme == "https",
              components.user == nil,
              components.password == nil,
              (components.port == nil || components.port == 443) else {
            return false
        }
        return true
    }

    private func isAllowedPopupWebURL(_ url: URL) -> Bool {
        guard isAllowedWebURL(url),
              let components = URLComponents(url: url, resolvingAgainstBaseURL: false),
              let host = components.host?.lowercased(),
              allowedPopupHosts.contains(host),
              components.fragment == nil else {
            return false
        }

        let path = components.path
        return allowedPopupPathPrefixes.contains { path == $0 || path.hasPrefix("\($0)/"); }
    }

    private func isAllowedCustomURL(_ url: URL) -> Bool {
        guard let components = URLComponents(url: url, resolvingAgainstBaseURL: false),
              let scheme = components.scheme?.lowercased(),
              let host = components.host?.lowercased(),
              allowedCustomSchemes.contains(scheme),
              allowedCustomHosts.contains(host),
              components.user == nil,
              components.password == nil,
              components.port == nil, // Reject explicit ports on custom schemes
              components.fragment == nil else {
            return false
        }

        let path = components.path
        if !path.isEmpty &&
           path.range(of: "^/[A-Za-z0-9/_-]{1,64}$", options: .regularExpression) == nil {
            return false
        }

        if let queryItems = components.queryItems {
            var seenKeys = Set<String>()
            for item in queryItems {
                if seenKeys.contains(item.name) {
                    return false
                }
                seenKeys.insert(item.name)

                guard allowedCustomQueryKeys.contains(item.name),
                      let value = item.value,
                      value.count <= 64,
                      value.range(of: "^[A-Za-z0-9_-]+$", options: .regularExpression) != nil else {
                    return false
                }
            }
        }
        return true
    }

    private func universalLinkLoopKey(for url: URL) -> String? {
        guard let components = URLComponents(url: url, resolvingAgainstBaseURL: false),
              let scheme = components.scheme?.lowercased(),
              let host = components.host?.lowercased() else {
            return nil
        }

        let portPart = (components.port != nil && components.port != 443) ? ":\(components.port!)" : ""
        let significantParams = (components.queryItems ?? [])
            .filter { significantLoopQueryKeys.contains($0.name) }
            .sorted { $0.name < $1.name }
            .map { "\($0.name)=\($0.value ?? "")" }
            .joined(separator: "&")

        let querySuffix = significantParams.isEmpty ? "" : "?\(significantParams)"
        return "\(scheme)://\(host)\(portPart)\(components.path)\(querySuffix)"
    }

    private func isBypassedKeyActive(_ key: String) -> Bool {
        let now = ProcessInfo.processInfo.systemUptime
        bypassedUniversalLinkKeys = bypassedUniversalLinkKeys.filter {
            (now - $0.value) < bypassTTLSeconds
        }
        return bypassedUniversalLinkKeys[key] != nil
    }

    private func recordBypassedKey(_ key: String) {
        let now = ProcessInfo.processInfo.systemUptime
        bypassedUniversalLinkKeys = bypassedUniversalLinkKeys.filter {
            (now - $0.value) < bypassTTLSeconds
        }
        if bypassedUniversalLinkKeys.count >= maxBypassedKeys,
           let oldestKey = bypassedUniversalLinkKeys.min(by: { $0.value < $1.value })?.key {
            bypassedUniversalLinkKeys.removeValue(forKey: oldestKey)
        }
        bypassedUniversalLinkKeys[key] = now
    }
}

Solución de ERR_UNKNOWN_URL_SCHEME y fallos de visibilidad de paquetes en Android WebView

Devoluciones de llamada obsoletas, hasGesture() y límites de POST

Android marcó como obsoleto shouldOverrideUrlLoading(WebView, String) en el nivel de API 24 a favor de shouldOverrideUrlLoading(WebView, WebResourceRequest). WebResourceRequest proporciona isForMainFrame, isRedirect y hasGesture(). Tenga en cuenta dos restricciones oficiales de la plataforma: shouldOverrideUrlLoading no se invoca para llamadas webView.loadUrl() iniciadas por la aplicación ni para navegaciones HTTP POST, y hasGesture() puede devolver false para redirecciones legítimas de JavaScript asíncrono o saltos 302 del lado del servidor.

Manejo de ventanas emergentes de defensa en profundidad y aislamiento de subprocesos en WebChromeClient.onCreateWindow

El comportamiento de las ventanas emergentes de Android depende de WebSettings.setSupportMultipleWindows. Si su aplicación no requiere ventanas emergentes interactivas, mantener setSupportMultipleWindows(false) (o devolver false desde onCreateWindow) evita que los iframes de terceros abran contenedores secundarios, o abre destinos verificados a través de un punto de entrada explícito controlado por el host.

Cuando setSupportMultipleWindows(true) está habilitado, WebChromeClient.onCreateWindow no proporciona la URL de destino en su firma de devolución de llamada, y ninguna devolución de llamada única cubre cada vector de navegación. Comprender el modelo de subprocesos exacto y los límites de las devoluciones de llamada es esencial para un enfoque de referencia de defensa en profundidad:

  • shouldOverrideUrlLoading (Hilo de la interfaz de usuario — Propietario de la navegación y el estado de la sesión): Se ejecuta exclusivamente en el hilo de la interfaz de usuario y posee todo el estado mutable de la sesión emergente (isInitialTransportLoad, isAuthorizedPopupSession, popupRedirectHops y popupChainStartMs). Solo una vez que una carga inicial verificada o un gesto directo del usuario coincide con policy.isAllowedPopupUri, shouldOverrideUrlLoading autoriza la sesión para las posteriores redirecciones HTTP 302 acotadas (request.isRedirect), asegurando que las cadenas de redirección se vinculen a una sesión autorizada en lugar de confiar en redirecciones arbitrarias.
  • shouldInterceptRequest (Hilo de E/S de WebView en segundo plano — Guardia de solo lectura sin estado): Se ejecuta en un subproceso de WebView que no es de la interfaz de usuario. Debido a que nunca debe mutar el estado de la sesión del hilo de la interfaz de usuario, opera estrictamente como una comprobación de política de solo lectura sin estado en safeClient.policy (bloqueando las solicitudes HTTP/HTTPS del marco principal que no superan isAllowedPopupUri y enviando disposeActivePopup() al hilo principal). Tenga en cuenta que, según la documentación de Android, shouldInterceptRequest solo se llama para la URL del recurso inicial, no para las URL de redirección HTTP 302 posteriores; las URL de redirección posteriores deben ser evaluadas por shouldOverrideUrlLoading.
  • onPageStarted (Hilo de la interfaz de usuario — Comprobación de respaldo de inicio de navegación): Se ejecuta cuando comienza la carga del marco principal (no como un filtro previo a la navegación). Actualiza el banner de origen visible para la transparencia del usuario y proporciona una comprobación de respaldo de inicio de navegación llamando a stopLoading() y disposeActivePopup() si una categoría de destino no aprobada comienza a cargarse.

Pruebe siempre las URL iniciales maliciosas, las cadenas HTTP 302 entre dominios, las redirecciones 302 consecutivas, target="_blank", window.open() y los activadores de iframes de terceros en las compilaciones físicas de WebView de destino.

Visibilidad de paquetes en Android 11+ y directrices obsoletas de canOpenURL

Bajo las reglas de visibilidad de paquetes de Android, las aplicaciones que se ejecutan en Android 11 (nivel de API 30) o superior y se dirigen al nivel de API 30 o superior (targetSdk >= 30) reciben resultados nulos o vacíos de intent.resolveActivity() o queryIntentActivities() a menos que las aplicaciones de destino estén declaradas bajo <queries> en AndroidManifest.xml. Android recomienda llamar a startActivity(intent) directamente dentro de un bloque try/catch para ActivityNotFoundException y SecurityException en lugar de ampliar <queries>.

En iOS, Apple ha desaprobado UIApplication.canOpenURL(_:) y recomienda intentar UIApplication.shared.open(_:options:completionHandler:) directamente y manejar cualquier fallo en el controlador de finalización (o migrar a Enlaces Universales para eliminar la prevalidación de esquemas). LSApplicationQueriesSchemes en Info.plist solo es necesario si el código heredado continúa llamando a canOpenURL(_:), mientras que open(_:options:completionHandler:) no requiere declarar esquemas en Info.plist. Tanto <queries> como LSApplicationQueriesSchemes controlan la visibilidad de consultas; no son listas blancas de seguridad para validar URI web no confiables.

<!-- Manifest Fragment: Merge <queries> into your existing AndroidManifest.xml -->
<!-- Required for targetSdk >= 30 on Android 11+ ONLY if calling resolveActivity or queryIntentActivities -->
<queries>
    <intent>
        <action android:name="android.intent.action.VIEW" />
        <category android:name="android.intent.category.BROWSABLE" />
        <data android:scheme="myapp" />
    </intent>
    <intent>
        <action android:name="android.intent.action.VIEW" />
        <category android:name="android.intent.category.BROWSABLE" />
        <data android:scheme="partnerapp" />
    </intent>
</queries>
<!-- Info.plist Fragment: Insert under the root <dict> in Info.plist -->
<!-- Legacy: Required on iOS ONLY if calling deprecated UIApplication.shared.canOpenURL; open(_:options:completionHandler:) does not require this key -->
<key>LSApplicationQueriesSchemes</key>
<array>
    <string>myapp</string>
    <string>partnerapp</string>
</array>

Cómo analizar de forma segura las URI de intents de Chrome y evitar bucles de redirección

Protección de Intent.parseUri contra vulnerabilidades de redirección de intents

Las URI intent:// de Android codifican un esquema de destino, un paquete y una URL de respaldo (S.browser_fallback_url). El análisis de URI web no confiables a través de Intent.parseUri(rawUri, Intent.URI_INTENT_SCHEME) introduce riesgos de redirección de intents detallados en la guía de seguridad de redirección de intents de Android y la Guía de pruebas de seguridad de aplicaciones móviles de OWASP. Incluso con la incorporación por parte de Android 16 (API 36) de un endurecimiento predeterminado a nivel de plataforma, las aplicaciones deben aplicar una validación estricta antes de enviar los Intents.

Layered URI validation blocks unsafe WebView intents before external application dispatch.

Para implementar una validación de bloqueo en caso de fallo utilizando la utilidad AndroidX IntentSanitizer (androidx.core:core:1.9.0+, o androidx.core:core-ktx:1.9.0+ que incluye androidx.core:core) sin activar conflictos de exclusión mutua de constructores entre allowAnyComponent() y los métodos de lista blanca de paquetes/componentes:

  • Comprobaciones de desinfección previa: Rechace inmediatamente los intents que transporten campos component o selector no nulos (parsedIntent.component != null || parsedIntent.selector != null). Extraiga y elimine browser_fallback_url antes de la desinfección, y verifique de forma nativa que parsedIntent.data?.scheme se asigne 1 a 1 al paquete parsedIntent. a través de customSchemeTargetPackages (asegurando que myapp:// se resuelva estrictamente en com.example.target, nunca en otro paquete asociado).
  • Ejecución del desinfectante: Limpie temporalmente el paquete parsedIntent. = null en la copia no confiable, ejecute IntentSanitizer.Builder().allowAnyComponent().allowAction(Intent.ACTION_VIEW).allowCategory(Intent.CATEGORY_BROWSABLE).allowData { ... }.build().sanitizeByThrowing(parsedIntent) (cero indicadores de tareas proporcionados por la página web) y reasigne el expectedPackage validado y CATEGORY_BROWSABLE en el Intent de propiedad del host desinfectado antes de las aserciones posteriores a la desinfección.
  • Indicadores de lanzamiento conscientes del contexto: Inyecte Intent.FLAG_ACTIVITY_NEW_TASK dentro del despachador nativo (launchWithContextSafety) solo cuando view.context !is Activity. Para la verificación de asociación de dominio a aplicación, prefiera los Enlaces de Aplicaciones de Android HTTPS verificados (assetlinks.json).

Prevención de bucles de respaldo infinitos con estado de cadena monotónica

Cuando startActivity genera una ActivityNotFoundException, valide browser_fallback_url con una comprobación dedicada isAllowedFallbackUri(uri) (estrictamente HTTPS, puerto predeterminado, host verificado, prefijos de ruta de respaldo explícitos, sin claves de consulta duplicadas y sin fragmentos). Rechace representaciones de puertos explícitos en esquemas personalizados verificando tanto que uri.port == -1 como que !uri.encodedAuthority.orEmpty().contains(":").

Realice un seguimiento de las cadenas de respaldo utilizando SystemClock.elapsedRealtime() (evitando saltos de reloj de pared System.currentTimeMillis()), aísle las cadenas a través de fallbackLoopKey() (no la canonicalización completa de IETF RFC 3986), restablezca el estado a través de un contenedor de host explícito loadNewNavigation(webView, url) y enrute las reservas de ventanas emergentes al contenedor principal mediante onPopupFallbackHandoff para que los dominios no autorizados nunca se carguen dentro de un cuadro de diálogo emergente.

Descargo de responsabilidad de la arquitectura de referencia: La siguiente implementación es una arquitectura de referencia defensiva. Valide la disponibilidad de la API, el orden de los delegados y el comportamiento del ciclo de vida frente a las versiones exactas de AndroidX e iOS utilizadas por su aplicación.

// Android - SafeWebViewModules.kt
// Reference architecture: compile and test against your specific project targets
// Requires androidx.core:core:1.9.0+ (or androidx.core:core-ktx:1.9.0+) for IntentSanitizer; targets minSdk >= 24.
package com.example.hostapp.webview

import android.app.Activity
import android.app.Dialog
import android.content.ActivityNotFoundException
import android.content.Intent
import android.content.pm.ApplicationInfo
import android.net.Uri
import android.os.Bundle
import android.os.Message
import android.os.SystemClock
import android.util.Log
import android.view.ViewGroup
import android.widget.TextView
import android.webkit.WebChromeClient
import android.webkit.WebResourceRequest
import android.webkit.WebResourceResponse
import android.webkit.WebView
import android.webkit.WebViewClient
import androidx.appcompat.app.AppCompatActivity
import androidx.core.content.IntentSanitizer
import java.io.ByteArrayInputStream
import java.net.URISyntaxException

// 1. Policy Module (Immutable / Thread-Safe for read-only access from IO & UI threads)
class CustomUriPolicy(
    val customSchemeTargetPackages: Map<String, String> = mapOf(
        "myapp" to "com.example.target",
        "partnerapp" to "com.partner.app"
    ),
    val allowedCustomHosts: Set<String> = setOf("open", "product", "promo"),
    val allowedCustomQueryKeys: Set<String> = setOf("id", "ref", "promo"),
    val allowedWebHosts: Set<String> = setOf("example.com", "downloads.example.com"),
    val allowedFallbackHosts: Set<String> = setOf("downloads.example.com", "example.com"),
    val allowedFallbackPathPrefixes: List<String> = listOf("/download", "/app", "/landing"),
    val allowedFallbackQueryKeys: Set<String> = setOf("id", "ref", "promo", "utm_source"),
    // Isolated allowlists explicitly for popup windows; distinct from general web hosts
    val allowedPopupHosts: Set<String> = setOf("example.com", "auth.example.com"),
    val allowedPopupPathPrefixes: List<String> = listOf("/oauth", "/popup", "/window")
) {
    val allowedCustomSchemes: Set<String> get() = customSchemeTargetPackages.keys
    val allowedTargetPackages: Set<String> get() = customSchemeTargetPackages.values.toSet()

    private val pathPattern = Regex("^/[A-Za-z0-9/_-]{1,64}$")
    private val queryValuePattern = Regex("^[A-Za-z0-9_-]{1,64}$")

    fun isAllowedWebUri(uri: Uri): Boolean {
        val scheme = uri.scheme?.lowercase() ?: return false
        val host = uri.host?.lowercase() ?: return false
        return scheme == "https" &&
            host in allowedWebHosts &&
            (uri.port == -1 || uri.port == 443) &&
            uri.userInfo == null
    }

    fun isAllowedPopupUri(uri: Uri): Boolean {
        val scheme = uri.scheme?.lowercase() ?: return false
        val host = uri.host?.lowercase() ?: return false
        if (scheme != "https" || host !in allowedPopupHosts) return false
        if ((uri.port != -1 && uri.port != 443) || uri.userInfo != null || uri.fragment != null) return false

        val path = uri.path.orEmpty()
        return allowedPopupPathPrefixes.any { path == it || path.startsWith("$it/") } && pathPattern.matches(path)
    }

    fun isAllowedFallbackUri(uri: Uri): Boolean {
        val scheme = uri.scheme?.lowercase() ?: return false
        val host = uri.host?.lowercase() ?: return false
        if (scheme != "https" || host !in allowedFallbackHosts) return false
        if ((uri.port != -1 && uri.port != 443) || uri.userInfo != null || uri.fragment != null) {
            return false
        }

        val path = uri.path.orEmpty()
        if (allowedFallbackPathPrefixes.none { path == it || path.startsWith("$it/") } ||
            !pathPattern.matches(path)
        ) {
            return false
        }

        // Validate query keys, enforce value syntax, and reject duplicate keys
        val queryNames = uri.queryParameterNames
        for (paramName in queryNames) {
            if (paramName !in allowedFallbackQueryKeys) return false
            val values = uri.getQueryParameters(paramName)
            if (values.size != 1 || !queryValuePattern.matches(values[0])) return false
        }
        return true
    }

    fun isAllowedCustomUri(uri: Uri): Boolean {
        val scheme = uri.scheme?.lowercase() ?: return false
        val host = uri.host?.lowercase() ?: return false
        if (scheme !in allowedCustomSchemes || host !in allowedCustomHosts) return false

        // Reject network ports strictly by checking both uri.port == -1 and raw authority colon absence
        val rawAuthority = uri.encodedAuthority.orEmpty()
        if (uri.userInfo != null || uri.port != -1 || rawAuthority.contains(":") || uri.fragment != null) {
            return false
        }

        val path = uri.path.orEmpty()
        if (path.isNotEmpty() && !pathPattern.matches(path)) return false

        // Validate query keys, enforce value syntax, and reject duplicate keys
        val queryNames = uri.queryParameterNames
        for (paramName in queryNames) {
            if (paramName !in allowedCustomQueryKeys) return false
            val values = uri.getQueryParameters(paramName)
            if (values.size != 1 || !queryValuePattern.matches(values[0])) return false
        }
        return true
    }
}

// 2. Fallback Manager: Monotonic Elapsed-Time Chain State (Isolates active chain from repeat sessions)
class FallbackLoopGuard(
    private val maxHopsPerChain: Int = 3,
    private val chainTtlMs: Long = 30_000L,
    private val significantQueryKeys: Set<String> = setOf("id")
) {
    private var chainStartElapsedMs: Long = 0L
    private var fallbackHopCount: Int = 0
    private val visitedInCurrentChain = mutableSetOf<String>()

    fun resetChain() {
        chainStartElapsedMs = 0L
        fallbackHopCount = 0
        visitedInCurrentChain.clear()
    }

    fun canLoadFallback(uri: Uri, currentWebViewUrl: String?): Boolean {
        val now = SystemClock.elapsedRealtime()

        if (chainStartElapsedMs == 0L || (now - chainStartElapsedMs) > chainTtlMs) {
            chainStartElapsedMs = now
            fallbackHopCount = 0
            visitedInCurrentChain.clear()
        }

        val loopKey = fallbackLoopKey(uri)
        val currentKey = currentWebViewUrl?.let { fallbackLoopKey(Uri.parse(it)) }

        if (fallbackHopCount >= maxHopsPerChain ||
            loopKey == currentKey ||
            loopKey in visitedInCurrentChain
        ) {
            return false
        }

        visitedInCurrentChain.add(loopKey)
        fallbackHopCount++
        return true
    }

    // Application-level loop key normalizing default HTTPS port and preserving significant query keys
    private fun fallbackLoopKey(uri: Uri): String {
        val scheme = uri.scheme?.lowercase().orEmpty()
        val host = uri.host?.lowercase().orEmpty()
        val portSuffix = if (uri.port != -1 && uri.port != 443) ":${uri.port}" else ""
        val path = uri.path.orEmpty()

        val sigParams = uri.queryParameterNames
            .filter { it in significantQueryKeys }
            .sorted()
            .joinToString("&") { key -> "$key=${uri.getQueryParameter(key).orEmpty()}" }

        val querySuffix = if (sigParams.isEmpty()) "" else "?$sigParams"
        return "$scheme://$host$portSuffix$path$querySuffix"
    }
}

// 3. Router & Fail-Closed IntentSanitizer WebViewClient (UI Thread Only)
class SafeRedirectWebViewClient(
    val policy: CustomUriPolicy = CustomUriPolicy(),
    val loopGuard: FallbackLoopGuard = FallbackLoopGuard(),
    private val onPopupFallbackHandoff: ((fallbackUri: Uri) -> Unit)? = null
) : WebViewClient() {

    // Explicit host-initiated navigation API that resets fallback chain state prior to loadUrl()
    fun loadNewNavigation(webView: WebView, url: String) {
        val targetUri = Uri.parse(url)
        if (!policy.isAllowedWebUri(targetUri)) {
            Log.w("WebViewDebug", "Blocked host-initiated navigation to untrusted URL")
            return
        }
        loopGuard.resetChain()
        webView.loadUrl(url)
    }

    // Dedicated fallback loader with internal validation preserving active chain state
    fun loadFallbackNavigation(webView: WebView, fallbackUri: Uri) {
        if (!policy.isAllowedFallbackUri(fallbackUri)) {
            Log.w("WebViewDebug", "Blocked untrusted fallback navigation attempt")
            return
        }
        webView.loadUrl(fallbackUri.toString())
    }

    override fun shouldOverrideUrlLoading(view: WebView, request: WebResourceRequest): Boolean {
        return handleNavigation(
            view = view,
            uri = request.url,
            isForMainFrame = request.isForMainFrame,
            hasUserGesture = request.hasGesture(),
            isPopupContext = false
        )
    }

    fun handleNavigation(
        view: WebView,
        uri: Uri?,
        isForMainFrame: Boolean,
        hasUserGesture: Boolean,
        isPopupContext: Boolean
    ): Boolean {
        val targetUri = uri ?: return true
        val scheme = targetUri.scheme?.lowercase() ?: return true

        // 1. Enforce HTTPS-only & Web Host Allowlist on all HTTP/HTTPS navigations
        if (scheme == "http" || scheme == "https") {
            if (!policy.isAllowedWebUri(targetUri)) {
                Log.w("WebViewDebug", "Blocked non-HTTPS, custom-port, or untrusted web host")
                return true
            }
            if (hasUserGesture && isForMainFrame) {
                loopGuard.resetChain()
            }
            return false
        }

        // 2. Enforce main-frame and user-gesture constraints on external app launches
        if (!isForMainFrame || !hasUserGesture) {
            Log.w("WebViewDebug", "Blocked non-main-frame or non-gesture scheme: $scheme")
            return true
        }

        // 3. Parse and fail-closed sanitize Chrome intent:// URIs
        if (scheme == "intent") {
            return handleIntentUri(view, targetUri.toString(), isPopupContext)
        }

        // 4. Validate and explicitly bind allowlisted custom URL schemes to 1-to-1 verified target packages
        if (policy.isAllowedCustomUri(targetUri)) {
            val expectedPackage = policy.customSchemeTargetPackages[scheme] ?: return true
            val viewIntent = Intent(Intent.ACTION_VIEW, targetUri).apply {
                addCategory(Intent.CATEGORY_BROWSABLE)
                `package` = expectedPackage
            }
            launchIntentSafely(view, viewIntent)
            return true
        }

        // 5. Block all unrecognized schemes
        Log.w("WebViewDebug", "Blocked unrecognized URL scheme: $scheme")
        return true
    }

    // UI-Thread Navigation Evaluator for child popup WebViews tying 302 redirects to authorized sessions
    fun handlePopupNavigation(
        view: WebView,
        uri: Uri?,
        isForMainFrame: Boolean,
        hasUserGesture: Boolean,
        isRedirect: Boolean,
        isInitialTransportLoad: Boolean,
        isAuthorizedPopupSession: Boolean,
        onAuthorizedInitialSession: () -> Unit,
        canProceedPopupRedirect: () -> Boolean
    ): Boolean {
        val targetUri = uri ?: return true
        val scheme = targetUri.scheme?.lowercase() ?: return true

        if (scheme == "http" || scheme == "https") {
            if (!isForMainFrame) {
                Log.w("WebViewDebug", "Blocked subframe HTTPS navigation inside popup")
                return true
            }
            if (!policy.isAllowedPopupUri(targetUri)) {
                Log.w("WebViewDebug", "Blocked untrusted popup HTTPS host or path navigation")
                return true
            }
            // Authorize session only on UI thread when initial load or user tap matches allowlist
            if (isInitialTransportLoad || hasUserGesture) {
                onAuthorizedInitialSession()
                return false
            }
            // Permit bounded server-side 302 redirects ONLY for previously authorized popup sessions
            if (isRedirect && isAuthorizedPopupSession && canProceedPopupRedirect()) {
                return false
            }

            Log.w("WebViewDebug", "Blocked unauthorized redirect or non-gesture popup navigation")
            return true
        }

        return handleNavigation(view, targetUri, isForMainFrame, hasUserGesture, isPopupContext = true)
    }

    private fun handleIntentUri(view: WebView, rawUri: String, isPopupContext: Boolean): Boolean {
        val parsedIntent = try {
            Intent.parseUri(rawUri, Intent.URI_INTENT_SCHEME)
        } catch (e: URISyntaxException) {
            Log.w("WebViewDebug", "Malformed intent URI syntax")
            return true
        }

        val fallbackUrl = parsedIntent.getStringExtra("browser_fallback_url")
        parsedIntent.removeExtra("browser_fallback_url")

        // 1-to-1 Binding: Extract target scheme and validate natively against expected target package
        val dataUri = parsedIntent.data ?: return true
        val targetScheme = dataUri.scheme?.lowercase() ?: return true
        val expectedPackage = policy.customSchemeTargetPackages[targetScheme] ?: run {
            Log.w("WebViewDebug", "Blocked intent with unmapped custom scheme: $targetScheme")
            return true
        }

        val rawPackage = parsedIntent.`package`
        if (rawPackage != expectedPackage) {
            Log.w("WebViewDebug", "Blocked intent package mismatch: expected $expectedPackage")
            return true
        }

        // Reject webpage-specified explicit components and selectors immediately
        if (parsedIntent.component != null || parsedIntent.selector != null) {
            Log.w("WebViewDebug", "Blocked intent with explicit component or selector")
            return true
        }

        // Clear verified package temporarily before invoking IntentSanitizer with allowAnyComponent()
        // to avoid Builder mutual-exclusion constraints while strictly rejecting untrusted flags/extras.
        parsedIntent.`package` = null

        val sanitizedIntent = try {
            IntentSanitizer.Builder()
                .allowAnyComponent()
                .allowAction(Intent.ACTION_VIEW)
                .allowCategory(Intent.CATEGORY_BROWSABLE)
                .allowData { uri -> policy.isAllowedCustomUri(uri) }
                .build()
                .sanitizeByThrowing(parsedIntent)
        } catch (e: SecurityException) {
            Log.w("WebViewDebug", "IntentSanitizer threw SecurityException for disallowed fields or flags")
            return true
        } catch (e: IllegalArgumentException) {
            Log.w("WebViewDebug", "IntentSanitizer rejected invalid intent arguments")
            return true
        }

        // Re-bind verified target package + host-enforced category + post-sanitization assertions
        sanitizedIntent.`package` = expectedPackage
        sanitizedIntent.addCategory(Intent.CATEGORY_BROWSABLE)

        val sanitizedData = sanitizedIntent.data
        if (sanitizedIntent.component != null ||
            sanitizedIntent.action != Intent.ACTION_VIEW ||
            sanitizedIntent.`package` != expectedPackage ||
            sanitizedData == null ||
            !policy.isAllowedCustomUri(sanitizedData)
        ) {
            Log.w("WebViewDebug", "Post-sanitization intent assertions failed")
            return true
        }

        try {
            launchWithContextSafety(view, sanitizedIntent)
            loopGuard.resetChain()
        } catch (e: ActivityNotFoundException) {
            if (!fallbackUrl.isNullOrBlank()) {
                val fallbackUri = Uri.parse(fallbackUrl)
                if (policy.isAllowedFallbackUri(fallbackUri) &&
                    loopGuard.canLoadFallback(fallbackUri, view.url)
                ) {
                    if (isPopupContext) {
                        onPopupFallbackHandoff?.invoke(fallbackUri)
                    } else {
                        loadFallbackNavigation(view, fallbackUri)
                    }
                } else {
                    Log.w("WebViewDebug", "Blocked untrusted or looping fallback URL")
                }
            }
        } catch (e: SecurityException) {
            Log.w("WebViewDebug", "SecurityException blocked intent launch")
        }
        return true
    }

    private fun launchIntentSafely(view: WebView, intent: Intent) {
        try {
            launchWithContextSafety(view, intent)
        } catch (e: ActivityNotFoundException) {
            Log.i("WebViewDebug", "No installed application handles target package/scheme")
        } catch (e: SecurityException) {
            Log.w("WebViewDebug", "SecurityException blocked custom scheme launch")
        }
    }

    private fun launchWithContextSafety(view: WebView, intent: Intent) {
        val safeIntent = Intent(intent)
        if (view.context !is Activity) {
            safeIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
        }
        view.context.startActivity(safeIntent)
    }
}

// 4. Lifecycle-Managed Popup WebChromeClient (Strict UI-Thread Session State & Stateless Background Guard)
class SafePopupWebChromeClient(
    private val safeClient: SafeRedirectWebViewClient
) : WebChromeClient() {

    private var activeDialog: Dialog? = null
    private var activeChildWebView: WebView? = null
    private var isDisposed: Boolean = false

    private fun disposeActivePopup() {
        if (isDisposed) return
        isDisposed = true

        val dialog = activeDialog
        val child = activeChildWebView
        activeDialog = null
        activeChildWebView = null

        dialog?.setOnDismissListener(null)
        dialog?.dismiss()

        child?.let {
            (it.parent as? ViewGroup)?.removeView(it)
            it.stopLoading()
            it.webViewClient = WebViewClient()
            it.webChromeClient = null
            it.destroy()
        }
    }

    override fun onCreateWindow(
        view: WebView,
        isDialog: Boolean,
        isUserGesture: Boolean,
        resultMsg: Message?
    ): Boolean {
        if (!isUserGesture) return false

        val activity = view.context as? Activity
        if (activity == null || activity.isFinishing || activity.isDestroyed) {
            return false
        }

        val transport = resultMsg?.obj as? WebView.WebViewTransport ?: return false
        disposeActivePopup()
        isDisposed = false

        val popupDialog = Dialog(activity)
        val popupRoot = android.widget.LinearLayout(activity).apply {
            orientation = android.widget.LinearLayout.VERTICAL
            layoutParams = ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT)
        }

        val originBanner = TextView(activity).apply {
            setPadding(24, 16, 24, 16)
            setBackgroundColor(android.graphics.Color.DKGRAY)
            setTextColor(android.graphics.Color.WHITE)
            textSize = 12f
            text = "Loading destination..."
        }
        popupRoot.addView(originBanner)

        // All popup session state variables below are read and mutated strictly on the UI thread
        var isInitialTransportLoad = true
        var isAuthorizedPopupSession = false
        var popupRedirectHops = 0
        var popupChainStartMs = SystemClock.elapsedRealtime()
        val maxPopupRedirects = 5
        val maxPopupRedirectWindowMs = 30_000L

        val childWebView = WebView(activity).apply {
            layoutParams = android.widget.LinearLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT)
            settings.apply {
                javaScriptEnabled = true
                allowFileAccess = false
                allowContentAccess = false
                setSupportMultipleWindows(false)
            }
            webViewClient = object : WebViewClient() {
                // UI Thread: Owns navigation, redirect, and session authorization state
                override fun shouldOverrideUrlLoading(
                    childView: WebView,
                    request: WebResourceRequest
                ): Boolean {
                    val hasGesture = request.hasGesture()
                    if (hasGesture) {
                        popupRedirectHops = 0
                        popupChainStartMs = SystemClock.elapsedRealtime()
                    }

                    val result = safeClient.handlePopupNavigation(
                        view = childView,
                        uri = request.url,
                        isForMainFrame = request.isForMainFrame,
                        hasUserGesture = hasGesture,
                        isRedirect = request.isRedirect,
                        isInitialTransportLoad = isInitialTransportLoad,
                        isAuthorizedPopupSession = isAuthorizedPopupSession,
                        onAuthorizedInitialSession = {
                            isAuthorizedPopupSession = true
                        },
                        canProceedPopupRedirect = {
                            val withinWindow = (SystemClock.elapsedRealtime() - popupChainStartMs) <= maxPopupRedirectWindowMs
                            if (withinWindow && popupRedirectHops < maxPopupRedirects) {
                                popupRedirectHops++
                                true
                            } else {
                                false
                            }
                        }
                    )
                    isInitialTransportLoad = false
                    return result
                }

                // Background WebView IO Thread: Strictly stateless, read-only policy check.
                // Never mutates UI-thread session state; covers initial resource URL only (not subsequent 302 hops).
                override fun shouldInterceptRequest(
                    childView: WebView,
                    request: WebResourceRequest
                ): WebResourceResponse? {
                    if (request.isForMainFrame) {
                        val targetUri = request.url
                        val scheme = targetUri?.scheme?.lowercase()
                        if ((scheme == "http" || scheme == "https") && !safeClient.policy.isAllowedPopupUri(targetUri)) {
                            Log.w("WebViewDebug", "Blocked unapproved popup main-frame request in shouldInterceptRequest")
                            childView.post { disposeActivePopup() }
                            return WebResourceResponse("text/plain", "utf-8", ByteArrayInputStream(ByteArray(0)))
                        }
                    }
                    return super.shouldInterceptRequest(childView, request)
                }

                // UI Thread: Navigation-start fallback check & origin display (not a pre-navigation filter)
                override fun onPageStarted(childView: WebView, url: String?, favicon: android.graphics.Bitmap?) {
                    super.onPageStarted(childView, url, favicon)
                    isInitialTransportLoad = false
                    val uri = url?.let { Uri.parse(it) }
                    if (uri == null || !safeClient.policy.isAllowedPopupUri(uri)) {
                        Log.w("WebViewDebug", "Navigation-start fallback check terminated unapproved popup URL")
                        childView.stopLoading()
                        disposeActivePopup()
                        return
                    }
                    isAuthorizedPopupSession = true
                    val scheme = uri.scheme?.lowercase() ?: "https"
                    val host = uri.host?.lowercase() ?: "Unknown"
                    originBanner.text = "Origin: $scheme://$host"
                }
            }
            webChromeClient = object : WebChromeClient() {
                override fun onCloseWindow(window: WebView?) {
                    disposeActivePopup()
                }
            }
        }
        popupRoot.addView(childWebView)

        popupDialog.setContentView(popupRoot)
        popupDialog.setOnDismissListener {
            disposeActivePopup()
        }

        activeDialog = popupDialog
        activeChildWebView = childWebView
        popupDialog.show()

        transport.webView = childWebView
        resultMsg.sendToTarget()
        return true
    }

    fun destroyPopups() {
        disposeActivePopup()
    }
}

// 5. Complete Host Activity Registration & Lifecycle Cleanup Example (JavaScript Enabled on Main WebView)
class SafeWebViewActivity : AppCompatActivity() {

    private lateinit var webView: WebView
    private lateinit var safeClient: SafeRedirectWebViewClient
    private lateinit var popupChromeClient: SafePopupWebChromeClient

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        if (applicationInfo.flags and ApplicationInfo.FLAG_DEBUGGABLE != 0) {
            WebView.setWebContentsDebuggingEnabled(true)
        }

        val policy = CustomUriPolicy()
        val loopGuard = FallbackLoopGuard()

        safeClient = SafeRedirectWebViewClient(
            policy = policy,
            loopGuard = loopGuard,
            onPopupFallbackHandoff = { fallbackUri ->
                popupChromeClient.destroyPopups()
                safeClient.loadFallbackNavigation(webView, fallbackUri)
            }
        )
        popupChromeClient = SafePopupWebChromeClient(safeClient)

        webView = WebView(this).apply {
            settings.apply {
                // Enable JavaScript explicitly for trusted landing pages requiring JS redirects or window.open()
                javaScriptEnabled = true
                allowFileAccess = false
                allowContentAccess = false
                // Enable multiple windows only if hosting interactive popup containers
                setSupportMultipleWindows(true)
            }
            webViewClient = safeClient
            webChromeClient = popupChromeClient
        }
        setContentView(webView)

        // Use explicit host wrapper rather than bare webView.loadUrl()
        safeClient.loadNewNavigation(webView, "https://example.com/landing")
    }

    override fun onDestroy() {
        popupChromeClient.destroyPopups()
        (webView.parent as? ViewGroup)?.removeView(webView)
        webView.destroy()
        super.onDestroy()
    }
}

Preguntas frecuentes (FAQ)

¿Por qué Android WebView muestra net::ERR_UNKNOWN_URL_SCHEME incluso cuando la aplicación de destino está instalada?
Este error ocurre cuando Chromium intenta recuperar un esquema de URL personalizado que no es HTTP a través de su pila de red en lugar de reenviarlo al Administrador de Actividades de Android. Verifique cinco puntos de control: confirme que se haya asignado un `WebViewClient` personalizado; asegúrese de que `shouldOverrideUrlLoading(WebView, WebResourceRequest)` devuelva `true` para el esquema interceptado; confirme que la estructura de la URI y el paquete de destino 1 a 1 superen su lista blanca; verifique que `startActivity(intent)` se ejecute limpiamente (capturando `ActivityNotFoundException` o configurando `<queries>` para `targetSdk >= 30` si se llama a `resolveActivity()`); y confirme que el manifiesto de la aplicación de destino declare un `<intent-filter>` coincidente con `CATEGORY_BROWSABLE`.
¿Por qué shouldOverrideUrlLoading no se activa cuando mi aplicación llama directamente a WebView loadUrl?
Por diseño del marco de trabajo de Android, `shouldOverrideUrlLoading` no se invoca para llamadas a `webView.loadUrl()` iniciadas por la aplicación ni para navegaciones HTTP `POST`. Se activa principalmente para navegaciones iniciadas por contenido web, interacciones del usuario o redirecciones de servidores HTTP 3xx compatibles. Active redirecciones de prueba desde interacciones del DOM o respuestas del servidor dentro de la página, y utilice contenedores de host explícitos (como `loadNewNavigation`) al auditar cargas iniciadas por la aplicación.
¿Por qué los enlaces target blank con esquemas personalizados fallan silenciosamente dentro de WKWebView?
Cuando un enlace web utiliza `target="_blank"` o `window.open()`, WebKit crea una solicitud de navegación de ventana nueva donde `navigationAction.targetFrame` es `nil`. Debido a que `WKWebView` no abre automáticamente pestañas nuevas, estas navegaciones pueden fallar silenciosamente a menos que la aplicación host detecte `targetFrame == nil` en `decidePolicyForNavigationAction` e implemente `WKUIDelegate.webView(_:createWebViewWith:for:windowFeatures:)` para evaluar y enrutar la solicitud bajo su política de navegación unificada.

Resumen y marco de decisiones

Resolver los fallos de redirección de enlaces profundos en WebView requiere aislar el comportamiento del motor de WebView de las políticas de navegación de la aplicación host. Al reproducir eventos de navegación en Chrome DevTools o Safari Web Inspector, confinando estrictamente el estado de la sesión emergente de Android al hilo de la interfaz de usuario mientras se combina el filtrado de solicitudes iniciales sin estado con comprobaciones de redirección 302 autorizadas por la sesión, aplicando listas permitidas estrictas de cierre por fallo IntentSanitizer y protegiendo las reservas de Enlaces Universales de iOS contra sobrescrituras asíncronas obsoletas y lanzamientos de delegados duplicados, los equipos de ingeniería pueden reducir las rutas de usuario interrumpidas y ayudar a prevenir vulnerabilidades de redirección del lado del cliente.

Una vez que se han verificado los delegados nativos a nivel de contenedor y las rutas de respaldo, los equipos de ingeniería también deben validar las páginas de destino de atribución de extremo a extremo y las cadenas de enrutamiento de lanzamiento con un solo clic utilizando plataformas como OpoInstall para confirmar la preservación de los parámetros en las transiciones del navegador a la aplicación.

Glosario de entidades

Término Definición Entidad relacionada Rol de intención de búsqueda
WebView Un componente de interfaz de usuario nativo integrado que se utiliza para renderizar páginas web dentro de una aplicación móvil. WebViewClient / WKWebView Informativo / Técnico
Esquema de URL personalizado Un prefijo de URI registrado por la aplicación (p. ej., myapp://) que permite la navegación externa hacia pantallas nativas. Intent.ACTION_VIEW Técnico / Informativo
WKNavigationDelegate El protocolo WebKit que permite que una aplicación host acepte, cancele o redirija acciones de navegación en WKWebView. decidePolicyForNavigationAction Técnico
WKUIDelegate El protocolo WebKit responsable de gestionar las solicitudes de creación de nuevas ventanas en WKWebView. createWebViewWith Técnico
WebResourceRequest El objeto de Android API 24+ que encapsula la URL, el marco, el método HTTP, la redirección y los metadatos de gestos. shouldOverrideUrlLoading Técnico
WebChromeClient La interfaz de devolución de llamada de Android WebView que maneja diálogos de JavaScript, progreso y onCreateWindow. WebViewTransport Técnico
IntentSanitizer La utilidad AndroidX Core utilizada para filtrar o validar estrictamente campos de Intent no confiables antes del envío. Defensa de redirección de intents Técnico / Seguridad
Enlaces universales El estándar de enlaces profundos basado en HTTPS de Apple que vincula dominios web verificados con aplicaciones de iOS instaladas. Dominios asociados Técnico / Informativo
Visibilidad de paquetes Filtrado del sistema operativo Android 11+ (targetSdk >= 30) que restringe qué aplicaciones instaladas puede consultar una aplicación host a través de PackageManager. Etiqueta de manifiesto <queries> Técnico
URI de Intent Una URI estructurada de Android (intent://) que codifica el paquete de destino, el esquema y las URL de respaldo del navegador. Intent.URI_INTENT_SCHEME Técnico

Línea de base de compatibilidad y estado de verificación

  • Destinos de compatibilidad previstos: Android minSdk 24, compileSdk 34/35, targetSdk 34/35 (Android 14/15), contexto de endurecimiento de redirección de intents de Android 16 (API 36), androidx.core:core:1.9.0+ (IntentSanitizer); iOS 15.0–18.0 (isInspectable limitado en iOS 16.4+), Xcode 15/16, Swift 5.9/6.0.

  • Estado de verificación:

    • Revisión estática de API y especificaciones: Completada frente a las especificaciones oficiales de Android Developers, AndroidX Core, Apple Developer, IETF RFC 3986 y OWASP MASTG.

    • Verificación de compilación y dispositivos físicos: Aún no ejecutada en este ciclo de revisión. Los equipos deben compilar y ejecutar una regresión en dispositivos físicos que cubra URL emergentes iniciales maliciosas, cadenas 302 entre dominios, saltos 302 consecutivos, creación de ventanas de iframes de terceros, Enlaces de Aplicaciones de Android (assetlinks.json), Dominios Asociados de iOS (almacenamiento en caché de AASA), cancelación asíncrona obsoleta de Enlaces Universales, cadenas de respaldo intent:// y despacho de ActivityNotFoundException antes del lanzamiento a producción.

Referencias

Share this article