Bagaimana Cara Menyelesaikan Ralat Pengalihan WebView pada Android dan iOS?

opoinstall
2026-11-19
5 min read

webview-safe-fallback-loop-prevention.webp

Bagaimanakah anda menyelesaikan ralat pengalihan WebView pada Android dan iOS? Kenal pasti sama ada kegagalan melibatkan navigasi HTTPS standard, skema URL tersuai, URI intent:// Android, atau permintaan tetingkap baharu, kemudian periksa navigasi melalui Chrome DevTools atau Safari Web Inspector dan jejak delegasi natif yang sepadan (shouldOverrideUrlLoading, onCreateWindow, decidePolicyForNavigationAction, atau createWebViewWith). Sahkan resolusi apl sasaran, senarai benarkan URI, dasar bingkai dan interaksi pengguna, serta penghalaan sandaran untuk mengasingkan ralat peringkat bekas daripada kegagalan penghantaran sistem pengendalian.

Ralat pengalihan WebView berlaku apabila Chromium WebView Android terbenam atau WKWebView WebKit iOS gagal menghala permintaan navigasi ke destinasi yang dimaksudkan. Punca biasa termasuk skema URL tersuai yang tidak disokong, permintaan target="_blank" yang tidak dikendalikan, pengisytiharan keterlihatan pakej yang hilang, serta pengalihan sandaran yang ditolak atau bergelung.

Mengapa Bekas WebView Android Terbenam dan WKWebView iOS Menggugurkan Pengalihan

Seni bina pengalihan WebView berlapis mendedahkan dasar natif dan kegagalan penghantaran sistem pengendalian.

Semasa menyahpepijat kegagalan pengalihan, pasukan kejuruteraan mesti memisahkan tingkah laku enjin WebView (cara Chromium atau WebKit menghuraikan URL, sasaran bingkai, dan peristiwa popup) daripada dasar aplikasi hos (cara WebViewClient, WebChromeClient, WKNavigationDelegate, atau WKUIDelegate yang disediakan aplikasi menilai jenis interaksi pengguna, senarai benarkan, dan penyerahan apl luaran). Pelayar tersendiri menyertakan penghantar URI terbina dalam dan pengendali penyerahan pautan, manakala android.webkit.WebView dan WKWebView Apple adalah komponen peng渲染an terbenam yang menjangkau respons rangkaian http:// atau https:// standard secara lalai.

Apabila halaman web mencetuskan skema tersuai (seperti myapp://product/42) atau pautan intent:// Android tanpa tindihan delegasi aktif, tingkah laku bekas lalai berbeza merentas platform:

  • WebView Chromium Android: Mengikut spesifikasi WebViewClient Android, jika tiada WebViewClient tersuai ditetapkan, WebView mungkin meminta Pengurus Aktiviti menyelesaikan URL melalui pengendali sistem yang tersedia. Apabila WebViewClient tersuai ditetapkan dan shouldOverrideUrlLoading mengembalikan false untuk skema tersuai yang tidak disokong, WebView terus memuatkannya di dalam Chromium dan memaparkan net::ERR_UNKNOWN_URL_SCHEME.
  • WKWebView WebKit iOS: WebKit menolak skema bukan HTTP secara dalaman dan membatalkan navigasi melainkan WKNavigationDelegate hos memintas permintaan tersebut dan menghantarnya kepada UIApplication, yang selalunya gagal secara senyap atau mencetuskan NSURLErrorUnsupportedURL.

Perhatikan juga bahawa Mempromosikan Apl dengan Sepanduk Apl Pintar Apple ialah ciri sokongan Safari yang direka bentuk untuk pelayaran Safari tersendiri dan bukannya API navigasi WKWebView terbenam, dan harus dinilai secara berasingan daripada pengalihan skema URL tersuai dalam apl.

Sekilas Pandang

  • Pisahkan Tingkah Laku Enjin daripada Dasar Hos: Asingkan sama ada navigasi gagal di dalam enjin web (Chromium/WebKit), di dalam tindihan delegasi natif, atau pada sempadan resolusi pakej OS.
  • Periksa Pengalihan Langsung Sebelum Pengekodan: Gunakan Chrome DevTools (chrome://inspect) dan Safari Web Inspector (isInspectable = true) untuk menangkap rantaian pengalihan 3xx, keadaan targetFrame, dan bendera gerak isyarat.
  • Kuatkuasakan Pengesahan URI & Intent yang Sesuai dengan Platform: Pada Android, ikat skema tersuai dan sasaran intent:// 1-kepada-1 kepada pakej yang disahkan melalui IntentSanitizer tanpa bendera tugas yang dibekalkan halaman web; pada iOS, sahkan struktur URI tersuai penuh (bergantung pada Pautan Universal apabila identiti apl-ke-domain yang disahkan diperlukan), dan tolak kunci pertanyaan duplikat pada kedua-dua platform.
  • Gunakan Pertahanan Mendalam untuk Popup & Keadaan Perlumbaan: Kekatkan keadaan sesi popup Android secara ketat pada benang UI sambil memahami sempadan panggilan balik merentas shouldInterceptRequest dan shouldOverrideUrlLoading, serta asingkan semakan dasar tulen daripada kesan sampingan penghantaran luaran dalam WKWebView iOS menggunakan penyahduplikasian peringkat tindakan dan token penjanaan navigasi.

Punca Biasa dan Langkah Pengesahan untuk Ralat Pengalihan WebView

Memetakan Ralat Klien yang Diberikan kepada Mekanisme Kegagalan Bekas Dasar

Gunakan matriks diagnostik di bawah untuk memetakan simptom WebView yang diperhatikan kepada punca akar platform biasa, langkah pengesahan, dan pemulihan sasaran:

Simptom atau Ralat yang Diperhatikan Platform Sasaran Punca Akar Biasa Langkah Pengesahan Diagnostik Pemulihan Sasaran
WebView memaparkan net::ERR_UNKNOWN_URL_SCHEME WebView Android WebViewClient tersuai mengembalikan false atau kekurangan senarai benarkan skema Periksa request.url dalam shouldOverrideUrlLoading Pintas URI yang disenarai benarkan dan hantar Intent.ACTION_VIEW terikat pakej 1-kepada-1
Kandas senyap apabila mengetik pautan skema tersuai WKWebView iOS WebKit membatalkan URI bukan HTTP apabila WKNavigationDelegate mengembalikan .allow Log navigationAction.request.url dalam decidePolicyForNavigationAction Hala skema yang disahkan melalui UIApplication.shared.open dan luluskan .cancel
target="_blank" menggantikan halaman semasa dalam WebView WebView Android setSupportMultipleWindows(false) menganggap tetingkap baharu sebagai muatan peringkat atas Semak webView.settings.supportMultipleWindows() Dayakan setSupportMultipleWindows(true) hanya jika bekas popup berasingan diperlukan
target="_blank" tidak melakukan apa-apa atau menggugurkan pengalihan 302 OAuth WebView Android onCreateWindow hilang, atau klien anak menyekat lompatan isRedirect yang kekurangan hasGesture() Semak log onCreateWindow, request.isRedirect, dan shouldInterceptRequest Lampirkan WebView popup hos pandangan dengan keadaan sesi benang UI dan lompatan isRedirect terhad
Pautan dengan target="_blank" atau window.open() tidak melakukan apa-apa WKWebView iOS Navigasi tetingkap baharu menetapkan targetFrame == nil dan memerlukan WKUIDelegate Semak navigationAction.targetFrame == nil Kesannya targetFrame == nil dalam decidePolicyForNavigationAction dan kendalikan melalui WKUIDelegate
Apl sasaran dipasang, namun halaman sandaran dibuka Android 11+ (targetSdk >= 30) Pengisytiharan <queries> yang hilang menyebabkan resolveActivity() atau queryIntentActivities() mengembalikan keputusan tidak lengkap untuk pakej halimunan Tambah pengelogan peringkat aplikasi di sekeliling resolveActivity() dan periksa output melalui adb logcat Isytiharkan intent <queries> jika pra-semak, atau panggil startActivity secara terus dengan tangkapan ActivityNotFoundException
Pengalihan pemasa JavaScript gagal membuka apl luaran iOS / Android Pengalihan skrip automatik kekurangan isyarat interaksi pengguna Semak request.hasGesture() (Android) atau navigationType (iOS) Ikat pengalihan kepada ketukan pengguna langsung dan tentukan dasar gerak isyarat hos yang jelas
Pautan Universal dimuatkan di dalam WKWebView dan bukan apl sasaran WKWebView iOS Konteks pelayaran, perhubungan domain, atau navigasi JS mengekalkan muatan dalam WebKit Semak navigationType dan hos dalam decidePolicyForNavigationAction Panggil UIApplication.shared.open dengan .universalLinksOnly: true untuk hos luaran yang dibenarkan

Senarai Semak Triage Pantas Pengalihan WebView Lima Minit

  • Langkah 1: Semak Skema Protokol dalam DevTools: Sahkan sama ada halaman memancarkan URI https://, skema tersuai, atau intent:// dan sahkan ia tidak disekat oleh Dasar Keselamatan Kandungan (CSP).
  • Langkah 2: Periksa Hierarki Bingkai: Semak sama ada pencetus bermula di dalam <iframe> pihak ketiga (!isMainFrame). Aplikasi hos mungkin sengaja menyekat pelancaran apl luaran dimulakan dari iframe pihak ketiga.
  • Langkah 3: Bezakan Pengalihan daripada Pemasa: Semak sama ada navigasi bukan gerak isyarat ialah pengalihan pelayan HTTP 3xx yang dibenarkan (request.isRedirect pada Android) berbanding pemasa JavaScript tanpa gesaan.
  • Langkah 4: Semak Pencetus Tetingkap Baharu: Sahkan sama ada target="_blank" atau window.open() mencipta permintaan tetingkap baharu (targetFrame == nil pada iOS atau onCreateWindow pada Android).
  • Langkah 5: Sahkan Resolusi Pakej OS: Untuk apl yang menyasarkan API 30+ pada Android 11+, sahkan sama ada panggilan prapenerbangan resolveActivity() gagal akibat pengisytiharan <queries> yang hilang.

Aliran kerja diagnostik berikut menggambarkan laluan triage berurutan untuk mengasingkan kegagalan pengalihan bekas:

[Kegagalan Navigasi WebView]
          │
          ▼
[Periksa URL + Rangkaian + Konsol melalui Chrome DevTools / Safari Web Inspector]
          │
          ▼
[Kenal pasti Sumber Navigasi]
          │
          ├── Muat turun apl() atau HTTP POST
          │       │
          │       └── shouldOverrideUrlLoading TIDAK dipanggil; periksa laluan panggilan sebelah hos
          │
          ├── target="_blank" atau window.open()
          │       │
          │       ├── Android (multiple-windows=false) ──> Menggantikan halaman WebView semasa
          │       ├── Android (multiple-windows=true)  ──> Periksa onCreateWindow + shouldInterceptRequest
          │       └── iOS (targetFrame == nil)         ──> Periksa WKNavigationDelegate + WKUIDelegate
          │
          ├── Navigasi HTTP / HTTPS
          │       │
          │       └── Periksa Hos + Port Senarai Benarkan, Pengalihan 3xx, Pautan Universal, atau Pautan Apl yang Sepadan
          │
          └── Skema Tersuai atau intent:// Chrome
                  │
                  ├── Nilai Interaksi Pengguna + Dasar Bingkai Utama
                  ├── Sahkan Struktur URI Penuh (Skema, Hos, Port, Laluan, Tiada Kunci Pertanyaan Duplikat)
                  ├── Sanitasi Intent (Tolak Komponen Eksplisit, Sahkan Pakej 1-kepada-1, Bendera Sifar Halaman Web)
                  ├── Semak Resolusi Apl Sasaran (<queries> / ActivityNotFoundException)
                  └── Sahkan Laluan Sandaran + Senarai Benarkan Pertanyaan + Pengawal Rantaian Monotonik (elapsedRealtime)

Cara Memeriksa Peristiwa Navigasi WebView Menggunakan Alatan Nyahpepijat Jauh

Mendayakan Nyahpepijat Jauh melalui Chrome DevTools dan ADB Logcat pada Android

Sebelum mengubah suai delegasi natif, sahkan sama ada halaman web yang dimuatkan memancarkan pengalihan yang dijangkakan. Mengikut panduan nyahpepijat jauh Chrome DevTools Android, dayakan nyahpepijat WebView jauh secara jelas dalam binaan pembangunan dengan memeriksa ApplicationInfo.FLAG_DEBUGGABLE dan memanggil WebView.setWebContentsDebuggingEnabled(true). Jangan sekali-kali menghantar nyahpepijat yang didayakan dalam keluaran pengeluaran:

// Android - Dayakan nyahpepijat WebView secara eksklusif dalam binaan boleh nyahpepijat
if (applicationInfo.flags and ApplicationInfo.FLAG_DEBUGGABLE != 0) {
    WebView.setWebContentsDebuggingEnabled(true)
}

Sambungkan peranti melalui USB, buka chrome://inspect/#devices dalam Chrome desktop, dan pantau tab Rangkaian dengan Kekalkan log ditanda. Pada masa yang sama, tapis log masa runcit natif melalui adb logcat untuk menangkap ActivityNotFoundException, SecurityException, atau log pembungkus tersuai. Ambil perhatian bahawa amaran susut nilai untuk tandatangan warisan shouldOverrideUrlLoading(WebView, String) muncul semasa penyusunan Android Studio / Gradle dan bukannya dalam masa runcit adb logcat:

# Terminal - Tapis logcat untuk tag WebView tersuai dan resolusi intent ActivityTaskManager
adb logcat -s "WebViewDebug" "ActivityTaskManager" "PackageManager"

Mengkonfigurasi isInspectable dan Melampirkan Safari Web Inspector dan Konsol Xcode pada iOS

Bermula dengan iOS 16.4 dan macOS 13.3, Apple memerlukan aplikasi untuk ikut serta melalui WKWebView.isInspectable, yang lalai kepada false. Dayakan webView.isInspectable = true di dalam blok #if DEBUG:

// iOS - Dayakan ikut serta Safari Web Inspector pada binaan nyahpepijat iOS 16.4+
#if DEBUG
if #available(iOS 16.4, *) {
    webView.isInspectable = true
}
#endif

Pada peranti iOS fizikal, navigasi ke Tetapan > Apl > Safari > Lanjutan (pada keluaran iOS yang lebih lama, Tetapan > Safari > Lanjutan) dan dayakan Web Inspector. Sambungkan melalui USB, buka menu Build Safari desktop, dan pantau Konsol Xcode serentak untuk output penyiapan decidePolicyForNavigationAction, createWebViewWith, dan UIApplication.shared.open natif.

WebView Android dan WKWebView iOS menggunakan navigasi natif berasingan dan pengendali popup.

Menyelesaikan Pengguguran Tetingkap Baharu Senyap dan Gerak Isyarat Pengguna yang Hilang dalam WKWebView iOS

Memisahkan Penilaian Dasar daripada Kesan Sampingan Merentas WKNavigationDelegate dan WKUIDelegate

Apabila pautan web menentukan target="_blank" atau window.open(), WebKit mencipta permintaan navigasi tetingkap baharu di mana navigationAction.targetFrame adalah nil dan melibatkan kedua-dua WKNavigationDelegate dan WKUIDelegate. Jika apl hos tidak melaksanakan webView(_:createWebViewWithConfiguration:for:windowFeatures:), WebKit tidak boleh melahirkan WebView sekunder, dan navigasi mungkin kelihatan gagal secara senyap.

Untuk mengelakkan pelancaran apl luaran duplikat atau token penjanaan dwi-tambahan apabila kedua-dua delegasi memeriksa permintaan, pisahkan penilaian dasar tulen (evaluateNavigationPolicy) daripada kesan sampingan pelaksanaan, dan nyahduplikasi mengikut contoh WKNavigationAction tertentu (ObjectIdentifier(navigationAction)) daripada bergantung semata-mata pada ambang masa kasar yang boleh menyekat ketukan ulangan pantas berniat oleh pengguna. Nilai navigationAction.targetFrame == nil secara terus dalam decidePolicyForNavigationAction: jika penilaian mengembalikan pelan penyerahan luaran, laksanakan sekali (merekodkan pengecam WKNavigationAction) dan luluskan .cancel; jika ia mengembalikan .allowInWebView untuk URL popup yang disenarai benarkan, luluskan .allow supaya createWebViewWith memuatkan popup dengan selamat. Sentiasa sahkan pesanan panggilan balik delegasi tepat pada versi iOS sasaran.

Konteks Pautan Universal, Keselamatan Perlumbaan Asinkron, dan Identiti Skema Tersuai

Penyerahan Pautan Universal bergantung pada konteks pelayaran sumber, perhubungan domain, and konfigurasian Domain Berkaitan (disahkan melalui fail apple-app-site-association pelayan sasaran). Nota teknikal Apple TN3155: Menyahpepijat pautan universal mendokumentasikan cara navigasi domain sama dalam Safari menyukai kekal dalam pelayar, manakala subdomain berbeza mengubah ke layak. Sentiasa uji tingkah laku Domain Berkaitan pada keluaran iOS sasaran di dalam WKWebView.

Apabila memanggil UIApplication.shared.open(url, options: [.universalLinksOnly: true]), lindungi terhadap keadaan perlumbaan navigasi asinkron: jika pengguna memulakan sebarang percubaan navigasi bingkai utama seterusnya semasa sistem memproses penyerahan Pautan Universal, pengendali penyiapan yang tidak dilindungi mengembalikan false boleh menimpa keadaan navigasi baharu pengguna. Tambah token activeNavigationGeneration monotonik pada setiap penilaian navigasi bingkai utama baharu (termasuk percubaan yang disekat atau dialihkan) supaya sebarang sandaran asinkron terdahulu yang tertangguh dibatalkan dengan serta-merta, dan sahkan self.activeNavigationGeneration == requestGeneration di samping self.isViewLoaded && self.view.window != nil sebelum memuatkan semula URL sandaran.

Patuhi dua sempadan keselamatan yang ketat:

  • Pengelasan WKNavigationType: Mengikut dokumentasi WKNavigationType Apple, formSubmitted mewakili permintaan untuk menyerahkan borang dan bukannya ketukan pautan, dan skrip halaman boleh menyerahkan borang secara programatik. Hadkan penyerahan apl luaran kepada peristiwa .linkActivated dikelaskan WebKit digabungkan dengan sourceFrame.isMainFrame dan senarai benarkan URI penuh, daripada merawat .linkActivated sebagai token gerak isyarat kriptografi terpencil.
  • Keunikan Skema Tersuai & Pencemaran Parameter: Mengikut panduan Apple tentang Menentukan Skema URL Tersuai untuk Apl Anda, berbilang apl boleh menuntut skema tersuai yang sama. isAllowedCustomURL(_:) mengesahkan struktur URI (skema, hos, port lalai nil, corak laluan, tiada maklumat pengguna/serpihan, dan menolak kunci pertanyaan duplikat), bukan identiti ID Bundle sasaran. Gunakan Pautan Universal yang disahkan domain pada bila-bila masa pengikatan identiti apl diperlukan.

Penafian Seni Bina Rujukan: Pelaksanaan berikut ialah seni bina rujukan pertahanan. Sahkan ketersediaan API, pesanan delegasi, and tingkah laku kitaran hayat terhadap versi AndroidX dan iOS tepat yang digunakan oleh aplikasi anda.

// iOS - WebViewContainerController.swift
// Seni bina rujukan: susun dan uji terhadap sasaran projek khusus anda (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!

    // Senarai benarkan eksplisit untuk skema URL tersuai luaran, hos, dan kunci pertanyaan
    private let allowedCustomSchemes: Set<String> = ["myapp", "partnerapp"]
    private let allowedCustomHosts: Set<String> = ["open", "product", "promo"]
    private let allowedCustomQueryKeys: Set<String> = ["id", "ref", "promo"]

    // Senarai benarkan eksplisit untuk hos HTTPS yang dibenarkan di dalam bekas WebView utama
    private let allowedWebHosts: Set<String> = [
        "example.com",
        "m.example.com",
        "links.example.com"
    ]

    // Senarai benarkan terpencil khusus untuk tetingkap popup anak (target="_blank")
    private let allowedPopupHosts: Set<String> = ["example.com", "auth.example.com"]
    private let allowedPopupPathPrefixes: [String] = ["/oauth", "/popup", "/window"]

    // Hos Pautan Universal Luaran yang mencuba penyerahan apl natif semasa pengaktifan pautan
    private let externalUniversalLinkHosts: Set<String> = ["links.example.com"]

    // Token penjanaan navigasi monotonik ditambah pada setiap percubaan navigasi bingkai utama baharu
    private var activeNavigationGeneration: UInt64 = 0

    // Penyahduplikasian peringkat tindakan menghalang penghantaran duplikat untuk WKNavigationAction yang sama
    private var dispatchedActionIDs: [ObjectIdentifier] = []
    private let maxTrackedActionIDs = 16

    // Cache pintasan terikat TTL masa aktif monotonik dikunci oleh kunci Pautan Universal yang dinormalkan
    private var bypassedUniversalLinkKeys: [String: TimeInterval] = [:]
    private let maxBypassedKeys = 10
    private let bypassTTLSeconds: TimeInterval = 300
    // Sesuaikan kunci pertanyaan penting agar sepadan dengan parameter penghalaan sebenar aplikasi anda
    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)

        // Tambah token penjanaan pada setiap percubaan navigasi bingkai utama (termasuk percubaan yang disekat)
        // supaya sebarang sandaran Pautan Universal asinkron terdahulu yang tertangguh dibatalkan dengan serta-merta.
        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 (Mengendalikan target="_blank" dan 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: - Penilaian Dasar Navigasi Tulen (Tiada Kesan Sampingan)

    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. Nilai Skema URL Tersuai bukan HTTP/HTTPS
        // Nota: Senarai benarkan skema tersuai mengesahkan struktur URI; ia tidak dapat menjamin identiti ID Bundle sasaran.
        if scheme != "http" && scheme != "https" {
            guard isMainFrame, isLinkActivated, isAllowedCustomURL(url) else {
                return .block
            }
            return .launchCustomScheme(url)
        }

        // 2. Kuatkuasakan HTTPS sahaja, port lalai (nil atau 443), dan Senarai Benarkan Hos
        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. Nilai Penyerahan Pautan Universal untuk hos luaran yang ditetapkan semasa pengaktifan pautan
        if let host = targetHost,
           externalUniversalLinkHosts.contains(host),
           isMainFrame,
           isLinkActivated,
           let loopKey = universalLinkLoopKey(for: url),
           !isBypassedKeyActive(loopKey) {
            return .attemptUniversalLink(url)
        }

        return .allowInWebView
    }

    // MARK: - Pelaksanaan Penghantaran Luaran Dinyahduplikasi Peringkat Tindakan

    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
                // Sahkan kitaran hayat pandangan DAN token penjanaan untuk mengelakkan penimpaan sandaran asinkron lapuk
                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] Gagal melancarkan skema tersuai (apl mungkin tidak dipasang)")
                }
            }
        }
    }

    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, // Tolak port eklisit pada skema tersuai
              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
    }
}

Memperbetulkan ERR_UNKNOWN_URL_SCHEME dan Kegagalan Keterlihatan Pakej dalam WebView Android

Panggilan Balik Disusutkan, hasGesture(), dan Sempadan POST

Android menyusutkan shouldOverrideUrlLoading(WebView, String) dalam tahap API 24 memihak kepada shouldOverrideUrlLoading(WebView, WebResourceRequest). WebResourceRequest menyediakan isForMainFrame, isRedirect, dan hasGesture(). Ambil perhatian dua kekangan platform rasmi: shouldOverrideUrlLoading tidak dipanggil untuk panggilan webView.loadUrl() dimulakan hos atau navigasi POST HTTP, dan hasGesture() boleh mengembalikan false untuk pengalihan JavaScript asinkron yang sah atau lompatan 302 sebelah pelayan.

Pengendalian Popup Pertahanan Mendalam dan Pengasingan Benang dalam WebChromeClient.onCreateWindow

Tingkah laku popup Android bergantung pada WebSettings.setSupportMultipleWindows. Jika apl anda tidak memerlukan popup interaktif, mengekalkan setSupportMultipleWindows(false) (atau mengembalikan false daripada onCreateWindow) menghalang iframe pihak ketiga daripada membuka bekas sekunder—atau membuka destinasi yang disahkan melalui titik kemasukan yang jelas dan dikawal hos.

Apabila setSupportMultipleWindows(true) didayakan, WebChromeClient.onCreateWindow tidak membekalkan URL destinasi dalam tandatangan panggilan baliknya, dan tiada panggilan balik tunggal merangkumi setiap vektor navigasi. Memahami model benang dan sempadan panggilan balik yang tepat adalah penting untuk pendekatan rujukan pertahanan mendalam:

  • shouldOverrideUrlLoading (Benang UI — Pemilik Keadaan Navigasi & Sesi): Berjalan secara eksklusif pada benang UI dan memiliki semua keadaan sesi popup boleh ubah (isInitialTransportLoad, isAuthorizedPopupSession, popupRedirectHops, dan popupChainStartMs). Hanya apabila muatan awal yang disahkan atau gerak isyarat pengguna langsung sepadan dengan policy.isAllowedPopupUri, shouldOverrideUrlLoading membenarkan sesi untuk pengalihan 302 HTTP terikat seterusnya (request.isRedirect), memastikan rantaian pengalihan terikat kembali kepada sesi yang dibenarkan dan bukannya mempercayai pengalihan sewenang-wenangnya.
  • shouldInterceptRequest (Benang IO WebView Latar Belakang — Pengawal Baca Sahaja Tanpa Keadaan): Berjalan pada benang WebView bukan UI. Kerana ia tidak boleh mengubah keadaan sesi benang UI, ia beroperasi secara ketat sebagai semakan dasar baca sahaja tanpa keadaan pada safeClient.policy (menyekat permintaan HTTP/HTTPS bingkai utama yang gagal isAllowedPopupUri dan menghantar disposeActivePopup() ke benang utama). Ambil perhatian bahawa mengikut dokumentasi Android, shouldInterceptRequest hanya dipanggil untuk URL sumber awal, bukan untuk URL pengalihan 302 HTTP seterusnya; URL pengalihan seterusnya mesti dinilai oleh shouldOverrideUrlLoading.
  • onPageStarted (Benang UI — Semakan Sandaran Mula Navigasi): Dilaksanakan apabila muatan bingkai utama bermula (bukan sebagai penapis pra-navigasi). Ia mengemas kini sepanduk asal kelihatan untuk ketelusan pengguna dan menyediakan semakan sandaran mula navigasi memanggil stopLoading() dan disposeActivePopup() jika destinasi yang tidak diluluskan mula dimuatkan.

Sentiasa uji URL awal berniat jahat, rantaian 302 HTTP merentas domain, pengalihan 302 berturut-turut, target="_blank", window.open(), dan pencetus iframe pihak ketiga pada binaan WebView fizikal sasaran.

Keterlihatan Pakej Android 11+ dan Panduan canOpenURL Disusutkan

Di bawah aturan keterlihatan pakej Android, aplikasi yang berjalan pada Android 11 (tahap API 30) atau lebih tinggi dan menyasarkan tahap API 30 atau lebih tinggi (targetSdk >= 30) menerima null atau keputusan kosong daripada intent.resolveActivity() atau queryIntentActivities() melainkan apl sasaran diisytiharkan di bawah <queries> dalam AndroidManifest.xml. Android mengesyorkan memanggil startActivity(intent) secara terus di dalam try/catch untuk ActivityNotFoundException dan SecurityException daripada mengembangkan <queries>.

Pada iOS, Apple telah menyusutkan UIApplication.canOpenURL(_:) dan mengesyorkan mencuba UIApplication.shared.open(_:options:completionHandler:) secara terus dan mengendalikan sebarang kegagalan dalam pengendali penyiapan (atau berhijrah ke Pautan Universal untuk mengalih keluar pra-pengesahan skema). LSApplicationQueriesSchemes dalam Info.plist hanya diperlukan jika kod warisan terus memanggil canOpenURL(_:), manakala open(_:options:completionHandler:) tidak memerlukan pengisytiharan skema dalam Info.plist. Kedua-dua <queries> dan LSApplicationQueriesSchemes mengawal keterlihatan pertanyaan — ia bukan senarai benarkan keselamatan untuk mengesahkan URI web yang tidak dipercayai.

<!-- Serpihan Manifest: Gabungkan <queries> ke dalam AndroidManifest.xml sedia ada anda -->
<!-- Dikehendaki untuk targetSdk >= 30 pada Android 11+ HANYA jika memanggil resolveActivity atau 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>
<!-- Serpihan Info.plist: Masukkan di bawah akar <dict> dalam Info.plist -->
<!-- Warisan: Dikehendaki pada iOS HANYA jika memanggil UIApplication.shared.canOpenURL yang disusutkan; open(_:options:completionHandler:) tidak memerlukan kekunci ini -->
<key>LSApplicationQueriesSchemes</key>
<array>
    <string>myapp</string>
    <string>partnerapp</string>
<array>

Cara Menghuraikan URI Intent Chrome dengan Selamat dan Menghalang Gelung Pengalihan

Mengamankan Intent.parseUri Terhadap Eksploitasi Pengalihan Intent

URI intent:// Android mengekod skema sasaran, pakej, dan URL sandaran (S.browser_fallback_url). Menghuraikan URI web yang tidak dipercayai melalui Intent.parseUri(rawUri, Intent.URI_INTENT_SCHEME) memperkenalkan risiko Pengalihan Intent yang didokumenkan dalam panduan keselamatan Pengalihan Intent Android dan Panduan Pengujian Keselamatan Aplikasi Mudah Alih OWASP. Walaupun dengan Android 16 (API 36) menambah pengukuhan lalai peringkat platform, aplikasi mesti menguatkuasakan pengesahan ketat sebelum menghantar Intent.

Pengesahan URI berlapis menyekat intent WebView tidak selamat sebelum penghantaran aplikasi luaran.

Untuk melaksanakan pengesahan tutup kegagalan menggunakan AndroidX IntentSanitizer (androidx.core:core:1.9.0+, atau androidx.core:core-ktx:1.9.0+ yang membungkus androidx.core:core) tanpa mencetuskan konflik pengecualian bersilang pembina antara allowAnyComponent() dan kaedah senarai benarkan pakej/komponen:

  • Semakan Pra-Sanitasi: Tolak serta-merta intent yang membawa medan component atau selector bukan null (parsedIntent.component != null || parsedIntent.selector != null). Ekstrak dan alih keluar browser_fallback_url sebelum sanitasi, dan sahkan secara natif bahawa parsedIntent.data?.scheme dipetakan 1-kepada-1 kepada parsedIntent.package melalui customSchemeTargetPackages (memastikan myapp:// diselesaikan secara ketat kepada com.example.target, tidak pernah pakej rakan kongsi lain).
  • Pelaksanaan Sanitizer: Kosongkan sementara parsedIntent.package = null pada salinan yang tidak dipercayai, laksanakan IntentSanitizer.Builder().allowAnyComponent().allowAction(Intent.ACTION_VIEW).allowCategory(Intent.CATEGORY_BROWSABLE).allowData { ... }.build().sanitizeByThrowing(parsedIntent) (tiada bendera tugas yang dibekalkan halaman web), dan tetapkan semula expectedPackage yang disahkan dan CATEGORY_BROWSABLE pada Intent milik hos yang disanitasi sebelum penegasan pasca-sanitasi.
  • Bendera Pelancaran Sedar Konteks: Masukkan Intent.FLAG_ACTIVITY_NEW_TASK di dalam penghantar natif (launchWithContextSafety) hanya apabila view.context !is Activity. Untuk pengesahan perhubungan domain-ke-apl, utamakan Pautan Apl Android HTTPS yang disahkan (assetlinks.json).

Menghalang Gelung Sandaran Tak Terhingga dengan Keadaan Rantaian Monotonik

Apabila startActivity melemparkan ActivityNotFoundException, sahkan browser_fallback_url dengan semakan isAllowedFallbackUri(uri) khusus (secara ketat HTTPS, port lalai, hos disahkan, awalan laluan sandaran eklisit, tiada kunci pertanyaan duplikat, dan tiada serpihan). Tolak perwakilan port eklisit pada skema tersuai dengan mengesahkan kedua-dua uri.port == -1 dan !uri.encodedAuthority.orEmpty().contains(":").

Jejak rantaian sandaran menggunakan SystemClock.elapsedRealtime() (mengelakkan lonjakan jam dinding System.currentTimeMillis()), asingkan rantaian melalui fallbackLoopKey() (bukan kanonisasi IETF RFC 3986 penuh), tetapkan semula keadaan melalui pembungkus hos loadNewNavigation(webView, url) yang jelas, dan hala sandaran popup keluar ke bekas utama melalui onPopupFallbackHandoff supaya domain yang tidak dibenarkan tidak pernah dimuatkan di dalam dialog popup.

Penafian Seni Bina Rujukan: Pelaksanaan berikut ialah seni bina rujukan pertahanan. Sahkan ketersediaan API, pesanan delegasi, and tingkah laku kitaran hayat terhadap versi AndroidX dan iOS tepat yang digunakan oleh aplikasi anda.

// Android - SafeWebViewModules.kt
// Seni bina rujukan: susun dan uji terhadap sasaran projek khusus anda
// Memerlukan androidx.core:core:1.9.0+ (atau androidx.core:core-ktx:1.9.0+) untuk IntentSanitizer; menyasarkan 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. Modul Dasar (Tidak Boleh Ubah / Selamat Benang untuk akses baca sahaja daripada benang IO & UI)
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"),
    // Senarai benarkan terpencil secara eklisit untuk tetingkap popup; berbeza daripada hos web am
    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
        }

        // Sahkan kunci pertanyaan, kuatkuasakan sintaks nilai, dan tolak kunci duplikat
        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

        // Tolak port rangkaian secara ketat dengan memeriksa kedua-dua uri.port == -1 dan ketiadaan kolon autoriti mentah
        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

        // Sahkan kunci pertanyaan, kuatkuasakan sintaks nilai, dan tolak kunci duplikat
        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. Pengurus Sandaran: Keadaan Rantaian Masa Terlepas Monotonik (Mengasingkan rantaian aktif daripada sesi ulangan)
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
    }

    // Kekunci gelung peringkat aplikasi menormalkan port HTTPS lalai dan mengekalkan kunci pertanyaan penting
    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. Penghala & WebViewClient IntentSanitizer Tutup Kegagalan (Benang UI Sahaja)
class SafeRedirectWebViewClient(
    val policy: CustomUriPolicy = CustomUriPolicy(),
    val loopGuard: FallbackLoopGuard = FallbackLoopGuard(),
    private val onPopupFallbackHandoff: ((fallbackUri: Uri) -> Unit)? = null
) : WebViewClient() {

    // API navigasi dimulakan hos eklisit yang menetapkan semula keadaan rantaian sandaran sebelum loadUrl()
    fun loadNewNavigation(webView: WebView, url: String) {
        val targetUri = Uri.parse(url)
        if (!policy.isAllowedWebUri(targetUri)) {
            Log.w("WebViewDebug", "Menyekat navigasi dimulakan hos ke URL tidak dipercayai")
            return
        }
        loopGuard.resetChain()
        webView.loadUrl(url)
    }

    // Pemuat sandaran khusus dengan pengesahan dalaman mengekalkan keadaan rantaian aktif
    fun loadFallbackNavigation(webView: WebView, fallbackUri: Uri) {
        if (!policy.isAllowedFallbackUri(fallbackUri)) {
            Log.w("WebViewDebug", "Menyekat percubaan navigasi sandaran tidak dipercayai")
            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. Kuatkuasakan HTTPS sahaja & Senarai Benarkan Hos Web pada semua navigasi HTTP/HTTPS
        if (scheme == "http" || scheme == "https") {
            if (!policy.isAllowedWebUri(targetUri)) {
                Log.w("WebViewDebug", "Menyekat hos web bukan HTTPS, port tersuai, atau tidak dipercayai")
                return true
            }
            if (hasUserGesture && isForMainFrame) {
                loopGuard.resetChain()
            }
            return false
        }

        // 2. Kuatkuasakan kekangan bingkai utama dan gerak isyarat pengguna pada pelancaran apl luaran
        if (!isForMainFrame || !hasUserGesture) {
            Log.w("WebViewDebug", "Menyekat skema bukan bingkai utama atau bukan gerak isyarat: $scheme")
            return true
        }

        // 3. Huraikan dan sanitasi tutup kegagalan URI intent:// Chrome
        if (scheme == "intent") {
            return handleIntentUri(view, targetUri.toString(), isPopupContext)
        }

        // 4. Sahkan dan ikat secara eklisit skema URL tersuai yang disenarai benarkan kepada pakej sasaran disahkan 1-kepada-1
        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. Sekat semua skema yang tidak dikenal pasti
        Log.w("WebViewDebug", "Menyekat skema URL tidak dikenal pasti: $scheme")
        return true
    }

    // Penilaian Navigasi Benang UI untuk WebView popup anak mengikat pengalihan 302 kepada sesi yang dibenarkan
    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", "Menyekat navigasi HTTPS subbingkai di dalam popup")
                return true
            }
            if (!policy.isAllowedPopupUri(targetUri)) {
                Log.w("WebViewDebug", "Menyekat navigasi hos atau laluan HTTPS popup tidak dipercayai")
                return true
            }
            // Benarkan sesi hanya pada benang UI apabila muatan awal atau ketukan pengguna sepadan dengan senarai benarkan
            if (isInitialTransportLoad || hasUserGesture) {
                onAuthorizedInitialSession()
                return false
            }
            // Izinkan pengalihan 302 sebelah pelayan terhad HANYA untuk sesi popup yang dibenarkan sebelum ini
            if (isRedirect && isAuthorizedPopupSession && canProceedPopupRedirect()) {
                return false
            }

            Log.w("WebViewDebug", "Menyekat pengalihan tidak dibenarkan atau navigasi popup bukan gerak isyarat")
            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", "Sintaks URI intent cacat")
            return true
        }

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

        // Pengikatan 1-kepada-1: Ekstrak skema sasaran dan sahkan secara natif terhadap pakej sasaran yang dijangkakan
        val dataUri = parsedIntent.data ?: return true
        val targetScheme = dataUri.scheme?.lowercase() ?: return true
        val expectedPackage = policy.customSchemeTargetPackages[targetScheme] ?: run {
            Log.w("WebViewDebug", "Menyekat intent dengan skema tersuai tidak dipetakan: $targetScheme")
            return true
        }

        val rawPackage = parsedIntent.`package`
        if (rawPackage != expectedPackage) {
            Log.w("WebViewDebug", "Menyekat ketidakpadanan pakej intent: dijangkakan $expectedPackage")
            return true
        }

        // Tolak komponen eklisit dan pemilih yang ditentukan halaman web dengan serta-merta
        if (parsedIntent.component != null || parsedIntent.selector != null) {
            Log.w("WebViewDebug", "Menyekat intent dengan komponen atau pemilih eklisit")
            return true
        }

        // Kosongkan pakej disahkan sementara sebelum memanggil IntentSanitizer dengan allowAnyComponent()
        // untuk mengelakkan kekangan pengecualian bersilang Pembina sambil menolak bendera/ekstra tidak dipercayai dengan ketat.
        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 melemparkan SecurityException untuk medan atau bendera tidak dibenarkan")
            return true
        } catch (e: IllegalArgumentException) {
            Log.w("WebViewDebug", "IntentSanitizer menolak hujah intent tidak sah")
            return true
        }

        // Ikat semula pakej sasaran disahkan + kategori dikuatkuasakan hos + penegasan pasca-sanitasi
        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", "Penegasan intent pasca-sanitasi gagal")
            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", "Menyekat URL sandaran tidak dipercayai atau bergelung")
                }
            }
        } catch (e: SecurityException) {
            Log.w("WebViewDebug", "SecurityException menyekat pelancaran intent")
        }
        return true
    }

    private fun launchIntentSafely(view: WebView, intent: Intent) {
        try {
            launchWithContextSafety(view, intent)
        } catch (e: ActivityNotFoundException) {
            Log.i("WebViewDebug", "Tiada aplikasi dipasang yang mengendalikan pakej/skema sasaran")
        } catch (e: SecurityException) {
            Log.w("WebViewDebug", "SecurityException menyekat pelancaran skema tersuai")
        }
    }

    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. WebChromeClient Popup Diurus Kitaran Hayat (Keadaan Sesi Benang UI Ketat & Pengawal Latar Belakang Tanpa Keadaan)
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 = "Memuatkan destinasi..."
        }
        popupRoot.addView(originBanner)

        // Semua pembolehubah keadaan sesi popup di bawah dibaca dan dimutasi secara ketat pada benang UI
        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() {
                // Benang UI: Memiliki navigasi, pengalihan, dan keadaan kebenaran sesi
                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
                }

                // Benang IO WebView Latar Belakang: Semakan dasar baca sahaja tanpa keadaan yang ketat.
                // Tidak pernah mengubah keadaan sesi benang UI; merangkumi URL sumber awal sahaja (bukan lompatan 302 seterusnya).
                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", "Menyekat permintaan bingkai utama popup tidak diluluskan dalam shouldInterceptRequest")
                            childView.post { disposeActivePopup() }
                            return WebResourceResponse("text/plain", "utf-8", ByteArrayInputStream(ByteArray(0)))
                        }
                    }
                    return super.shouldInterceptRequest(childView, request)
                }

                // Benang UI: Semakan sandaran mula navigasi & paparan asal (bukan penapis pra-navigasi)
                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", "Semakan sandaran mula navigasi menamatkan URL popup tidak diluluskan")
                        childView.stopLoading()
                        disposeActivePopup()
                        return
                    }
                    isAuthorizedPopupSession = true
                    val scheme = uri.scheme?.lowercase() ?: "https"
                    val host = uri.host?.lowercase() ?: "Tidak Dikenali"
                    originBanner.text = "Asal: $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. Contoh Pendaftaran Aktiviti Hos Lengkap & Pembersihan Kitaran Hayat (JavaScript Didayakan pada WebView Utama)
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 {
                // Dayakan JavaScript secara eklisit untuk halaman pendaratan dipercayai yang memerlukan pengalihan JS atau window.open()
                javaScriptEnabled = true
                allowFileAccess = false
                allowContentAccess = false
                // Dayakan berbilang tetingkap hanya jika mengehos bekas popup interaktif
                setSupportMultipleWindows(true)
            }
            webViewClient = safeClient
            webChromeClient = popupChromeClient
        }
        setContentView(webView)

        // Gunakan pembungkus hos eklisit dan bukannya webView.loadUrl() kosong
        safeClient.loadNewNavigation(webView, "https://example.com/landing")
    }

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

Soalan Lazim (FAQ)

Mengapakah WebView Android memaparkan net::ERR_UNKNOWN_URL_SCHEME walaupun apl sasaran dipasang?
Ralat ini berlaku apabila Chromium cuba mengambil skema URL tersuai bukan HTTP melalui bertindih rangkaiannya dan bukannya menghantarnya ke Pengurus Aktiviti Android. Sahkan lima pusat pemeriksaan: sahkan `WebViewClient` tersuai ditetapkan; pastikan `shouldOverrideUrlLoading(WebView, WebResourceRequest)` mengembalikan `true` untuk skema yang dipintas; sahkan struktur URI dan pakej sasaran 1-kepada-1 melepasi senarai benarkan anda; sahkan `startActivity(intent)` dilaksanakan dengan bersih (menangkap `ActivityNotFoundException` atau mengkonfigurasi `<queries>` untuk `targetSdk >= 30` jika memanggil `resolveActivity()`); dan sahkan manifes apl sasaran mengisytiharkan `<intent-filter>` yang sepadan dengan `CATEGORY_BROWSABLE`.
Mengapakah shouldOverrideUrlLoading gagal dicetuskan apabila apl saya memanggil WebView loadUrl secara terus?
Mengikut reka bentuk kerangka kerja Android, `shouldOverrideUrlLoading` tidak dipanggil untuk panggilan `webView.loadUrl()` dimulakan apl atau navigasi `POST` HTTP. Ia dicetuskan terutamanya untuk navigasi yang dimulakan oleh kandungan web, interaksi pengguna, atau pengalihan pelayan HTTP 3xx yang disokong. Cetuskan pengalihan ujian daripada interaksi DOM atau respons pelayan di dalam halaman, dan gunakan pembungkus hos eklisit (seperti `loadNewNavigation`) semasa mengaudit muatan dimulakan apl.
Mengapakah pautan sasaran kosong dengan skema tersuai gagal secara senyap di dalam WKWebView?
Apabila pautan web menggunakan `target="_blank"` atau `window.open()`, WebKit mencipta permintaan navigasi tetingkap baharu di mana `navigationAction.targetFrame` adalah `nil`. Kerana `WKWebView` tidak membuka tab baharu secara automatik, navigasi ini mungkin gagal secara senyap melainkan apl hos mengesan `targetFrame == nil` dalam `decidePolicyForNavigationAction` dan melaksanakan `WKUIDelegate.webView(_:createWebViewWith:for:windowFeatures:)` untuk menilai dan menghala permintaan di bawah dasar navigasi bersatunya.

Ringkasan dan Rangka Kerja Keputusan

Menyelesaikan kegagalan pengalihan pautan mendalam WebView memerlukan pengasingan tingkah laku enjin WebView daripada dasar navigasi aplikasi hos. Dengan menghasilkan semula peristiwa navigasi dalam Chrome DevTools atau Safari Web Inspector, mengekatkan keadaan sesi popup Android secara ketat pada benang UI sambil memasangkan penapisan permintaan awal tanpa keadaan dengan semakan pengalihan 302 yang dibenarkan sesi, menguatkuasakan senarai benarkan IntentSanitizer tutup kegagalan, dan melindungi sandaran Pautan Universal iOS terhadap penimpaan asinkron lapuk dan pelancaran delegasi duplikat, pasukan kejuruteraan boleh mengurangkan perjalanan pengguna yang rosak dan membantu mencegah kerentanan pengalihan sebelah klien.

Selepas delegasi natif peringkat bekas dan lalai sandaran disahkan, pasukan kejuruteraan juga harus mengesahkan halaman pendaratan atribusi hujung-ke-hujung dan rantaian penghalaan Pelancaran Satu Klik menggunakan platform seperti OpoInstall untuk mengesahkan pemeliharaan parameter merentas peralihan pelayar-ke-apl.

Glosari Entiti

Terma Definisi Entiti Berkaitan Peranan Intent Carian
WebView Komponen UI natif terbenam yang digunakan untuk memaparkan halaman web di dalam aplikasi mudah alih. WebViewClient / WKWebView Informatif / Teknikal
Skema URL Tersuai Prefiks URI berdaftar apl (cth., myapp://) membolehkan navigasi luaran ke skrin natif. Intent.ACTION_VIEW Teknikal / Informatif
WKNavigationDelegate Protokol WebKit membenarkan apl hos menerima, membatalkan, atau mengalihkan tindakan navigasi dalam WKWebView. decidePolicyForNavigationAction Teknikal
WKUIDelegate Protokol WebKit bertanggungjawab mengendalikan permintaan penciptaan tetingkap baharu dalam WKWebView. createWebViewWith Teknikal
WebResourceRequest Objek API 24+ Android merangkumkan URL, bingkai, kaedah HTTP, pengalihan, dan metadata gerak isyarat. shouldOverrideUrlLoading Teknikal
WebChromeClient Antara muka panggilan balik WebView Android mengendalikan dialog JavaScript, kemajuan, dan onCreateWindow. WebViewTransport Teknikal
IntentSanitizer Utiliti Teras AndroidX digunakan untuk menapis atau mengesahkan secara ketat medan Intent tidak dipercayai sebelum penghantaran. Pertahanan Pengalihan Intent Teknikal / Keselamatan
Pautan Universal Piawaian pautan mendalam berasaskan HTTPS Apple mengikat domain web disahkan kepada aplikasi iOS yang dipasang. Domain Berkaitan Teknikal / Informatif
Keterlihatan Pakej Penapisan OS Android 11+ (targetSdk >= 30) menyekat apl yang dipasang yang boleh disoal oleh apl hos melalui PackageManager. Tag Manifes <queries> Teknikal
URI Intent URI Android berstruktur (intent://) mengekod pakej sasaran, skema, dan URL sandaran pelayar. Intent.URI_INTENT_SCHEME Teknikal

Garis Dasar Keserasian dan Status Pengesahan

  • Sasaran Keserasian Dimaksudkan: Android minSdk 24, compileSdk 34/35, targetSdk 34/35 (Android 14/15), konteks pengukuhan Pengalihan Intent Android 16 (API 36), androidx.core:core:1.9.0+ (IntentSanitizer); iOS 15.0–18.0 (isInspectable dikawal pada iOS 16.4+), Xcode 15/16, Swift 5.9/6.0.

  • Status Pengesahan:

    • Semakan API & Spesifikasi Statik: Disiapkan terhadap spesifikasi rasmi Pemaju Android, Teras AndroidX, Pemaju Apple, IETF RFC 3986, dan OWASP MASTG.

    • Pengesahan Peranti Fizikal & Susun: Belum dilaksanakan dalam kitaran semakan ini. Pasukan mesti menyusun and melaksanakan regresi peranti fizikal merangkumi URL popup awal berniat jahat, rantaian 302 merentas domain, lompatan 302 berturut-turut, penciptaan tetingkap iframe pihak ketiga, Pautan Apl Android (assetlinks.json), Domain Berkaitan iOS (pengecahan AASA), pembatalan Pautan Universal asinkron lapuk, rantaian sandaran intent://, dan penghantaran ActivityNotFoundException sebelum pelancaran pengeluaran.

Rujukan

Share this article