วิธีตั้งค่าการกำหนดเส้นทางใน WKWebView เพื่อรองรับ iOS Universal Links

opoinstall
2026-10-07
5 min read

ฉันจะเปิดใช้งาน Universal Links ภายใน WKWebView ของ iOS ได้อย่างไร? Universal Links สามารถทำงานได้จากลิงก์ที่เข้าเกณฑ์ภายใน WKWebView อยู่แล้ว การใช้งาน WKNavigationDelegate จะช่วยให้แอปพลิเคชันหลักปรับแต่งนโยบายการกำหนดเส้นทาง (Routing Policy) ได้ เช่น การดักจับปลายทางที่เป็นของแอปเอง, การควบคุมการส่งต่อไปยังภายนอกผ่าน decidePolicyForNavigationAction และการบังคับใช้ความปลอดภัยระดับเฟรม

ในสถาปัตยกรรมแอปพลิเคชัน iOS การดักจับการนำทางใน WKWebView ช่วยให้แอปสามารถปรับแต่งนโยบายการกำหนดเส้นทางสำหรับ Universal Links, custom URL schemes และปลายทางบนเว็บได้ โดยการตรวจสอบเมตาข้อมูลของคำขอการนำทางผ่าน WKNavigationDelegate แอปจะสามารถกำหนดเส้นทางปลายทางที่เป็นของแอปเองไว้ภายใน ส่งต่อปลายทางภายนอกไปยังตัวจัดการของระบบ และบังคับใช้นโยบายความปลอดภัยระดับเฟรมได้

คำศัพท์ คำนิยาม เอนทิตีที่เกี่ยวข้อง บทบาทของ Search Intent
WebView องค์ประกอบมุมมองที่ใช้ WebKit ซึ่งฝังไว้เพื่อแสดงผลเนื้อหาเว็บแบบโต้ตอบภายในแอปพลิเคชัน iOS iOS SDK เชิงให้ข้อมูล / เชิงพาณิชย์
Universal Links กลไกมาตรฐาน HTTPS ที่เชื่อมโยงโดเมนเว็บที่ผ่านการยืนยันเข้ากับมุมมองในแอปพลิเคชัน iOS โดยตรง การกำหนดเส้นทาง Deep Link เชิงเทคนิค / เชิงให้ข้อมูล
Custom URL Scheme รูปแบบ URI ที่แอปกำหนดขึ้นเองเพื่อใช้สำหรับนำทาง URL เข้าสู่แอปพลิเคชันเนทีฟ Mobile Deep Linking เชิงให้ข้อมูล

การโต้ตอบระหว่าง WKWebView และการกำหนดเส้นทาง Universal Link บน iOS

WKNavigationDelegate ตัดสินใจว่าจะให้ WebKit โหลด, กำหนดเส้นทางภายใน, ส่งต่อ หรือยกเลิกการนำทาง

วงจรการนำทางของ WebKit และนโยบายการกำหนดเส้นทางของแอป

Apple ใช้ Universal Links เป็นกลไกการกำหนดเส้นทางระดับระบบที่รองรับทั้งใน Safari และสภาพแวดล้อม WKWebView เมื่อผู้ใช้แตะลิงก์ที่เข้าเกณฑ์ภายใน WKWebView ที่ฝังอยู่ ระบบจะสามารถแก้ไขความสัมพันธ์ของโดเมนและดำเนินการกำหนดเส้นทางตามนโยบายของระบบปฏิบัติการ

แม้ว่า Universal Links ที่ระบบรู้จักจะสามารถส่งต่อการดำเนินการไปยังตัวจัดการเนทีฟได้ แต่สภาพแวดล้อมของเบราว์เซอร์ที่ฝังอยู่มักต้องการตรรกะการกำหนดเส้นทางเฉพาะของแอปพลิเคชัน ตัวอย่างเช่น เมื่อลิงก์ชี้ไปยังโดเมนของแอปเอง นักพัฒนามักต้องการให้มีการนำทางผ่าน view controllers ของเนทีฟโดยตรงแทนที่จะเปิดแอปภายนอกขึ้นมาใหม่ทั้งหมด การใช้งาน WKNavigationDelegate ช่วยให้แอปพลิเคชันหลักสามารถควบคุมการประเมินลิงก์ได้อย่างละเอียด ช่วยให้ทีมสามารถบังคับใช้ allowlist ที่กำหนดเองและกำหนดเส้นทางภายในได้อย่างแม่นยำ

อุปสรรคด้านประสบการณ์ผู้ใช้: เมื่อการท่องเว็บในแอปติดลูปการเปลี่ยนเส้นทาง

WebView ที่ฝังอยู่มักถูกใช้เพื่อแสดงไมโครไซต์โปรโมชัน, ศูนย์ช่วยเหลือ, แคตตาล็อกพันธมิตร และหน้า Landing Page ของการตลาดภายในแอป iOS เมื่อหน้าเว็บภายในแอปมีลิงก์ที่ตั้งใจจะพาผู้ใช้ไปยังส่วนอื่นๆ ของแอปหลัก (เช่น ปุ่ม "ดูในแอป") หรือไปยังแอปพันธมิตร การนำทางโดยค่าเริ่มต้นอาจนำไปสู่การแสดงผลที่ซ้ำซ้อน:

  • การแสดงผลเว็บที่ซ้ำซ้อน: แทนที่จะโหลดหน้าจอเนทีฟ ผู้ใช้อาจถูกนำไปยังหน้าเว็บที่ปรับขนาดตามอุปกรณ์ของหน้าในแอป ทำให้ต้องล็อกอินซ้ำและเสียความสอดคล้องทางภาพ
  • การติดลูปบนเว็บ: ผู้ใช้อาจติดอยู่ใน Stack การนำทางของเว็บโดยไม่มีทางกลับไปยังอินเทอร์เฟซหลักของแอปเนทีฟได้ง่าย
  • การเปลี่ยนจากแอปหนึ่งไปอีกแอปหนึ่งล้มเหลว: การแตะลิงก์ที่ชี้ไปยังบริการของบุคคลที่สาม (เช่น แอปนำทาง, หน้าต่างแชร์โซเชียล หรือเกตเวย์ชำระเงิน) จำเป็นต้องมีการมอบหมายสิทธิ์ที่ชัดเจนหากบริการเหล่านั้นอาศัย Custom URL schemes

เปรียบเทียบ WKWebView กับ SFSafariViewController สำหรับการส่งต่อ Web-to-App

เมื่อออกแบบการท่องเว็บภายในแอปบน iOS ทีมวิศวกรต้องเลือกระหว่าง WKWebView และ SFSafariViewController:

  • SFSafariViewController: มอบอินเทอร์เฟซเบราว์เซอร์ Safari ที่จัดการโดยระบบและเป็นอิสระ พร้อมคุณสมบัติเช่น AutoFill และการบล็อกเนื้อหา แอปพลิเคชันหลักไม่สามารถตรวจสอบกิจกรรมการท่องเว็บหรือข้อมูลเว็บไซต์ได้ และการปรับแต่ง UI จำกัดเพียงแค่สีพื้นหลัง
  • WKWebView: เป็นองค์ประกอบมุมมองที่ฝังอยู่ภายในกระบวนการ UI ของแอปขณะที่รันเนื้อหาเว็บในกระบวนการ WebKit แยกต่างหาก ช่วยให้สามารถปรับแต่ง UI ได้อย่างลึกซึ้ง, ใช้ JavaScript bridges และรวมเลย์เอาต์ที่กำหนดเองได้ โดยจำเป็นต้องมีการตั้งค่า WKNavigationDelegate อย่างชัดเจนเพื่อกำหนดนโยบายการกำหนดเส้นทางและจัดการ Custom Schemes

decidePolicyForNavigationAction ดักจับการนำทางของ WebKit อย่างไร

ไปป์ไลน์นโยบายการนำทาง: ทำความเข้าใจ WKNavigationAction, request และ decisionHandler

ในการควบคุมลำดับการนำทางภายใน WKWebView นักพัฒนาจะมอบหมาย delegate ที่เป็นไปตาม คำแนะนำของ Apple เกี่ยวกับ WKNavigationDelegate จุดดักจับหลักคือเมธอด delegate:

func webView(
    _ webView: WKWebView,
    decidePolicyFor navigationAction: WKNavigationAction,
    decisionHandler: @escaping (WKNavigationActionPolicy) -> Void
)

การดำเนินการนำทางที่เกิดจากการโต้ตอบของผู้ใช้, การเปลี่ยนเส้นทางโดยโปรแกรม หรือการส่งฟอร์ม จะผ่านเมธอดนี้ โดยออบเจกต์ WKNavigationAction จะให้เมตาข้อมูลที่สำคัญ:

  • navigationAction.request.url: URL ปลายทางที่ถูกร้องขอ
  • navigationAction.navigationType: ประเภทของตัวกระตุ้น (.linkActivated, .other, .formSubmitted)
  • navigationAction.sourceFrame: ข้อมูลเกี่ยวกับเฟรมที่เริ่มคำขอการนำทาง
  • navigationAction.targetFrame: ข้อมูลเกี่ยวกับเฟรมปลายทางที่ต้องการโหลดเนื้อหา

decisionHandler คือ closure ที่แจ้งให้ WebKit ทราบว่าจะอนุญาตหรือยกเลิกการนำทางที่ร้องขอ

เมื่อใดที่ควรส่งคืน .allow เทียบกับ .cancel: การควบคุมวงจรการโหลดทรัพยากรของ WebKit

WKNavigationActionPolicy ที่ส่งไปยัง decisionHandler จะควบคุมว่า WebKit จะดำเนินการนำทางต่อหรือไม่:

  • .allow: แจ้งให้ WebKit ดำเนินการนำทางต่อไปภายใน web view
  • .cancel: สั่งให้ WebKit ยกเลิกการนำทางที่ร้องขอ นโยบายนี้จะดำเนินการเมื่อแอปพลิเคชันดักจับ Custom Scheme, กำหนดเส้นทาง Universal Link ภายใน, หรือส่งต่อเป้าหมายภายนอกไปยัง UIApplication.shared.open()

decisionHandler จะต้องถูกเรียกใช้งานหนึ่งครั้งต่อการกระทำหนึ่งอย่าง เพื่อให้แน่ใจว่านโยบายการนำทางดำเนินไปโดยไม่หยุดชะงัก

การประเมินประเภทการนำทาง: การแยกแยะการคลิกของผู้ใช้ (.linkActivated) จากการ Redirect อัตโนมัติ

WKNavigationAction.navigationType ช่วยให้นักพัฒนาแยกแยะการโต้ตอบของผู้ใช้ที่ชัดเจนจากสคริปต์อัตโนมัติ:

  • .linkActivated: ผู้ใช้แตะลิงก์ HTML anchor tag (<a href="...">) โดยตรง
  • .other: แสดงถึงการนำทางโดยโปรแกรม เช่น การอัปเดต window.location.href, meta refresh หรือการเรียก webView.load() ครั้งแรก
  • .formSubmitted / .formResubmitted: แสดงถึงการส่งฟอร์มแบบ POST หรือ GET

การประเมิน navigationType ช่วยให้แอปพลิเคชันบังคับใช้นโยบายการเปิดลิงก์ที่ชัดเจน สำหรับการเรียก Custom Scheme ภายนอกหรือการส่งต่อไปยังแอปอื่น การกำหนดให้ต้องเป็น .linkActivated จะช่วยป้องกันไม่ให้สคริปต์เบื้องหลังที่ไม่ได้ตั้งใจเรียกการเปิดแอปภายนอกโดยอัตโนมัติ

การจัดการนโยบายการตัดสินใจแบบ Asynchronous โดยไม่เกิด Retain Cycle

เมื่อการตรวจสอบเส้นทางหรือสิทธิ์ต้องมีการสอบถามแคชในเครื่องหรือตัวตรวจสอบความปลอดภัยก่อนส่งคืนการตัดสินใจ:

  1. ตรวจสอบให้แน่ใจว่า decisionHandler ถูกเรียกใช้งานในทุกเส้นทาง รวมถึงกรณีที่มีข้อผิดพลาด
  2. ใช้ weak references ([weak self]) ภายใน escaping closures เพื่อป้องกัน retain cycles ระหว่าง WKWebView, delegate ของมัน และ UIViewController แม่

การแยกความแตกต่างระหว่าง Associated Domains ของแอปกับ Universal Links ภายนอก

Universal Links ที่เป็นของแอปควรได้รับการตรวจสอบและกำหนดเส้นทางภายในจาก WKWebView

การจัดการปลายทางที่เป็นของแอปเทียบกับการมอบหมายลิงก์ระดับระบบ

สำหรับเส้นทางที่เป็นของแอปเอง ให้หลีกเลี่ยงการพยายามกลับเข้าสู่แอปเดิมผ่านการค้นหา Universal Link ซ้ำซ้อน ให้จัดการปลายทางที่เป็นของแอปโดยตรงผ่านตัวกำหนดเส้นทางภายในของแอป และใช้การเปิดระบบหลักสำหรับปลายทางที่ควรออกจากแอปปัจจุบันหรือควรแก้ไขโดยบริการภายนอก

สถาปัตยกรรมที่แยกส่วนนี้ช่วยให้การนำทางราบรื่น:

  • Associated Domains ของแอป: หาก URL host ตรงกับโดเมนที่เกี่ยวข้องของแอป (app.example.com) ให้ยกเลิกการนำทางของ web view (decisionHandler(.cancel)), ตรวจสอบ path ของเส้นทาง, และส่งพารามิเตอร์ที่แยกวิเคราะห์แล้วไปยังตัวกำหนดเส้นทางภายในของแอปโดยตรง
  • แอปพลิเคชันภายนอก: หาก URL ชี้ไปยังปลายทางของพันธมิตรภายนอกหรือ Custom Scheme ที่ได้รับอนุญาต ให้ใช้นโยบายการเปิดลิงก์ที่ชัดเจนระดับแอป (navigationType == .linkActivated), ยกเลิกการนำทาง web view, และส่งต่อคำขอไปยัง UIApplication.shared.open(url) เพื่อให้ระบบปฏิบัติการเปิดแอปภายนอก

การออกแบบการตรวจสอบเส้นทางภายใน: การสกัด Path และ Query Parameters ผ่าน AppRouteValidator

เมื่อ URL ที่เข้ามาตรงกับโดเมนที่เกี่ยวข้องของแอปพลิเคชัน สตริงของ URL จะต้องผ่านการตรวจสอบเส้นทางที่เข้มงวดก่อนที่จะเปิดใช้การเปลี่ยนหน้าของ view controller

โมเดล AppRouteValidator:

  • ตรวจสอบ Path ของ URL เทียบกับ allowlist ของเส้นทางภายในที่รองรับ (เช่น /open/, /product/, /promo/, /checkout/)
  • สกัด Query Parameters (เช่น id, promo, utm_source)
  • บังคับใช้ข้อจำกัดของชุดอักขระ, ขอบเขตความยาว และการปฏิเสธคีย์ที่ซ้ำกัน โดยส่งคืนโครงสร้างข้อมูล ValidatedAppRoute ที่สะอาด

การจัดการ Universal Links ของบุคคลที่สามผ่านระบบ UIApplication Delegation

Universal Links ภายนอกสามารถพยายามส่งต่อแบบเนทีฟและสำรองข้อมูลไปยังเว็บได้

เมื่อหน้าเว็บภายใน WKWebView เชื่อมโยงไปยังบริการภายนอก (เช่น แอปพันธมิตร, แพลตฟอร์มโซเชียล หรือยูทิลิตี้ภายนอก) แอปพลิเคชันหลักสามารถมอบหมายการกำหนดเส้นทางให้กับระบบ iOS ได้:

let options: [UIApplication.OpenExternalURLOptionsKey: Any] = [
    .universalLinksOnly: true
]
UIApplication.shared.open(url, options: options) { success in
    if !success {
        // นโยบายสำรอง: โหลดปลายทางเว็บหากไม่มีแอปเนทีฟจัดการ Universal Link
    }
}

การจัดการ Custom URL Scheme (myapp://) ควบคู่กับ HTTPS Universal Links

ในขณะที่ HTTPS Universal Links เป็นมาตรฐานของ Deep Linking บน iOS แต่ Custom Scheme ที่แอปกำหนดขึ้น (เช่น myapp:// หรือ partnerapp://) ก็ยังคงพบเห็นได้ทั่วไปในแคมเปญโปรโมชันและการเชื่อมต่อกับพันธมิตร

ในการใช้งาน WKNavigationDelegate แบบรวมศูนย์:

  • ตรวจสอบ Scheme ที่ไม่ใช่ HTTP/HTTPS ก่อน หาก scheme ตรงกับโปรโตคอลที่ได้รับอนุญาตและเป็นไปตามนโยบายการเปิดลิงก์ (navigationType == .linkActivated) delegate จะตรวจสอบ host, path และพารามิเตอร์ก่อนส่งไปยัง UIApplication.shared.open()
  • Scheme ที่ไม่รู้จักหรือไม่ได้รับคำสั่งให้เปิดจะถูกยกเลิกทันที เพื่อป้องกันข้อผิดพลาดในการนำทางหรือการเรียกใช้งานสคริปต์โดยไม่ตั้งใจ
[ผู้ใช้โต้ตอบกับลิงก์ภายใน iOS WKWebView]
                       │
                       ▼
[WKNavigationDelegate: decidePolicyForNavigationAction]
                       │
         ┌─────────────┴─────────────┐
         ▼                           ▼
[!action.sourceFrame.isMainFrame] [action.sourceFrame.isMainFrame]
         │                           │
         ▼                           ▼
[ความปลอดภัยของ Subframe]      [ตรวจสอบ Scheme & Host ปลายทาง]
├─ HTTP(S) -> .allow                 │
└─ Non-Web -> .cancel    ┌───────────┼───────────┐
   (ระงับ Subframe)   ▼           ▼           ▼
                   [Host Domain] [เว็บภายนอก] [Custom Scheme]
                         │           │           │
                         ▼           ▼           ▼
                   [AppRoute]    [ตรวจสอบลิงก์]   [ตรวจสอบลิงก์]
                   ├─ ถูกต้อง ->   ├─ พันธมิตร->   ├─ ถูกต้อง & คลิก->
                   │  ภายใน        │  เปิดแอป      │  เปิดแอป
                   └─ ไม่ถูกต้อง->  └─ เว็บ ->      └─ ไม่ถูกต้อง/Auto->
                      .cancel       .allow         .cancel

วิธีบังคับใช้ความปลอดภัยของ Main Frame และป้องกัน Iframe Hijacking

ต้นทางเฟรมและบริบทเป้าหมายของ WKNavigationAction กำหนดนโยบายการนำทางที่ปลอดภัย

การปฏิบัติต่อการนำทางเว็บที่ฝังตัวว่าเป็นอินพุตที่ไม่น่าเชื่อถือ: มาตรฐานความปลอดภัย Deep Link ของ OWASP

ตาม แนวทางปฏิบัติของ OWASP เกี่ยวกับ Deep Links ที่ไม่ปลอดภัย URL และพารามิเตอร์ทั้งหมดที่ประมวลผลโดยตัวจัดการการนำทางบนมือถือจะต้องได้รับการปฏิบัติว่าเป็นอินพุตภายนอกที่ไม่น่าเชื่อถือ

หน้าเว็บที่แสดงผลภายใน WKWebView อาจโหลดสคริปต์ของบุคคลที่สาม, แบนเนอร์โฆษณา หรือเนื้อหาที่ผู้ใช้สร้างขึ้น หาก navigation delegate ส่งต่อ URL ตามอำเภอใจไปยัง native view controller หรือ UIApplication.shared.open() โดยไม่มีการตรวจสอบ พารามิเตอร์ที่ไม่คาดคิดอาจกำหนดเป้าหมายไปยังเส้นทางภายในแอปที่ละเอียดอ่อนได้

การแยกการนำทางของ Main Frame ออกจาก Iframe และเป้าหมายหน้าต่างใหม่

ตาม เอกสารของ Apple เกี่ยวกับ WKNavigationAction การประเมินความปลอดภัยของเฟรมต้องมีการตรวจสอบเฟรมที่เป็นต้นทาง:

  • sourceFrame.isMainFrame == true: การนำทางถูกเริ่มต้นโดยตรงจากเฟรมหลักของเอกสาร
  • sourceFrame.isMainFrame == false: การนำทางถูกเริ่มต้นโดย subframe หรือ iframe ที่ฝังอยู่
  • targetFrame == nil: การนำทางร้องขอเป้าหมายหน้าต่างใหม่ (เช่น anchor ที่มี target="_blank")

เพื่อป้องกัน iframe hijacking (ที่ iframe พยายามเปิดแอปภายนอกหรือเรียกการเปลี่ยนหน้าจอในพื้นหลัง) delegate จะต้องประเมิน sourceFrame.isMainFrame หากเฟรมที่เริ่มต้นเป็น iframe (sourceFrame.isMainFrame == false) ให้ยอมรับการนำทาง HTTP/HTTPS ปกติ (.allow) แต่บล็อก Custom Scheme ที่ไม่ใช่เว็บ หรือการส่งต่อเส้นทางเนทีฟ (.cancel)

การป้องกันการเรียกใช้โปรโตคอล Subframe ที่ประสงค์ร้ายและการยิงสคริปต์

การบังคับใช้การตรวจสอบเฟรมต้นทางจะช่วยป้องกันไม่ให้ subframe เรียกใช้ Custom Scheme ภายนอกโดยไม่ได้ตั้งใจ:

if !navigationAction.sourceFrame.isMainFrame {
    let scheme = url.scheme?.lowercased() ?? ""
    if scheme == "http" || scheme == "https" {
        decisionHandler(.allow) // อนุญาตการนำทาง Subframe แบบปกติ
    } else {
        decisionHandler(.cancel) // ระงับ Custom Scheme ที่ไม่ใช่เว็บจาก Subframe
    }
    return
}

การบังคับใช้ Allowlists ของ Path และพารามิเตอร์อย่างเข้มงวดในการกำหนดเส้นทาง

ทั้ง URL โดเมนภายในและ Custom Scheme ภายนอกจะต้องผ่านโมเดลการตรวจสอบที่เข้มงวดก่อนการดำเนินการ:

  • Path Prefix Allowlists: บังคับใช้ Prefix เส้นทางที่ได้รับอนุมัติ (เช่น /open/, /product/, /promo/, /checkout/) และปฏิเสธเส้นทางที่ผิดปกติ
  • Query Key Filtering: ทิ้ง Query Key ที่ไม่คาดคิดและปฏิเสธคีย์พารามิเตอร์ซ้ำเพื่อป้องกันปัญหาพารามิเตอร์ที่ไม่ถูกต้อง
  • ข้อจำกัดด้านชนิดข้อมูลและความยาว: จำกัดพารามิเตอร์ให้อยู่ในชุดอักขระตัวเลขและตัวอักษร และจำกัดความยาวสูงสุดไม่เกิน 64 ตัวอักษร

การใช้งาน WKNavigationDelegate ในขั้นตอนการผลิตด้วย Swift

การจัดโครงสร้าง CustomWebViewController และสถาปัตยกรรม Delegate ใน Swift

คอนโทรลเลอร์ WKWebView ที่พร้อมใช้งานในขั้นตอนการผลิตจะประสานการตั้งค่าเว็บ, การประเมินนโยบาย, การกำหนดเส้นทางภายใน และการส่งต่อภายนอก การใช้งานนี้จะห่อหุ้มกฎการตรวจสอบภายในคลาส validator (AppRouteValidator และ CustomSchemeValidator) เพื่อให้ delegate callback สะอาด, ทดสอบได้ และปลอดภัย

การใช้งานโมเดล AppRouteValidator และ CustomSchemeValidator

โมเดล validator จะบังคับใช้ความปลอดภัยแบบปิดเมื่อเกิดข้อผิดพลาด:

  • AppRouteValidator ตรวจสอบโดเมนที่เกี่ยวข้องภายใน โดยตรวจสอบ Path Prefix และตรวจสอบพารามิเตอร์ให้อยู่ในออบเจกต์ ValidatedAppRoute
  • CustomSchemeValidator ตรวจสอบ Custom Scheme ที่ได้รับอนุญาต (myapp), ตรวจสอบ Host ที่ได้รับอนุญาต (open, product, event) และล้างค่าพารามิเตอร์

OpoInstall สามารถรวมเข้ากับเลเยอร์การกำหนดเส้นทางของแอปพลิเคชันเพื่อการระบุแหล่งที่มา (Attribution) และการกู้คืนพารามิเตอร์ที่ล่าช้า ตรวจสอบ เอกสารประกอบการรวม SDK สำหรับคำแนะนำแบบครบถ้วน

การดำเนินการทางเทคนิคด้านล่างแสดงวิธีการตั้งค่า WKNavigationDelegate ที่ปลอดภัยใน Swift:

// iOS: CustomWebViewController พร้อมการกำหนดเส้นทางและความปลอดภัยของเฟรมที่เข้มงวด
import UIKit
import WebKit

struct ValidatedAppRoute {
    let path: String
    let queryParams: [String: String]
}

// 1. Validator สำหรับโดเมนของแอปเอง (Internal Routes)
class AppRouteValidator {
    private static let allowedPrefixes = ["/open/", "/product/", "/promo/", "/checkout/"]
    private static let allowedQueryKeys = Set(["target", "id", "promo", "utm_source"])

    static func validate(url: URL) -> ValidatedAppRoute? {
        let path = url.path
        guard allowedPrefixes.contains(where: { path.hasPrefix($0) }) else {
            return nil
        }

        var sanitizedParams: [String: String] = [:]
        var seenKeys = Set<String>()

        if let components = URLComponents(url: url, resolvingAgainstBaseURL: false),
           let queryItems = components.queryItems {
            let validChars = CharacterSet(charactersIn: "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-")
            
            for item in queryItems {
                guard allowedQueryKeys.contains(item.name), !seenKeys.contains(item.name) else { return nil }
                seenKeys.insert(item.name)

                let value = item.value ?? ""
                if value.count <= 64 && value.rangeOfCharacter(from: validChars.inverted) == nil {
                    sanitizedParams[item.name] = value
                } else {
                    return nil
                }
            }
        }

        return ValidatedAppRoute(path: path, queryParams: sanitizedParams)
    }
}

// 2. Validator สำหรับ Custom Schemes (myapp://)
class CustomSchemeValidator {
    private static let allowedSchemes = Set(["myapp"])
    private static let allowedHosts = Set(["open", "product", "event"])
    private static let allowedPathPrefixes = ["/detail/", "/view/", "/main/"]
    private static let allowedQueryKeys = Set(["target", "id", "promo", "utm_source"])

    static func validate(url: URL) -> URL? {
        guard let scheme = url.scheme?.lowercased(), allowedSchemes.contains(scheme) else {
            return nil
        }
        guard let host = url.host?.lowercased(), allowedHosts.contains(host) else {
            return nil
        }

        let path = url.path
        if !path.isEmpty && !allowedPathPrefixes.contains(where: { path.hasPrefix($0) }) {
            return nil
        }

        var seenKeys = Set<String>()
        if let components = URLComponents(url: url, resolvingAgainstBaseURL: false),
           let queryItems = components.queryItems {
            let validChars = CharacterSet(charactersIn: "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-")
            for item in queryItems {
                guard allowedQueryKeys.contains(item.name), !seenKeys.contains(item.name) else { return nil }
                seenKeys.insert(item.name)

                let value = item.value ?? ""
                if value.count > 64 || value.rangeOfCharacter(from: validChars.inverted) != nil {
                    return nil
                }
            }
        }

        return url
    }
}

// 3. UIViewController ที่โฮสต์ WKWebView พร้อมการดักจับนโยบายความปลอดภัย
class CustomWebViewController: UIViewController, WKNavigationDelegate {

    var webView: WKWebView!
    private let hostAssociatedDomain = "app.example.com"
    private let allowedExternalPartnerHosts = Set(["partner.example.com"])

    override func viewDidLoad() {
        super.viewDidLoad()

        let configuration = WKWebViewConfiguration()
        webView = WKWebView(frame: view.bounds, configuration: configuration)
        webView.navigationDelegate = self
        view.addSubview(webView)
    }

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

        if !navigationAction.sourceFrame.isMainFrame {
            let scheme = url.scheme?.lowercased() ?? ""
            if scheme == "http" || scheme == "https" {
                decisionHandler(.allow)
            } else {
                decisionHandler(.cancel)
            }
            return
        }

        let scheme = url.scheme?.lowercased() ?? ""
        let isExplicitLinkActivation = (navigationAction.navigationType == .linkActivated)

        if scheme == "https", let host = url.host?.lowercased(), host == hostAssociatedDomain {
            if let validatedRoute = AppRouteValidator.validate(url: url) {
                AppInternalRouter.shared.navigate(to: validatedRoute)
            }
            decisionHandler(.cancel)
            return
        }

        if scheme != "http" && scheme != "https" && scheme != "about" {
            if isExplicitLinkActivation, let validatedURL = CustomSchemeValidator.validate(url: url) {
                UIApplication.shared.open(validatedURL, options: [:], completionHandler: nil)
            }
            decisionHandler(.cancel)
            return
        }

        if scheme == "http" || scheme == "https" {
            let host = url.host?.lowercased() ?? ""
            
            if allowedExternalPartnerHosts.contains(host) && isExplicitLinkActivation {
                let options: [UIApplication.OpenExternalURLOptionsKey: Any] = [
                    .universalLinksOnly: true
                ]
                UIApplication.shared.open(url, options: options) { [weak self] success in
                    if !success {
                        guard let self = self else { return }
                        self.webView.load(navigationAction.request)
                    }
                }
                decisionHandler(.cancel)
                return
            }

            if navigationAction.targetFrame == nil {
                webView.load(navigationAction.request)
                decisionHandler(.cancel)
                return
            }

            decisionHandler(.allow)
            return
        }

        decisionHandler(.allow)
    }
}

class AppInternalRouter {
    static let shared = AppInternalRouter()
    func navigate(to route: ValidatedAppRoute) {}
}

การดำเนินการที่ปลอดภัย (Thread-Safe): การเปลี่ยนหน้า UI บน Main Actor

ในโมเดล concurrency ของ Swift ปัจจุบัน callback ของ WKNavigationDelegate จะถูกแยกส่วนบน main-actor การกำหนดเส้นทางของแอปและการเปลี่ยน view controller จะดำเนินการบน main-actor เพื่อคงความปลอดภัยของ Thread ตลอดขั้นตอนการนำทาง

ข้อผิดพลาดในการนำทาง Deep Link ใน WKWebView และตารางวิเคราะห์

คู่มือแก้ไขปัญหา Deep Linking สำหรับ iOS WKWebView

อาการของข้อผิดพลาด สาเหตุหลัก เวอร์ชัน iOS จุดตรวจสอบ วิธีแก้ไข
Universal Link โหลดเป็นเว็บ โดเมนของแอปไม่ถูกดักจับ iOS 9+ ไม่ได้จัดการ decidePolicyForNavigationAction ดักจับโดเมนโฮสต์, สกัด path, กำหนดเส้นทางภายใน, .cancel
ลิงก์ของตัวเองกำหนดเส้นทางไม่สำเร็จ เรียก UIApplication.open ไปยังโดเมนตัวเอง iOS 9+ เรียกใช้ UIApplication.shared.open บนโฮสต์ตัวเอง หลีกเลี่ยงการเปิดตัวเองผ่านภายนอก; ส่งตรงไปยัง router ภายใน
Custom Scheme เงียบหายไป WebKit ไม่รู้จักโปรโตคอลที่ไม่ใช่ HTTP iOS 9+ Scheme ไม่ถูกส่งต่อให้ UIApplication ดักจับ scheme ใน delegate, ตรวจสอบ allowlist, เปิดผ่าน UIApplication
Iframe ปลอมแปลงโปรโตคอล Subframe เรียก Custom Scheme ภายนอก iOS 9+ sourceFrame.isMainFrame ไม่ได้ตรวจสอบ ใช้ if !sourceFrame.isMainFrame เพื่อระงับ scheme ที่ไม่ใช่เว็บ
ปัญหาการส่งต่อ UI การเปลี่ยน UI ไม่ได้อยู่บน thread หลัก iOS 9+ ขาดการ dispatch บน main-actor ตรวจสอบการใช้ main-actor สำหรับ router และการเปลี่ยนหน้าจอ

คำถามที่พบบ่อย (FAQ)

นักพัฒนาจะดักจับ Universal Links ใน WKWebView ได้อย่างไร?
นักพัฒนาต้องใช้ `WKNavigationDelegate` และตรวจสอบ URL ที่เข้ามาภายใน `decidePolicyForNavigationAction` หาก URL ตรงกับปลายทางที่เป็นของแอปเอง delegate จะยกเลิกการนำทางด้วย `.cancel` และส่งพารามิเตอร์ที่ผ่านการตรวจสอบไปยังตัวกำหนดเส้นทางภายในของแอปโดยตรง
ฉันสามารถใช้ UIApplication.shared.open เพื่อเปิดแอปของตัวเองจาก WKWebView ได้หรือไม่?
เอกสารของ Apple ระบุว่าการเรียก `UIApplication.shared.open()` บน Universal Link ที่ชี้ไปยังโดเมนของแอปเอง จะไม่เปิดลิงก์ในแอปแบบ Universal Link สำหรับลิงก์โดเมนตัวเอง แอปพลิเคชันควรยกเลิกการนำทางใน webview แล้วเรียกใช้ตัวกำหนดเส้นทางภายในแอปแทน
ฉันจะป้องกันไม่ให้ Iframe ใน WKWebView เรียกการเปิดแอปภายนอกได้อย่างไร?
เพื่อป้องกัน iframe hijacking ให้ตรวจสอบ `navigationAction.sourceFrame.isMainFrame` ภายใน `decidePolicyForNavigationAction` หาก `isMainFrame` เป็น `false` ให้ยอมรับการนำทาง HTTP(S) ปกติ แต่ให้ยกเลิก Custom Scheme ที่ไม่ใช่เว็บด้วย `.cancel` เพื่อป้องกันไม่ให้ iframe ของบุคคลที่สามเปิดแอปภายนอกโดยไม่ได้ตั้งใจ

สรุปและเฟรมเวิร์กการตัดสินใจ

การจัดการ Universal Links และ Custom Schemes ภายใน WKWebView ของ iOS จำเป็นต้องเชื่อมช่องว่างระหว่างคอนเทนเนอร์แสดงผลเว็บของ WebKit และวงจรการนำทางของ UIKit การพึ่งพานโยบายการนำทางเริ่มต้นอาจทำให้การส่งต่อข้อมูลไม่ราบรื่นเมื่อต้องการตรรกะการกำหนดเส้นทางเฉพาะของแอปพลิเคชัน

ด้วยการใช้งาน WKNavigationDelegate ที่แข็งแกร่งซึ่งตรวจสอบขอบเขตเฟรม, บังคับใช้นโยบายการเปิดลิงก์ที่ปลอดภัยสำหรับการส่งต่อภายนอก, แยกวิเคราะห์โดเมนภายในผ่านเครื่องมือตรวจสอบเส้นทางที่เข้มงวด และส่งต่อเป้าหมายภายนอกไปยัง UIApplication.shared.open อย่างปลอดภัย ทีมวิศวกรจะสามารถควบคุมการนำทางในขณะที่ป้องกันการโจมตีแบบ iframe ได้

หากต้องการสำรวจสถาปัตยกรรมการกำหนดเส้นทางพารามิเตอร์และ Deep Linking สำหรับ iOS โปรดดู เอกสารประกอบการรวม SDK

เนื้อหาที่เกี่ยวข้อง

Share this article

Keep Discovering

วิธีที่นักพัฒนาอ่านคำอธิบาย API สำหรับคอลแบ็ก Deep Linking

วิธีที่นักพัฒนาอ่านคำอธิบาย API สำหรับคอลแบ็ก Deep Linking

สำรวจคำอธิบาย API หลักใน SDK การระบุแหล่งที่มาของมือถือ เรียนรู้ลายเซ็นต์เมธอด getInstallParam และ getWakeUpParams, สคีมาเพย์โหลด และกฎวงจรชีวิต

Google เปิดตัว Gemini 4 Hydrogen? ความเร็วในการเขียนโค้ดเปลี่ยนไปอย่างไร

Google เปิดตัว Gemini 4 Hydrogen? ความเร็วในการเขียนโค้ดเปลี่ยนไปอย่างไร

คำอธิบาย: Google เปิดตัว Gemini 4 Hydrogen สำหรับงานเขียนโค้ดที่มีปริมาณงานสูง ค้นพบการเปรียบเทียบเบนช์มาร์ก การกำหนดเส้นทางแบบหลายโมเดล และข้อแลกเปลี่ยนในการใช้งานจริง

Google Android XR เชื่อมต่อกับ iOS ได้หรือไม่? แว่นตาอัจฉริยะสามารถเชื่อมโยงระบบต่างๆ เข้าด้วยกันได้หรือเปล่า

Google Android XR เชื่อมต่อกับ iOS ได้หรือไม่? แว่นตาอัจฉริยะสามารถเชื่อมโยงระบบต่างๆ เข้าด้วยกันได้หรือเปล่า

Google เปิดตัวแว่นตา Android XR ที่มาพร้อมการรับรอง MFi สำหรับ iOS ค้นพบสถาปัตยกรรมแอปคู่หูข้ามแพลตฟอร์ม Wi-Fi Aware และมาตรการปกป้องความเป็นส่วนตัว