So beheben Sie WebView-Umleitungsfehler unter Android und iOS

opoinstall
2026-11-19
5 min read

webview-safe-fallback-loop-prevention.webp

Wie beheben Sie WebView-Umleitungsfehler unter Android und iOS? Identifizieren Sie, ob der Fehler eine Standard-HTTPS-Navigation, ein benutzerdefiniertes URL-Schema, eine Android-intent://-URI oder eine Anfrage für ein neues Fenster betrifft, untersuchen Sie dann die Navigation über die Chrome DevTools oder den Safari Web Inspector und verfolgen Sie den entsprechenden nativen Delegaten (shouldOverrideUrlLoading, onCreateWindow, decidePolicyForNavigationAction oder createWebViewWith). Überprüfen Sie die Ziel-App-Auflösung, URI-Allowlists, Frame- und Nutzerinteraktionsrichtlinien sowie das Fallback-Routing, um Container-Fehler von Fehlern bei der Betriebssystem-Ausführung zu isolieren.

Ein WebView-Umleitungsfehler tritt auf, wenn ein eingebettetes Android-Chromium-WebView oder ein iOS-WebKit-WKWebView eine Navigationsanfrage nicht an das gewünschte Ziel weiterleiten kann. Typische Ursachen sind nicht unterstützte benutzerdefinierte URL-Schemata, unbehandelte target="_blank"-Anfragen, fehlende Paket-Sichtbarkeitsdeklarationen sowie abgelehnte oder in Schleifen laufende Fallback-Umleitungen.

Warum eingebettete Android-WebView- und iOS-WKWebView-Container Umleitungen verwerfen

Eine geschichtete WebView-Umleitungsarchitektur zeigt Fehler bei nativen Richtlinien und der Betriebssystem-Ausführung.

Bei der Fehlersuche bei Umleitungsfehlern müssen Entwicklungsteams das Verhalten der WebView-Engine (wie Chromium oder WebKit URLs, Frame-Ziele und Popup-Ereignisse analysiert) von der Richtlinie der Host-Anwendung (wie die anwendungsspezifischen WebViewClient, WebChromeClient, WKNavigationDelegate oder WKUIDelegate Nutzerinteraktionstypen, Allowlists und Übergaben an externe Apps auswerten) trennen. Eigenständige Browser enthalten integrierte URI-Dispatcher und Link-Übergabehandler, wohingegen android.webkit.WebView und das WKWebView von Apple eingebettete Rendering-Komponenten sind, die standardmäßig standardmäßige Netzwerkantworten vom Typ http:// oder https:// erwarten.

Wenn eine Webseite ein benutzerdefiniertes Schema (wie myapp://product/42) oder einen Android-intent://-Link ohne aktive Delegaten-Überschreibung auslöst, weicht das Standard-Containerverhalten zwischen den Plattformen voneinander ab:

  • Android Chromium WebView: Gemäß der WebViewClient-Spezifikation für Android fordert WebView möglicherweise den Activity Manager auf, die URL über verfügbare Systemhandler aufzulösen, wenn kein benutzerdefinierter WebViewClient zugewiesen ist. Wenn jedoch ein benutzerdefinierter WebViewClient zugewiesen ist und shouldOverrideUrlLoading für ein nicht unterstütztes benutzerdefiniertes Schema false zurückgibt, lädt WebView es weiterhin in Chromium und gibt net::ERR_UNKNOWN_URL_SCHEME aus.
  • iOS WebKit WKWebView: WebKit lehnt Nicht-HTTP-Schemata intern ab und bricht die Navigation ab, es sei denn, der WKNavigationDelegate des Hosts fängt die Anfrage ab und leitet sie an UIApplication weiter, was häufig stillschweigend fehlschlägt oder NSURLErrorUnsupportedURL auslöst.

Beachten Sie zudem, dass Apples Funktion Apps mit Smart App-Bannern bewerben ein Safari-Support-Feature ist, das für das eigenständige Surfen in Safari und nicht für eine eingebettete WKWebView-Navigations-API entwickelt wurde, und separat von Umleitungen über benutzerdefinierte In-App-URL-Schemata bewertet werden sollte.

Auf einen Blick

  • Engine-Verhalten von Host-Richtlinien trennen: Isolieren Sie, ob eine Navigation innerhalb der Web-Engine (Chromium/WebKit), innerhalb nativer Delegaten-Überschreibungen oder an der Grenze der Betriebssystem-Paketauflösung fehlgeschlagen ist.
  • Live-Umleitungen vor dem Programmieren untersuchen: Verwenden Sie Chrome DevTools (chrome://inspect) und Safari Web Inspector (isInspectable = true), um 3xx-Umleitungsketten, targetFrame-Zustände und Gesten-Flags zu erfassen.
  • Plattformgerechte URI- und Intent-Validierung durchsetzen: Binden Sie unter Android benutzerdefinierte Schemata und intent://-Ziele 1:1 über IntentSanitizer an verifizierte Pakete, ohne vom Webseiten bereitgestellte Task-Flags; validieren Sie unter iOS vollständige benutzerdefinierte URI-Strukturen (wobei auf Universal Links zurückgegriffen wird, wenn eine verifizierte App-zu-Domain-Identität erforderlich ist) und lehnen Sie doppelte Abfrageschlüssel auf beiden Plattformen ab.
  • Tiefenverteidigung für Popups und Race Conditions anwenden: Beschränken Sie den Android-Popup-Sitzungsstatus strikt auf den UI-Thread, während Sie die Callback-Grenzen über shouldInterceptRequest und shouldOverrideUrlLoading hinweg verstehen, und trennen Sie reine Richtlinienprüfungen von Nebeneffekten externer Dispatches im iOS-WKWebView mithilfe einer aktionsbasierten Deduplizierung und Navigationsgenerierungs-Token.

Häufige Ursachen und Verifizierungsschritte für WebView-Umleitungsfehler

Zuordnung beobachteter Client-Fehler zu zugrundeliegenden Container-Fehlermechanismen

Verwenden Sie die folgende Diagnosematrix, um beobachtete WebView-Symptome gängigen Plattform-Ursachen, Verifizierungsschritten und gezielten Korrekturmaßnahmen zuzuordnen:

Beobachtetes Symptom oder Fehler Zielplattform Häufige Ursache Diagnostischer Verifizierungsschritt Gezielte Korrekturmaßnahme
WebView zeigt net::ERR_UNKNOWN_URL_SCHEME an Android WebView Benutzerdefinierter WebViewClient gibt false zurück oder es fehlt eine Schema-Allowlist Untersuchen Sie request.url in shouldOverrideUrlLoading Allowlist-URIs abfangen und 1:1 paketgebundenes Intent.ACTION_VIEW ausführen
Stilles Hängenbleiben beim Tippen auf einen Link mit benutzerdefiniertem Schema iOS WKWebView WebKit bricht Nicht-HTTP-URI ab, wenn WKNavigationDelegate .allow zurückgibt Protokollieren Sie navigationAction.request.url in decidePolicyForNavigationAction Validierte Schemata über UIApplication.shared.open routen und .cancel übergeben
target="_blank" ersetzt die aktuelle Seite in WebView Android WebView setSupportMultipleWindows(false) behandelt neue Fenster als Ladevorgänge auf oberster Ebene Überprüfen Sie webView.settings.supportMultipleWindows() Aktivieren Sie setSupportMultipleWindows(true) nur, wenn separate Popup-Container benötigt werden
target="_blank" bewirkt nichts oder verwirft OAuth-302-Umleitungen Android WebView onCreateWindow fehlt oder der untergeordnete Client blockiert isRedirect-Hops ohne hasGesture() Überprüfen Sie die Protokolle für onCreateWindow, request.isRedirect und shouldInterceptRequest Ein in einer Ansicht gehostetes Popup-WebView mit UI-Thread-Sitzungsstatus und begrenzten isRedirect-Hops einbinden
Link mit target="_blank" oder window.open() bewirkt nichts iOS WKWebView Navigation in neuem Fenster setzt targetFrame == nil und erfordert WKUIDelegate Überprüfen Sie navigationAction.targetFrame == nil Erkennen Sie targetFrame == nil in decidePolicyForNavigationAction und verarbeiten Sie es über WKUIDelegate
Ziel-App ist installiert, aber die Fallback-Seite öffnet sich Android 11+ (targetSdk >= 30) Fehlende <queries>-Deklarationen führen dazu, dass resolveActivity() oder queryIntentActivities() unvollständige Ergebnisse für unsichtbare Pakete liefern Fügen Sie anwendungsspezifisches Logging um resolveActivity() hinzu und untersuchen Sie die Ausgabe über adb logcat Deklarieren Sie <queries>-Intents beim Vorab-Prüfen oder rufen Sie startActivity direkt mit einem ActivityNotFoundException-Catch auf
JavaScript-Timer-Umleitung öffnet die externe App nicht iOS / Android Automatisierter Skript-Redirect entbehrt eines Nutzerinteraktionssignals Überprüfen Sie request.hasGesture() (Android) oder navigationType (iOS) Verknüpfen Sie Umleitungen mit direkten Nutzertipps und definieren Sie eine explizite Host-Gesten-Richtlinie
Universal Link wird im WKWebView anstelle der Ziel-App geladen iOS WKWebView Browser-Kontext, Domain-Beziehung oder JS-Navigation hält das Laden in WebKit Überprüfen Sie navigationType und Host in decidePolicyForNavigationAction Rufen Sie UIApplication.shared.open mit .universalLinksOnly: true für erlaubte externe Hosts auf

Fünf-Minuten-Schnell-Checkliste für WebView-Umleitungen

  • Schritt 1: Protokollschema in DevTools überprüfen: Überprüfen Sie, ob die Seite eine https://, ein benutzerdefiniertes Schema oder eine intent://-URI ausgegeben hat, und vergewissern Sie sich, dass sie nicht durch die Content Security Policy (CSP) blockiert wurde.
  • Schritt 2: Frame-Hierarchie untersuchen: Prüfen Sie, ob der Auslöser innerhalb eines Drittanbieter-<iframe> (!isMainFrame) entstanden ist. Host-Anwendungen können von Drittanbieter-Iframes initiierte externe App-Starts absichtlich blockieren.
  • Schritt 3: Umleitungen von Timern unterscheiden: Prüfen Sie, ob eine Navigation ohne Geste eine autorisierte HTTP-3xx-Serverumleitung (request.isRedirect unter Android) im Gegensatz zu einem unaufgeforderten JavaScript-Timer ist.
  • Schritt 4: Auslöser für neue Fenster prüfen: Bestätigen Sie, ob target="_blank" oder window.open() eine Anfrage für ein neues Fenster erstellt hat (targetFrame == nil unter iOS oder onCreateWindow unter Android).
  • Schritt 5: Betriebssystem-Paketauflösung verifizieren: Bestätigen Sie für Apps, die auf API 30+ unter Android 11+ abzielen, ob Pre-Flight-resolveActivity()-Aufrufe aufgrund fehlender <queries>-Deklarationen fehlschlagen.

Der folgende Diagnose-Workflow veranschaulicht den sequenziellen Triage-Pfad zur Isolierung von Container-Umleitungsfehlern:

[WebView-Navigationsfehler]
          │
          ▼
[URL + Netzwerk + Konsole über Chrome DevTools / Safari Web Inspector untersuchen]
          │
          ▼
[Navigationsquelle identifizieren]
          │
          ├── App loadUrl() oder HTTP POST
          │       │
          │       └── shouldOverrideUrlLoading wird NICHT aufgerufen; Aufrufpfad auf Host-Seite untersuchen
          │
          ├── target="_blank" oder window.open()
          │       │
          │       ├── Android (multiple-windows=false) ──> Ersetzt aktuelle WebView-Seite
          │       ├── Android (multiple-windows=true)  ──> onCreateWindow + shouldInterceptRequest untersuchen
          │       └── iOS (targetFrame == nil)         ──> WKNavigationDelegate + WKUIDelegate untersuchen
          │
          ├── HTTP / HTTPS Navigation
          │       │
          │       └── Host- und Port-Allowlist, 3xx-Umleitungen, Universal Link oder App-Link-Übereinstimmung untersuchen
          │
          └── Benutzerdefiniertes Schema oder Chrome intent://
                  │
                  ├── Nutzerinteraktion + Main-Frame-Richtlinie auswerten
                  ├── Vollständige URI-Struktur verifizieren (Schema, Host, Port, Pfad, keine doppelten Abfrageschlüssel)
                  ├── Intent bereinigen (explizite Komponenten ablehnen, 1:1-Paket verifizieren, Null Webpage-Flags)
                  ├── Ziel-App-Auflösung prüfen (<queries> / ActivityNotFoundException)
                  └── Fallback-Pfad + Abfrage-Allowlist + mononotische Ketten-Sicherung (elapsedRealtime) validieren

So untersuchen Sie WebView-Navigationsereignisse mit Remote-Debugging-Tools

Aktivieren des Remote-Debuggings über Chrome DevTools und ADB Logcat unter Android

Bevor Sie native Delegaten ändern, überprüfen Sie, ob die geladene Webseite die erwartete Umleitung ausgibt. Gemäß dem Leitfaden für das Remote-Debugging von Android Chrome DevTools sollten Sie das Remote-Debugging von WebViews in Entwicklungswuilds explizit aktivieren, indem Sie ApplicationInfo.FLAG_DEBUGGABLE untersuchen und WebView.setWebContentsDebuggingEnabled(true) aufrufen. Liefern Sie niemals aktivierte Debugging-Funktionen in Produktionsversionen aus:

// Android - WebView-Debugging ausschließlich in debug-fähigen Builds aktivieren
if (applicationInfo.flags and ApplicationInfo.FLAG_DEBUGGABLE != 0) {
    WebView.setWebContentsDebuggingEnabled(true)
}

Verbinden Sie das Gerät über USB, öffnen Sie chrome://inspect/#devices in Chrome auf dem Desktop und überwachen Sie den Tab Network mit aktiviertem Preserve log. Filtern Sie gleichzeitig native Laufzeitprotokolle über adb logcat, um ActivityNotFoundException, SecurityException oder benutzerdefinierte Wrapper-Protokolle zu erfassen. Beachten Sie, dass Veraltungswarnungen für die ältere shouldOverrideUrlLoading(WebView, String)-Signatur während der Android Studio- / Gradle-Kompilierung und nicht in der Laufzeit von adb logcat angezeigt werden:

# Terminal - Logcat nach benutzerdefinierten WebView-Tags und Intent-Auflösung des ActivityTaskManager filtern
adb logcat -s "WebViewDebug" "ActivityTaskManager" "PackageManager"

Konfigurieren von isInspectable und Einbinden von Safari Web Inspector und Xcode Console unter iOS

Beginnend mit iOS 16.4 und macOS 13.3 verlangt Apple, dass Anwendungen sich über WKWebView.isInspectable anmelden, was standardmäßig auf false gesetzt ist. Aktivieren Sie webView.isInspectable = true innerhalb von #if DEBUG-Blöcken:

// iOS - Safari Web Inspector-Opt-in auf Debug-Builds ab iOS 16.4 aktivieren
#if DEBUG
if #available(iOS 16.4, *) {
    webView.isInspectable = true
}
#endif

Navigieren Sie auf dem physischen iOS-Gerät zu Einstellungen > Apps > Safari > Erweitert (bei älteren iOS-Versionen Einstellungen > Safari > Erweitert) und aktivieren Sie den Web Inspector. Stellen Sie eine Verbindung über USB her, öffnen Sie das Menü Entwickeln von Desktop-Safari und überwachen Sie die Xcode Console gleichzeitig auf native Ausgaben zum Abschluss von decidePolicyForNavigationAction, createWebViewWith und UIApplication.shared.open.

Android WebView und iOS WKWebView verwenden unterschiedliche native Navigations- und Popup-Handler.

Beheben von stillen Neufenster-Verwerfungen und fehlenden Nutzergesten in iOS WKWebView

Trennen der Richtlinienbewertung von Nebeneffekten über WKNavigationDelegate und WKUIDelegate hinweg

Wenn ein Weblink target="_blank" oder window.open() angibt, erstellt WebKit eine Navigationsanfrage für ein neues Fenster, bei der navigationAction.targetFrame den Wert nil hat und sowohl WKNavigationDelegate als auch WKUIDelegate einbezieht. Wenn die Host-App webView(_:createWebViewWithConfiguration:for:windowFeatures:) nicht implementiert, kann WebKit kein sekundäres WebView erzeugen, und Navigationen schlagen möglicherweise stillschweigend fehl.

Um doppelte Starts externer Apps oder doppelt inkrementierte Generationen-Token zu verhindern, wenn beide Delegaten eine Anfrage untersuchen, trennen Sie die reine Richtlinienbewertung (evaluateNavigationPolicy) von den Ausführungs-Nebeneffekten und deduplizieren Sie nach der spezifischen WKNavigationAction-Instanz (ObjectIdentifier(navigationAction)), anstatt sich ausschließlich auf eine grobe Zeitschwelle zu verlassen, die absichtliche, schnelle Wiederholungsklicks eines Benutzers unterdrücken könnte. Bewerten Sie navigationAction.targetFrame == nil direkt in decidePolicyForNavigationAction: Wenn die Bewertung einen Plan für die externe Übergabe zurückgibt, führen Sie diesen einmal aus (und zeichnen die WKNavigationAction-Kennung auf) und übergeben Sie .cancel; wenn sie .allowInWebView für eine erlaubte Popup-URL zurückgibt, übergeben Sie .allow, damit createWebViewWith das Popup sicher lädt. Überprüfen Sie immer die genaue Delegaten-Callback-Reihenfolge auf den Ziel-iOS-Versionen.

Universal-Link-Kontext, Asynchronitäts-Sicherheit und Identität benutzerdefinierter Schemata

Die Universal-Link-Übergabe hängt vom Quell-Browser-Kontext, der Domain-Beziehung und der Konfiguration der zugehörigen Domains (verifiziert über die apple-app-site-association-Datei des Zielservers) ab. Apples technischer Hinweis TN3155: Debugging Universal Links dokumentiert, wie die Navigation auf derselben Domain in Safari bevorzugt im Browser verbleibt, während unterschiedliche Subdomains die Berechtigung ändern. Testen Sie das Verhalten zugehöriger Domains immer auf Ziel-iOS-Releases innerhalb von WKWebView.

Wenn Sie UIApplication.shared.open(url, options: [.universalLinksOnly: true]) aufrufen, schützen Sie sich vor asynchronen Navigations-Race-Conditions: Wenn ein Benutzer einen nachfolgenden Main-Frame-Navigationsversuch unternimmt, während das System die Universal-Link-Übergabe verarbeitet, könnte ein nicht geschützter Completion-Handler, der false zurückgibt, den neueren Navigationsstatus des Benutzers überschreiben. Erhöhen Sie ein mononotisches activeNavigationGeneration-Token bei jeder neuen Main-Frame-Navigationsbewertung (einschließlich blockierter oder umgeleiteter Versuche), sodass jedes ausstehende vorherige asynchrone Fallback sofort ungültig wird, und überprüfen Sie self.activeNavigationGeneration == requestGeneration neben self.isViewLoaded && self.view.window != nil, bevor Sie Fallback-URLs neu laden.

Beachten Sie zwei strikte Sicherheitsgrenzen:

  • Klassifizierung von WKNavigationType: Gemäß der WKNavigationType-Dokumentation von Apple stellt formSubmitted eine Anfrage zum Senden eines Formulars anstelle eines Link-Tipps dar, und Seitenskripte können Formulare programmgesteuert senden. Beschränken Sie die Übergabe externer Apps auf von WebKit klassifizierte .linkActivated-Ereignisse in Kombination mit sourceFrame.isMainFrame und vollständigen URI-Allowlists, anstatt .linkActivated als isoliertes kryptografisches Gesten-Token zu behandeln.
  • Einzigartigkeit benutzerdefinierter Schemata und Parameterverschmutzung: Gemäß Apples Leitfaden zum Definieren eines benutzerdefinierten URL-Schemas für Ihre App können mehrere Apps dasselbe benutzerdefinierte Schema beanspruchen. isAllowedCustomURL(_:) validiert die URI-Struktur (Schema, Host, Standardport nil, Pfadmuster, keine Userinfo/Fragment und Ablehnung doppelt vorhandener Abfrageschlüssel), nicht jedoch die Identität der Ziel-Bundle-ID. Verwenden Sie domainverifizierte Universal Links, wann immer eine App-Identitätsbindung erforderlich ist.

Haftungsausschluss zur Referenzarchitektur: Die folgende Implementierung ist eine defensive Referenzarchitektur. Validieren Sie die API-Verfügbarkeit, die Delegaten-Reihenfolge und das Lifecycle-Verhalten anhand der genauen AndroidX- und iOS-Versionen, die von Ihrer Anwendung verwendet werden.

// iOS - WebViewContainerController.swift
// Referenzarchitektur: Kompilieren und testen Sie gegen Ihre spezifischen Projektziele (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!

    // Explizite Allowlist für externe benutzerdefinierte URL-Schemata, Hosts und Abfrageschlüssel
    private let allowedCustomSchemes: Set<String> = ["myapp", "partnerapp"]
    private let allowedCustomHosts: Set<String> = ["open", "product", "promo"]
    private let allowedCustomQueryKeys: Set<String> = ["id", "ref", "promo"]

    // Explizite Allowlist für HTTPS-Hosts, die innerhalb des primären WebView-Containers erlaubt sind
    private let allowedWebHosts: Set<String> = [
        "example.com",
        "m.example.com",
        "links.example.com"
    ]

    // Isolierte Allowlists speziell für untergeordnete Popup-Fenster (target="_blank")
    private let allowedPopupHosts: Set<String> = ["example.com", "auth.example.com"]
    private let allowedPopupPathPrefixes: [String] = ["/oauth", "/popup", "/window"]

    // Externe Universal-Link-Hosts, die bei Link-Aktivierung eine native App-Übergabe versuchen
    private let externalUniversalLinkHosts: Set<String> = ["links.example.com"]

    // Monotones Navigationsgenerierungs-Token, das bei jedem neuen Main-Frame-Navigationsversuch inkrementiert wird
    private var activeNavigationGeneration: UInt64 = 0

    // Aktionsbasierte Deduplizierung zur Verhinderung doppelter Dispatches für dieselbe WKNavigationAction
    private var dispatchedActionIDs: [ObjectIdentifier] = []
    private let maxTrackedActionIDs = 16

    // Monotone Betriebszeit-TTL-geschützter Bypass-Cache, indiziert nach normalisiertem Universal-Link-Schlüssel
    private var bypassedUniversalLinkKeys: [String: TimeInterval] = [:]
    private let maxBypassedKeys = 10
    private let bypassTTLSeconds: TimeInterval = 300
    // Passen Sie signifikante Abfrageschlüssel an die tatsächlichen Routing-Parameter Ihrer Anwendung an
    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)

        // Inkrementieren Sie das Generationen-Token bei jedem Main-Frame-Navigationsversuch (einschließlich blockierter Versuche),
        // sodass ein ausstehendes vorheriges asynchrones Universal-Link-Fallback sofort ungültig wird.
        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 (Behandelt target="_blank" und 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: - Reine Navigationsrichtlinienbewertung (Keine Nebeneffekte)

    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. Benutzerdefinierte URL-Schemata auswerten, die nicht HTTP/HTTPS sind
        // Hinweis: Die Allowlist für benutzerdefinierte Schemata validiert die URI-Struktur; sie kann keine Ziel-Bundle-ID-Identität garantieren.
        if scheme != "http" && scheme != "https" {
            guard isMainFrame, isLinkActivated, isAllowedCustomURL(url) else {
                return .block
            }
            return .launchCustomScheme(url)
        }

        // 2. Nur HTTPS, Standardport (nil oder 443) und Host-Allowlists erzwingen
        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. Universal-Link-Übergaben für bestimmte externe Hosts bei Link-Aktivierung bewerten
        if let host = targetHost,
           externalUniversalLinkHosts.contains(host),
           isMainFrame,
           isLinkActivated,
           let loopKey = universalLinkLoopKey(for: url),
           !isBypassedKeyActive(loopKey) {
            return .attemptUniversalLink(url)
        }

        return .allowInWebView
    }

    // MARK: - Aktionsbasierte, deduplizierte Ausführung externer Dispatches

    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
                // Überprüfen Sie den Ansichtslebenszyklus UND das Generationen-Token, um veraltete Überschreibungen durch asynchrone Fallbacks zu verhindern
                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] Fehler beim Starten des benutzerdefinierten Schemas (App ist möglicherweise nicht installiert)")
                }
            }
        }
    }

    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, // Explizite Ports für benutzerdefinierte Schemata ablehnen
              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
    }
}

Beheben von ERR_UNKNOWN_URL_SCHEME und Paket-Sichtbarkeitsfehlern in Android WebView

Veraltete Callbacks, hasGesture() und POST-Grenzen

Android hat shouldOverrideUrlLoading(WebView, String) in API-Level 24 zugunsten von shouldOverrideUrlLoading(WebView, WebResourceRequest) als veraltet eingestuft. WebResourceRequest stellt isForMainFrame, isRedirect und hasGesture() bereit. Beachten Sie zwei offizielle Plattform-Einschränkungen: shouldOverrideUrlLoading wird nicht für vom Host initiierte webView.loadUrl()-Aufrufe oder HTTP-POST-Navigationen aufgerufen, und hasGesture() kann für legitime asynchrone JavaScript-Umleitungen oder serverseitige 302-Hops false zurückgeben.

Tiefenverteidigungs-Popup-Handhabung und Thread-Isolierung in WebChromeClient.onCreateWindow

Das Android-Popup-Verhalten hängt von WebSettings.setSupportMultipleWindows ab. Wenn Ihre App keine interaktiven Popups erfordert, verhindert das Beibehalten von setSupportMultipleWindows(false) (oder das Zurückgeben von false aus onCreateWindow), dass Drittanbieter-Iframes sekundäre Container öffnen – oder öffnet verifizierte Ziele über einen expliziten, vom Host gesteuerten Einstiegspunkt.

Wenn setSupportMultipleWindows(true) aktiviert ist, liefert WebChromeClient.onCreateWindow die Ziel-URL nicht in ihrer Callback-Signatur, und kein einzelner Callback deckt jeden Navigationsvektor ab. Das Verständnis des genauen Thread-Modells und der Callback-Grenzen ist für einen Referenzansatz der Tiefenverteidigung unerlässlich:

  • shouldOverrideUrlLoading (UI-Thread – Besitzer von Navigations- und Sitzungsstatus): Läuft ausschließlich auf dem UI-Thread und besitzt den gesamten veränderbaren Popup-Sitzungsstatus (isInitialTransportLoad, isAuthorizedPopupSession, popupRedirectHops und popupChainStartMs). Erst wenn ein verifizierter anfänglicher Ladevorgang oder eine direkte Nutzergeste mit policy.isAllowedPopupUri übereinstimmt, autorisiert shouldOverrideUrlLoading die Sitzung für nachfolgende begrenzte HTTP-302-Umleitungen (request.isRedirect), wodurch sichergestellt wird, dass Umleitungsketten sich auf eine autorisierte Sitzung zurückverfolgen lassen, anstatt beliebigen Umleitungen zu vertrauen.
  • shouldInterceptRequest (Hintergrund-WebView-E/A-Thread – Zustandsloser, schreibgeschützter Wächter): Läuft auf einem Nicht-UI-WebView-Thread. Da er niemals den UI-Thread-Sitzungsstatus verändern darf, fungiert er streng als zustandslose, schreibgeschützte Richtlinienprüfung für safeClient.policy (blockiert Main-Frame-HTTP/HTTPS-Anfragen, die isAllowedPopupUri nicht bestehen, und leitet disposeActivePopup() an den Haupt-Thread weiter). Beachten Sie, dass shouldInterceptRequest gemäß der Android-Dokumentation nur für die ursprüngliche Ressourcen-URL aufgerufen wird, nicht für nachfolgende HTTP-302-Umleitungs-URLs; nachfolgende Umleitungs-URLs müssen von shouldOverrideUrlLoading bewertet werden.
  • onPageStarted (UI-Thread – Fallback-Prüfung beim Navigationsstart): Wird ausgeführt, wenn das Laden des Main-Frames beginnt (nicht als Filter vor der Navigation). Es aktualisiert das Banner für den sichtbaren Ursprung zur Transparenz für den Benutzer und bietet eine Fallback-Prüfung beim Navigationsstart, die stopLoading() und disposeActivePopup() aufruft, wenn ein nicht genehmigtes Ziel geladen wird.

Testen Sie bösartige initiale URLs, domänenübergreifende HTTP-302-Ketten, aufeinanderfolgende 302-Umleitungen, target="_blank", window.open() und Drittanbieter-Iframe-Auslöser immer an physischen Ziel-WebView-Builds.

Paketsichtbarkeit ab Android 11+ und veraltete Leitlinien für canOpenURL

Gemäß den Android-Paketsichtbarkeitsregeln erhalten Anwendungen, die unter Android 11 (API-Level 30) oder höher ausgeführt werden und auf API-Level 30 oder höher abzielen (targetSdk >= 30), null oder leere Ergebnisse von intent.resolveActivity() oder queryIntentActivities(), es sei denn, Ziel-Apps sind unter <queries> in AndroidManifest.xml deklariert. Android empfiehlt, startActivity(intent) direkt innerhalb eines try/catch für ActivityNotFoundException und SecurityException aufzurufen, anstatt <queries> zu erweitern.

Unter iOS hat Apple UIApplication.canOpenURL(_:) als veraltet eingestuft und empfiehlt, UIApplication.shared.open(_:options:completionHandler:) direkt zu versuchen und eventuelle Fehler im Completion-Handler zu behandeln (oder zu Universal Links zu migrieren, um die Vorab-Validierung von Schemata zu entfernen). LSApplicationQueriesSchemes in Info.plist ist nur erforderlich, wenn älterer Code weiterhin canOpenURL(_:) aufruft, während open(_:options:completionHandler:) die Deklaration von Schemata in Info.plist nicht erfordert. Sowohl <queries> als auch LSApplicationQueriesSchemes steuern die Abfragesichtbarkeit – sie sind keine Sicherheits-Allowlists für die Validierung nicht vertrauenswürdiger Web-URIs.

<!-- Manifest-Fragment: Fügen Sie <queries> in Ihr bestehendes AndroidManifest.xml ein -->
<!-- Erforderlich für targetSdk >= 30 unter Android 11+ NUR, wenn resolveActivity oder queryIntentActivities aufgerufen wird -->
<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: Unter dem Root-<dict> in Info.plist einfügen -->
<!-- Legacy: Erforderlich unter iOS NUR beim Aufruf der veralteten UIApplication.shared.canOpenURL; open(_:options:completionHandler:) erfordert diesen Schlüssel nicht -->
<key>LSApplicationQueriesSchemes</key>
<array>
    <string>myapp</string>
    <string>partnerapp</string>
</array>

So parsen Sie Chrome-Intent-URIs sicher und verhindern Umleitungsschleifen

Absicherung von Intent.parseUri gegen Intent-Redirection-Angriffe

Android-intent://-URIs codieren ein Zielschema, ein Paket und eine Fallback-URL (S.browser_fallback_url). Das Parsen nicht vertrauenswürdiger Web-URIs über Intent.parseUri(rawUri, Intent.URI_INTENT_SCHEME) führt zu Risiken einer Intent-Umleitung, die im Android-Sicherheitsleitfaden zur Intent-Umleitung und im OWASP Mobile Application Security Testing Guide detailliert beschrieben sind. Selbst wenn Android 16 (API 36) eine plattformweite Standardhärtung hinzufügt, müssen Anwendungen eine strikte Validierung erzwingen, bevor sie Intents ausführen.

Eine geschichtete URI-Validierung blockiert unsichere WebView-Intents vor der Ausführung externer Anwendungen.

So implementieren Sie eine Fail-Closed-Validierung mithilfe von AndroidX IntentSanitizer (androidx.core:core:1.9.0+ oder androidx.core:core-ktx:1.9.0+, das androidx.core:core bündelt), ohne Builder-Konflikte bezüglich gegenseitiger Ausschlüsse zwischen allowAnyComponent() und Paket-/Komponenten-Allowlist-Methoden auszulösen:

  • Prüfungen vor der Bereinigung: Lehnen Sie Intents mit nicht nullen component- oder selector-Feldern sofort ab (parsedIntent.component != null || parsedIntent.selector != null). Extrahieren und entfernen Sie browser_fallback_url vor der Bereinigung und verifizieren Sie nativ, dass parsedIntent.data?.scheme 1:1 auf parsedIntent.package`` über customSchemeTargetPackages abbildet (wobei sichergestellt wird, dass myapp:// sich strikt in com.example.target auflöst, niemals in ein anderes Partnerpaket).
  • Ausführung des Sanitizers: Setzen Sie parsedIntent.package` = null` auf der nicht vertrauenswürdigen Kopie temporär zurück, führen Sie IntentSanitizer.Builder().allowAnyComponent().allowAction(Intent.ACTION_VIEW).allowCategory(Intent.CATEGORY_BROWSABLE).allowData { ... }.build().sanitizeByThrowing(parsedIntent) aus (null vom Webseiten bereitgestellte Task-Flags) und weisen Sie das validierte expectedPackage und CATEGORY_BROWSABLE dem bereinigten, host-eigenen Intent vor Zusicherungen nach der Bereinigung neu zu.
  • Kontextbewusste Start-Flags: Injizieren Sie Intent.FLAG_ACTIVITY_NEW_TASK im nativen Dispatcher (launchWithContextSafety) nur dann, wenn view.context !is Activity. Bevorzugen Sie zur Verifizierung der Domain-zu-App-Zuordnung verifizierte HTTPS Android App Links (assetlinks.json).

Verhindern unendlicher Fallback-Schleifen mit monotonem Kettenstatus

Wenn startActivity eine ActivityNotFoundException auslöst, validieren Sie browser_fallback_url mit einer dedizierten isAllowedFallbackUri(uri)-Prüfung (strikt HTTPS, Standardport, verifizierter Host, explizite Fallback-Pfadpräfixe, keine doppelten Abfrageschlüssel und keine Fragmente). Lehnen Sie explizite Portdarstellungen für benutzerdefinierte Schemata ab, indem Sie sowohl uri.port == -1 als auch !uri.encodedAuthority.orEmpty().contains(":") verifizieren.

Verfolgen Sie Fallback-Ketten mithilfe von SystemClock.elapsedRealtime() (um Sprünge der Wanduhrzeit System.currentTimeMillis() zu vermeiden), isolieren Sie Ketten über fallbackLoopKey() (nicht vollständige IETF RFC 3986-Kanonisierungen), setzen Sie den Status über einen expliziten loadNewNavigation(webView, url)-Host-Wrapper zurück und leiten Sie Popup-Fallbacks über onPopupFallbackHandoff an den primären Container weiter, sodass unbefugte Domains niemals in einem Popup-Dialog geladen werden.

Haftungsausschluss zur Referenzarchitektur: Die folgende Implementierung ist eine defensive Referenzarchitektur. Validieren Sie die API-Verfügbarkeit, die Delegaten-Reihenfolge und das Lifecycle-Verhalten anhand der genauen AndroidX- und iOS-Versionen, die von Ihrer Anwendung verwendet werden.

// Android - SafeWebViewModules.kt
// Referenzarchitektur: Kompilieren und testen Sie gegen Ihre spezifischen Projektziele
// Erfordert androidx.core:core:1.9.0+ (oder androidx.core:core-ktx:1.9.0+) für IntentSanitizer; zielt auf 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. Richtlinienmodul (Immutabel / Threadsicher für schreibgeschützten Zugriff von E/A- & 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"),
    // Isolierte Allowlists explizit für Popup-Fenster; unterscheidet sich von allgemeinen 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
        }

        // Abfrageschlüssel validieren, Wertesyntax erzwingen und doppelte Schlüssel ablehnen
        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

        // Netzwerkports strikt ablehnen, indem sowohl uri.port == -1 als auch das Fehlen des Authority-Doppelpunkts geprüft werden
        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

        // Abfrageschlüssel validieren, Wertesyntax erzwingen und doppelte Schlüssel ablehnen
        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: Monotoner Kettenstatus basierend auf verstrichener Zeit (Isoliert aktive Kette von wiederholten Sitzungen)
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
    }

    // Anwendungsspezifischer Schleifenschlüssel, der den Standard-HTTPS-Port normalisiert und signifikante Abfrageschlüssel beibehält
    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 (Nur UI-Thread)
class SafeRedirectWebViewClient(
    val policy: CustomUriPolicy = CustomUriPolicy(),
    val loopGuard: FallbackLoopGuard = FallbackLoopGuard(),
    private val onPopupFallbackHandoff: ((fallbackUri: Uri) -> Unit)? = null
) : WebViewClient() {

    // Explizite, vom Host initiierte Navigations-API, die den Fallback-Kettenstatus vor loadUrl() zurücksetzt
    fun loadNewNavigation(webView: WebView, url: String) {
        val targetUri = Uri.parse(url)
        if (!policy.isAllowedWebUri(targetUri)) {
            Log.w("WebViewDebug", "Vom Host initiierte Navigation zu nicht vertrauenswürdiger URL blockiert")
            return
        }
        loopGuard.resetChain()
        webView.loadUrl(url)
    }

    // Dedizierter Fallback-Loader mit interner Validierung unter Beibehaltung des aktiven Kettenstatus
    fun loadFallbackNavigation(webView: WebView, fallbackUri: Uri) {
        if (!policy.isAllowedFallbackUri(fallbackUri)) {
            Log.w("WebViewDebug", "Nicht vertrauenswürdiger Fallback-Navigationsversuch blockiert")
            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. HTTPS-Only & Web-Host-Allowlist bei allen HTTP/HTTPS-Navigationen erzwingen
        if (scheme == "http" || scheme == "https") {
            if (!policy.isAllowedWebUri(targetUri)) {
                Log.w("WebViewDebug", "Nicht-HTTPS-, benutzerdefinierter Port- oder nicht vertrauenswürdiger Web-Host blockiert")
                return true
            }
            if (hasUserGesture && isForMainFrame) {
                loopGuard.resetChain()
            }
            return false
        }

        // 2. Main-Frame- und Nutzergesten-Einschränkungen bei Starts externer Apps erzwingen
        if (!isForMainFrame || !hasUserGesture) {
            Log.w(
                "WebViewDebug",
                "Schema außerhalb des Main-Frames oder ohne Geste blockiert: $scheme"
            )
            return true
        }

        // 3. Chrome intent://-URIs parsen und im Fehlerfall (Fail-Closed) bereinigen
        if (scheme == "intent") {
            return handleIntentUri(view, targetUri.toString(), isPopupContext)
        }

        // 4. Erlaubte benutzerdefinierte URL-Schemata validieren und explizit an 1:1 verifizierte Zielpakete binden
        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. Alle nicht anerkannten Schemata blockieren
        Log.w("WebViewDebug", "Unbekanntes URL-Schema blockiert: $scheme")
        return true
    }

    // UI-Thread-Navigationsbewerter für untergeordnete Popup-WebViews, der 302-Umleitungen an autorisierte Sitzungen bindet
    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", "Subframe-HTTPS-Navigation innerhalb des Popups blockiert")
                return true
            }
            if (!policy.isAllowedPopupUri(targetUri)) {
                Log.w(
                    "WebViewDebug",
                    "Nicht vertrauenswürdiger Popup-HTTPS-Host oder -Pfad-Navigation blockiert"
                )
                return true
            }
            // Sitzung nur im UI-Thread autorisieren, wenn der erste Ladevorgang oder Tippen des Nutzers der Allowlist entspricht
            if (isInitialTransportLoad || hasUserGesture) {
                onAuthorizedInitialSession()
                return false
            }
            // Begrenzte serverseitige 302-Umleitungen NUR für zuvor autorisierte Popup-Sitzungen zulassen
            if (isRedirect && isAuthorizedPopupSession && canProceedPopupRedirect()) {
                return false
            }

            Log.w(
                "WebViewDebug",
                "Nicht autorisierte Umleitung oder Popup-Navigation ohne Geste blockiert"
            )
            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", "Fehlerhafte Intent-URI-Syntax")
            return true
        }

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

        // 1:1-Bindung: Zielschema extrahieren und nativ gegen erwartetes Zielpaket validieren
        val dataUri = parsedIntent.data ?: return true
        val targetScheme = dataUri.scheme?.lowercase() ?: return true
        val expectedPackage = policy.customSchemeTargetPackages[targetScheme] ?: run {
            Log.w("WebViewDebug", "Intent mit nicht zugeordnetem benutzerdefiniertem Schema blockiert: $targetScheme")
            return true
        }

        val rawPackage = parsedIntent.`package`
        if (rawPackage != expectedPackage) {
            Log.w("WebViewDebug", "Intent-Paket-Nichtübereinstimmung blockiert: erwartet $expectedPackage")
            return true
        }

        // Vom Webseiten angegebene explizite Komponenten und Selektoren sofort ablehnen
        if (parsedIntent.component != null || parsedIntent.selector != null) {
            Log.w("WebViewDebug", "Intent mit expliziter Komponente oder Selektor blockiert")
            return true
        }

        // Verifiziertes Paket vor dem Aufruf von IntentSanitizer mit allowAnyComponent() temporär löschen,
        // um Builder-Beschränkungen bezüglich gegenseitiger Ausschlüsse zu vermeiden und gleichzeitig nicht vertrauenswürdige Flags/Extras strikt abzulehnen.
        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 hat SecurityException für unzulässige Felder oder Flags ausgelöst")
            return true
        } catch (e: IllegalArgumentException) {
            Log.w("WebViewDebug", "IntentSanitizer hat ungültige Intent-Argumente abgelehnt")
            return true
        }

        // Verifiziertes Zielpaket + vom Host erzwungene Kategorie + Zusicherungen nach der Bereinigung erneut binden
        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", "Intent-Zusicherungen nach der Bereinigung fehlgeschlagen")
            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", "Nicht vertrauenswürdige oder schleifenförmige Fallback-URL blockiert")
                }
            }
        } catch (e: SecurityException) {
            Log.w(
                "WebViewDebug",
                "SecurityException hat den Start des Intents blockiert"
            )
        }
        return true
    }

    private fun launchIntentSafely(view: WebView, intent: Intent) {
        try {
            launchWithContextSafety(view, intent)
        } catch (e: ActivityNotFoundException) {
            Log.i(
                "WebViewDebug",
                "Keine installierte Anwendung verarbeitet das Zielpaket/-schema"
            )
        } catch (e: SecurityException) {
            Log.w(
                "WebViewDebug",
                "SecurityException hat den Start des benutzerdefinierten Schemas blockiert"
            )
        }
    }

    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-verwalteter Popup-WebChromeClient (Strikter UI-Thread-Sitzungsstatus & zustandsloser Hintergrundwächter)
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 = "Ziel wird geladen..."
        }
        popupRoot.addView(originBanner)

        // Alle folgenden Popup-Sitzungsstatusvariablen werden ausschließlich im UI-Thread gelesen und verändert
        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: Verwaltet Navigation, Umleitung und Sitzungsautorisierungsstatus
                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
                }

                // Hintergrund-WebView-E/A-Thread: Streng zustandslose, schreibgeschützte Richtlinienprüfung.
                // Verändert niemals den UI-Thread-Sitzungsstatus; deckt nur die ursprüngliche Ressourcen-URL ab (nicht nachfolgende 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", "Nicht genehmigte Popup-Main-Frame-Anfrage in shouldInterceptRequest blockiert")
                            childView.post { disposeActivePopup() }
                            return WebResourceResponse("text/plain", "utf-8", ByteArrayInputStream(ByteArray(0)))
                        }
                    }
                    return super.shouldInterceptRequest(childView, request)
                }

                // UI-Thread: Fallback-Prüfung beim Navigationsstart & Anzeige des Ursprungs (kein Filter vor der Navigation)
                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", "Fallback-Prüfung beim Navigationsstart hat nicht genehmigte Popup-URL beendet")
                        childView.stopLoading()
                        disposeActivePopup()
                        return
                    }
                    isAuthorizedPopupSession = true
                    val scheme = uri.scheme?.lowercase() ?: "https"
                    val host = uri.host?.lowercase() ?: "Unknown"
                    originBanner.text = "Ursprung: $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. Vollständiges Beispiel für Host-Aktivitätsregistrierung & Lifecycle-Bereinigung (JavaScript im Haupt-WebView aktiviert)
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 {
                // JavaScript für vertrauenswürdige Zielseiten, die JS-Umleitungen oder window.open() erfordern, explizit aktivieren
                javaScriptEnabled = true
                allowFileAccess = false
                allowContentAccess = false
                // Mehrere Fenster nur dann aktivieren, wenn interaktive Popup-Container gehostet werden
                setSupportMultipleWindows(true)
            }
            webViewClient = safeClient
            webChromeClient = popupChromeClient
        }
        setContentView(webView)

        // Expliziten Host-Wrapper anstelle von barem webView.loadUrl() verwenden
        safeClient.loadNewNavigation(webView, "https://example.com/landing")
    }

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

Häufig gestellte Fragen (FAQ)

Warum zeigt Android WebView net::ERR_UNKNOWN_URL_SCHEME an, obwohl die Ziel-App installiert ist?
Dieser Fehler tritt auf, wenn Chromium versucht, ein benutzerdefiniertes Nicht-HTTP-URL-Schema über seinen Netzwerk-Stack abzurufen, anstatt es an den Activity Manager von Android weiterzuleiten. Überprüfen Sie fünf Kontrollpunkte: Bestätigen Sie, dass ein benutzerdefinierter `WebViewClient` zugewiesen ist; stellen Sie sicher, dass `shouldOverrideUrlLoading(WebView, WebResourceRequest)` für das abgefangene Schema `true` zurückgibt; bestätigen Sie, dass die URI-Struktur und das 1:1-Zielpaket Ihre Allowlist passieren; überprüfen Sie, ob `startActivity(intent)` sauber ausgeführt wird (fangen Sie `ActivityNotFoundException` ab oder konfigurieren Sie `<queries>` für `targetSdk >= 30`, falls `resolveActivity()` aufgerufen wird); und bestätigen Sie, dass das Manifest der Ziel-App einen übereinstimmenden `<intent-filter>` mit `CATEGORY_BROWSABLE` deklariert.
Warum wird shouldOverrideUrlLoading nicht ausgelöst, wenn meine App WebView.loadUrl direkt aufruft?
Gemäß dem Entwurf des Android-Frameworks wird `shouldOverrideUrlLoading` für von der App initiierte `webView.loadUrl()`-Aufrufe oder HTTP-`POST`-Navigationen nicht aufgerufen. Es wird hauptsächlich für Navigationen ausgelöst, die durch Web-Inhalte, Nutzerinteraktionen oder unterstützte HTTP-3xx-Serverumleitungen initiiert wurden. Lösen Sie Testumleitungen über DOM-Interaktionen oder Serverantworten innerhalb der Seite aus und verwenden Sie explizite Host-Wrapper (wie `loadNewNavigation`), wenn Sie von der App initiierte Ladevorgänge überprüfen.
Warum schlagen Target-Blank-Links mit benutzerdefinierten Schemata in WKWebView stillschweigend fehl?
Wenn ein Weblink `target="_blank"` oder `window.open()` verwendet, erstellt WebKit eine Navigationsanfrage für ein neues Fenster, bei der `navigationAction.targetFrame` den Wert `nil` hat. Da `WKWebView` neue Tabs nicht automatisch öffnet, schlagen diese Navigationen möglicherweise stillschweigend fehl, es sei denn, die Host-App erkennt `targetFrame == nil` in `decidePolicyForNavigationAction` und implementiert `WKUIDelegate.webView(_:createWebViewWith:for:windowFeatures:)`, um die Anfrage im Rahmen ihrer einheitlichen Navigationsrichtlinie auszuwerten und zu routen.

Zusammenfassung und Entscheidungsrahmen

Das Beheben von Fehlern bei Deep-Linking-Umleitungen in WebViews erfordert die Isolierung des Verhaltens der WebView-Engine von den Navigationsrichtlinien der Host-Anwendung. Durch die Reproduktion von Navigationsereignissen in den Chrome DevTools oder dem Safari Web Inspector, die strikte Beschränkung des Android-Popup-Sitzungsstatus auf den UI-Thread bei gleichzeitiger Kopplung der zustandslosen Überprüfung initialer Anfragen mit sitzungsautorisierten 302-Umleitungsprüfungen, die Durchsetzung von Fail-Closed-Allowlists für den IntentSanitizer und den Schutz von iOS-Universal-Link-Fallbacks vor veralteten asynchronen Überschreibungen und doppelten Delegaten-Starts können Engineering-Teams fehlerhafte Nutzerreisen reduzieren und dazu beitragen, clientseitige Umleitungsschwachstellen zu verhindern.

Nachdem native Delegaten auf Container-Ebene und Fallback-Pfade verifiziert wurden, sollten Entwicklungsteams auch End-to-End-Attributions-Landingpages und One-Click-Launch-Routing-Ketten mithilfe von Plattformen wie OpoInstall validieren, um die Parameterbeibehaltung bei Übergängen vom Browser zur App zu bestätigen.

Entitäten-Glossar

Begriff Definition Zugehörige Entität Suchintention-Rolle
WebView Eine eingebettete native UI-Komponente zum Rendern von Webseiten innerhalb einer mobilen Anwendung. WebViewClient / WKWebView Informativ / Technisch
Benutzerdefiniertes URL-Schema Ein von der App registriertes URI-Präfix (z. B. myapp://), das eine externe Navigation in native Bildschirme ermöglicht. Intent.ACTION_VIEW Technisch / Informativ
WKNavigationDelegate Das WebKit-Protokoll, das es einer Host-App ermöglicht, Navigationsaktionen in WKWebView zu akzeptieren, abzubrechen oder umzuleiten. decidePolicyForNavigationAction Technisch
WKUIDelegate Das WebKit-Protokoll, das für die Behandlung von Anfragen zur Erstellung neuer Fenster in WKWebView verantwortlich ist. createWebViewWith Technisch
WebResourceRequest Das Android API 24+-Objekt, das URL, Frame, HTTP-Methode, Umleitung und Gesten-Metadaten kapselt. shouldOverrideUrlLoading Technisch
WebChromeClient Die Android-WebView-Callback-Schnittstelle zur Behandlung von JavaScript-Dialogen, Fortschritt und onCreateWindow. WebViewTransport Technisch
IntentSanitizer Das AndroidX Core-Dienstprogramm zum Filtern oder strengen Validieren nicht vertrauenswürdiger Intent-Felder vor dem Start. Abwehr von Intent-Umleitungen Technisch / Sicherheit
Universal Links Apples HTTPS-basierter Deep-Linking-Standard, der verifizierte Web-Domains mit installierten iOS-Anwendungen verknüpft. Zugehörige Domains Technisch / Informativ
Paketsichtbarkeit Betriebssystemfilterung ab Android 11+ (targetSdk >= 30), die einschränkt, welche installierten Apps eine Host-App über den PackageManager abfragen kann. <queries>-Manifest-Tag Technisch
Intent-URI Eine strukturierte Android-URI (intent://), die Zielpaket, Schema und Browser-Fallback-URLs codiert. Intent.URI_INTENT_SCHEME Technisch

Kompatibilitäts-Baseline und Verifizierungsstatus

  • Vorgesehene Kompatibilitätsziele: Android minSdk 24, compileSdk 34/35, targetSdk 34/35 (Android 14/15), Android 16 (API 36) Kontext zur Härtung von Intent-Umleitungen, androidx.core:core:1.9.0+ (IntentSanitizer); iOS 15.0–18.0 (isInspectable gekapselt ab iOS 16.4+), Xcode 15/16, Swift 5.9/6.0.

  • Verifizierungsstatus:

    • Statische API- & Spezifikationsprüfung: Abgeschlossen gemäß den offiziellen Spezifikationen von Android Developers, AndroidX Core, Apple Developer, IETF RFC 3986 und OWASP MASTG.

    • Kompilierungs- & physische Geräteverifizierung: Noch nicht ausgeführt in diesem Überprüfungszyklus. Teams müssen Regressionen auf physischen Geräten kompilieren und ausführen, die bösartige initiale Popup-URLs, domänenübergreifende 302-Ketten, aufeinanderfolgende 302-Hops, Fenstererstellung für Drittanbieter-Iframes, Android App Links (assetlinks.json), iOS Associated Domains (AASA-Caching), veraltete asynchrone Universal-Link-Abbrüche, intent://-Fallback-Ketten und ActivityNotFoundException-Dispatches vor dem Rollout in die Produktion abdecken.

Referenzen

Share this article