iOS SDK

dependencies: [
    .package(
        url: "https://github.com/Deeplinkly/ios_deeplinkly.git",
        from: "1.2.1"
    )
]

.product(name: "Deeplinkly", package: "ios_deeplinkly")

pod 'Deeplinkly', '~> 1.2'

<key>DeeplinklyApiKey</key>
<string>your_api_key_here</string>

<key>DeeplinklyLinkDomains</key>
<array>
  <string>yourbrand.deeplinkly.com</string>
  <string>links.yourbrand.com</string>
</array>

<key>CFBundleURLTypes</key>
<array>
  <dict>
    <key>CFBundleURLName</key>
    <string>com.example.myapp</string>
    <key>CFBundleURLSchemes</key>
    <array>
      <string>yourapp</string>
    </array>
  </dict>
</array>

applinks:yourbrand.deeplinkly.com
applinks:links.yourbrand.com

import Deeplinkly

final class DeepLinkRouter: DeeplinklyDeepLinkListener {
    func onDeepLink(_ payload: [String: Any]) {
        let clickId = payload["click_id"] as? String
        let params = payload["params"] as? [String: Any] ?? [:]

        if params["screen"] as? String == "product",
           let productId = params["product_id"] as? String {
            openProduct(productId)
        }
    }

    private func openProduct(_ id: String) {
        // Integrate with your router or navigation coordinator.
    }
}

import Deeplinkly
import UIKit

@main
final class AppDelegate: UIResponder, UIApplicationDelegate {
    private let router = DeepLinkRouter()

    func application(
        _ application: UIApplication,
        didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
    ) -> Bool {
        Deeplinkly.setDeepLinkListener(router)
        Deeplinkly.initialize()
        return true
    }

    func application(
        _ application: UIApplication,
        open url: URL,
        options: [UIApplication.OpenURLOptionsKey: Any] = [:]
    ) -> Bool {
        Deeplinkly.handleLink(url)
        return true
    }

    func application(
        _ application: UIApplication,
        continue userActivity: NSUserActivity,
        restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void
    ) -> Bool {
        guard let url = userActivity.webpageURL else { return false }
        Deeplinkly.handleLink(url)
        return true
    }
}

import Deeplinkly
import UIKit

final class SceneDelegate: UIResponder, UIWindowSceneDelegate {
    var window: UIWindow?

    func scene(
        _ scene: UIScene,
        willConnectTo session: UISceneSession,
        options connectionOptions: UIScene.ConnectionOptions
    ) {
        for context in connectionOptions.urlContexts {
            Deeplinkly.handleLink(context.url)
        }
        for activity in connectionOptions.userActivities {
            if let url = activity.webpageURL {
                Deeplinkly.handleLink(url)
            }
        }
    }

    func scene(_ scene: UIScene, openURLContexts contexts: Set<UIOpenURLContext>) {
        for context in contexts {
            Deeplinkly.handleLink(context.url)
        }
    }

    func scene(_ scene: UIScene, continue userActivity: NSUserActivity) {
        guard let url = userActivity.webpageURL else { return }
        Deeplinkly.handleLink(url)
    }
}

import Deeplinkly
import SwiftUI
import UIKit

final class DeeplinklyAppDelegate: NSObject, UIApplicationDelegate {
    let router = DeepLinkRouter()

    func application(
        _ application: UIApplication,
        didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
    ) -> Bool {
        Deeplinkly.setDeepLinkListener(router)
        Deeplinkly.initialize()
        return true
    }
}

@main
struct ExampleApp: App {
    @UIApplicationDelegateAdaptor(DeeplinklyAppDelegate.self)
    private var appDelegate

    var body: some Scene {
        WindowGroup {
            RootView()
                .onOpenURL { Deeplinkly.handleLink($0) }
        }
    }
}

<key>DeeplinklyCheckPasteboardOnInstall</key>
<false/>

Deeplinkly.setCheckPasteboardOnInstall(true, checkNow: false)

Deeplinkly.willShowPasteboardBanner { willShow in
    guard willShow else {
        Deeplinkly.checkPasteboardNow()
        return
    }

    presentPasteboardExplanation {
        Deeplinkly.checkPasteboardNow()
    }
}

import Deeplinkly
import UIKit

@available(iOS 16.0, *)
final class DeeplinklyPasteControlView: UIView {
    var onResult: ((Bool) -> Void)?

    override init(frame: CGRect) {
        super.init(frame: frame)

        let configuration = UIPasteControl.Configuration()
        configuration.displayMode = .iconAndLabel

        let control = UIPasteControl(configuration: configuration)
        control.target = self
        control.translatesAutoresizingMaskIntoConstraints = false
        addSubview(control)

        NSLayoutConstraint.activate([
            control.centerXAnchor.constraint(equalTo: centerXAnchor),
            control.centerYAnchor.constraint(equalTo: centerYAnchor),
        ])
    }

    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }

    override func canPaste(_ itemProviders: [NSItemProvider]) -> Bool {
        itemProviders.contains {
            $0.hasItemConformingToTypeIdentifier("public.url") ||
            $0.hasItemConformingToTypeIdentifier("public.plain-text")
        }
    }

    override func paste(itemProviders: [NSItemProvider]) {
        Deeplinkly.handlePaste(itemProviders: itemProviders) { [weak self] handled in
            self?.onResult?(handled)
        }
    }
}

let attribution = Deeplinkly.getInstallAttribution() // first-touch, write-once
let deeplinklyId = Deeplinkly.getDeeplinklyId()   // stable local install ID

Deeplinkly.setUserId("user_123")
Deeplinkly.setUserId(nil) // clear on logout

Deeplinkly.setUserData(
    userId: "user_123",
    email: "ada@example.com",
    phoneNumber: "+441234567890",
    firstName: "Ada",
    lastName: "Lovelace",
    city: "London",
    country: "GB"
)   // false if any field was malformed, in which case nothing was stored

Deeplinkly.setUserData(
    userId: "user_123",
    customData: [
        "mixpanel_distinct_id": "d-8837",
        "clevertap_id": "ct-4412",
    ]
)

Deeplinkly.clearUserData()   // erases everything setUserData and setUserId recorded
Deeplinkly.setUserId(nil)    // clears only the id

Deeplinkly.setAttributionLevel(.reduced)
let level = Deeplinkly.getAttributionLevel()

Deeplinkly.setTrackingEnabled(false)
let enabled = Deeplinkly.isTrackingEnabled()

<key>DeeplinklyAttributionLevel</key>
<string>reduced</string>

Deeplinkly.setPIIHashingEnabled(true)   // SHA-256 on device before sending
Deeplinkly.isPIIHashingEnabled()       // off unless you turned it on

Deeplinkly.logEvent(
    "purchase",
    parameters: [
        "order_id": "ord_42",
        "amount": 49.99,
        "currency": "USD",
        "is_first_purchase": true,
    ]
) { accepted in
    // Main thread. False means validation or delivery failed.
}

Deeplinkly.logPurchase(
    value: 49.99,
    currency: "USD",
    orderId: "ord_42",
    quantity: 1,
    productId: "sku_9"
) { accepted in /* optional */ }

let payload: [String: Any] = [
    "content": [
        "canonical_identifier": "product/sku_42",
        "title": "Pro Plan",
        "description": "Upgrade to Pro",
        "image_url": "https://example.com/images/pro.png",
        "metadata": ["screen": "product", "product_id": "sku_42"],
    ],
    "options": [
        "channel": "email",
        "feature": "upgrade_campaign",
        "tags": ["spring", "sale"],
    ],
]

Deeplinkly.generateLink(payload: payload) { result in
    if result["success"] as? Bool == true {
        let url = result["url"] as? String
    } else {
        let code = result["error_code"] as? String
        let message = result["error_message"] as? String
    }
}

Deeplinkly.setDebugMode(true)

print(Deeplinkly.version)
print(Deeplinkly.isEnabled)