https://github.com/QQuik/li2-swift-sdk

import SwiftUI
import Li2SDK

@main
struct MyApp: App {
    init() {
        Li2.configure(
            publishableKey: "li2_pk_your_key",
            deepLinkDomains: ["app.example.com"]
        )
    }

    @StateObject private var deepLinks = DeepLinkModel()

    var body: some Scene {
        WindowGroup {
            RootView()
                .environmentObject(deepLinks)
                .li2DeepLink(using: deepLinks.resolver)   // nối UL + deferred grace
                .fullScreenCover(isPresented: $deepLinks.showConsent) {
                    ConsentSheet(resolver: deepLinks.resolver)
                }
        }
    }
}

import SwiftUI
import Combine
import Li2SDK

@MainActor
final class DeepLinkModel: ObservableObject {
    @Published var route: URL?
    @Published var showConsent = false

    private(set) lazy var resolver = Li2DeepLinkResolver { [weak self] outcome in
        switch outcome {
        case let .matched(destination, clickId):
            // Điều hướng theo destination (đã bóc li2_cid).
            self?.route = destination
        case let .missed(reason):
            // Không khớp link nào — hiển thị màn hình chính bình thường.
            break
        case let .failed(error):
            // Lỗi mạng / HTTP / parse — xử lý tùy app.
            break
        }
    }

    private var bag = Set<AnyCancellable>()
    init() {
        // Phản chiếu cờ đồng ý của SDK để điều khiển sheet.
        resolver.$isConsentPending
            .receive(on: RunLoop.main)
            .sink { [weak self] in self?.showConsent = $0 }
            .store(in: &bag)
    }
}

import SwiftUI
import UIKit
import Li2SDK

struct ConsentSheet: View {
    let resolver: Li2DeepLinkResolver
    @Environment(\.scenePhase) private var scenePhase

    /// nil = đang probe, true/false = clipboard có nội dung hay không.
    @State private var clipboardHasContent: Bool?

    var body: some View {
        VStack(spacing: 24) {
            Spacer()
            Text("Chào mừng").font(.largeTitle.bold())
            Text("Bạn đến từ một link chia sẻ. Tiếp tục để mở đúng nội dung đó.")
                .multilineTextAlignment(.center)
            Spacer()

            primaryButton

            Button("Bỏ qua") { resolver.submitOptOut() }
        }
        .padding(24)
        .onAppear(perform: probeClipboard)
        // (b) Re-probe khi foreground: người dùng có thể tắt app, copy link, quay lại.
        // Không có dòng này, trạng thái nút sẽ bị cũ.
        .onChange(of: scenePhase) { phase in
            if phase == .active { probeClipboard() }
        }
    }

    // Chỉ kiểm tra sự có mặt (hasStrings/hasURLs) — không bao giờ bật alert hệ thống.
    private func probeClipboard() {
        clipboardHasContent = UIPasteboard.general.hasStrings
            || UIPasteboard.general.hasURLs
    }

    @ViewBuilder
    private var primaryButton: some View {
        if #available(iOS 16.0, *), clipboardHasContent != false {
            // iOS 16+: dùng Li2PasteButton — cú chạm của người dùng là sự đồng ý,
            // iOS không hiện alert "Allow Paste".
            Li2PasteButton { raw in
                resolver.submitPasteControlResult(raw)
            }
            .frame(height: 52)
        } else {
            // (a) Clipboard rỗng (Li2PasteButton tự disable): phải có nút thay thế —
            // không thì người dùng bị kẹt và outcome `empty` không bao giờ được gửi.
            Button("Tiếp tục") { resolver.submitPasteControlEmpty() }
        }
    }
}

import UIKit
import Li2SDK

final class SceneDelegate: UIResponder, UIWindowSceneDelegate {

    let resolver = Li2DeepLinkResolver { outcome in
        // switch outcome — điều hướng như ví dụ SwiftUI
    }

    // Universal Link cold launch / continuation
    func scene(_ scene: UIScene,
               continue userActivity: NSUserActivity) {
        guard userActivity.activityType == NSUserActivityTypeBrowsingWeb,
              let url = userActivity.webpageURL else { return }
        resolver.handle(url: url)
    }

    // Universal Link / custom scheme khi app đang chạy
    func scene(_ scene: UIScene,
               openURLContexts contexts: Set<UIOpenURLContext>) {
        for ctx in contexts { resolver.handle(url: ctx.url) }
    }

    // Kích hoạt deferred gate — gọi một lần, sau cửa sổ chờ.
    func sceneDidBecomeActive(_ scene: UIScene) {
        resolver.requestFirstLaunchConsentAfterGrace()
    }
}

<key>com.apple.developer.associated-domains</key>
<array>
    <string>applinks:app.example.com</string>
</array>

struct TrackOpenRequest: Encodable {
    var deepLink: String? = nil
    var li2Domains: [String]? = nil
    var clipboardStatus: String? = nil   // "read" | "empty" | "denied" | "optout"
    var installReferrer: String? = nil   // chỉ dùng cho Android
}

struct TrackOpenResponse: Decodable {
    struct Link: Decodable {
        let id: String
        let domain: String
        let key: String
        let url: String
    }
    let clickId: String
    let link: Link?          // nil khi deferred không đối chiếu được
    let matchMethod: String?
    let missReason: String?
    let platform: String?
}

// baseURL PHẢI gồm /api/v1, ví dụ "https://api.li2.ai/api/v1"
func trackOpen(_ body: TrackOpenRequest) async throws -> TrackOpenResponse {
    var req = URLRequest(url: URL(string: "\(baseURL)/track/open")!)
    req.httpMethod = "POST"
    req.setValue("application/json", forHTTPHeaderField: "Content-Type")
    req.setValue(publishableKey, forHTTPHeaderField: "X-Li2-Key")  // li2_pk_...
    req.httpBody = try JSONEncoder().encode(body)

    let (data, _) = try await URLSession.shared.data(for: req)
    return try JSONDecoder().decode(TrackOpenResponse.self, from: data)
}

// Điều hướng theo phản hồi: khớp → mở đúng màn hình; trượt → fallback + lý do
@MainActor
func route(_ res: TrackOpenResponse) {
    if let dest = res.link?.url {
        router.open(dest)
    } else {
        router.showFallbackBanner(missReason: res.missReason)
    }
}

WindowGroup {
    ContentView()
        .onOpenURL { url in
            store.handleIncomingURL(url)
        }
        .onContinueUserActivity(NSUserActivityTypeBrowsingWeb) { activity in
            guard let url = activity.webpageURL else { return }
            store.handleIncomingURL(url)
        }
}

func handleIncomingURL(_ url: URL) {
    hasReceivedUniversalLink = true   // chặn luồng deferred ở bước 4
    Task {
        let res = try await trackOpen(.init(deepLink: url.absoluteString))
        await route(res)
    }
}

func recoverDeferredOnce() {
    guard !firstLaunchRan, !hasReceivedUniversalLink else { return }
    firstLaunchRan = true

    let body: TrackOpenRequest
    switch clipboardOutcome {       // kết quả sau khi người dùng tương tác PasteControl
    case .read(let copied) where copied.contains("li2_cid"):
        body = .init(deepLink: copied, clipboardStatus: "read")
    case .read:                                   // có nội dung nhưng không phải link Li2
        body = .init(li2Domains: ["app.example.com"], clipboardStatus: "read")
    case .empty:
        body = .init(li2Domains: ["app.example.com"], clipboardStatus: "empty")
    case .denied:                                 // người dùng chặn quyền dán
        body = .init(li2Domains: ["app.example.com"], clipboardStatus: "denied")
    case .optout:                                 // người dùng bỏ qua
        body = .init(li2Domains: ["app.example.com"], clipboardStatus: "optout")
    }

    Task {
        let res = try await trackOpen(body)
        await route(res)
    }
}

struct ClipboardPasteButton: UIViewRepresentable {
    var onPaste: (String?) -> Void   // nil = không có gì dán được

    func makeUIView(context: Context) -> PasteReceiverView {
        let receiver = PasteReceiverView()
        receiver.onPaste = onPaste

        let config = UIPasteControl.Configuration()
        config.displayMode = .iconAndLabel
        config.cornerStyle = .capsule

        let control = UIPasteControl(configuration: config)
        control.translatesAutoresizingMaskIntoConstraints = false
        control.target = receiver          // ← dòng quyết định: trỏ target tường minh
        receiver.addSubview(control)
        NSLayoutConstraint.activate([
            control.topAnchor.constraint(equalTo: receiver.topAnchor),
            control.bottomAnchor.constraint(equalTo: receiver.bottomAnchor),
            control.leadingAnchor.constraint(equalTo: receiver.leadingAnchor),
            control.trailingAnchor.constraint(equalTo: receiver.trailingAnchor),
        ])
        return receiver
    }

    func updateUIView(_ v: PasteReceiverView, context: Context) { v.onPaste = onPaste }
}

final class PasteReceiverView: UIView {
    var onPaste: ((String?) -> Void)?

    override init(frame: CGRect) {
        super.init(frame: frame)
        pasteConfiguration = UIPasteConfiguration(
            acceptableTypeIdentifiers: [UTType.url.identifier, UTType.plainText.identifier])
    }
    @available(*, unavailable) required init?(coder: NSCoder) { fatalError() }

    // Quyết định control bật/tắt — iOS gọi với item providers của clipboard hiện tại.
    override func canPaste(_ providers: [NSItemProvider]) -> Bool {
        providers.contains {
            $0.hasItemConformingToTypeIdentifier(UTType.url.identifier)
                || $0.hasItemConformingToTypeIdentifier(UTType.plainText.identifier)
        }
    }

    override func paste(itemProviders: [NSItemProvider]) {
        guard let p = itemProviders.first else { return deliver(nil) }
        if p.canLoadObject(ofClass: NSURL.self) {
            p.loadObject(ofClass: NSURL.self) { [weak self] o, _ in self?.deliver((o as? URL)?.absoluteString) }
        } else if p.canLoadObject(ofClass: NSString.self) {
            p.loadObject(ofClass: NSString.self) { [weak self] o, _ in self?.deliver((o as? NSString) as String?) }
        } else { deliver(nil) }
    }

    private nonisolated func deliver(_ v: String?) {
        Task { @MainActor [weak self] in self?.onPaste?(v) }
    }
}