Deep Links

Deep links enable your application to open specific screens or content directly from notifications, web pages, or external sources. By integrating deep links, you can guide users to precise destinations within your app — enhancing engagement and creating seamless navigation between notifications, campaigns, and in-app experiences.

Overview

Handling deep links in your Android application allows you to:

• Support Deep Link notification types from Actito.
• Handle custom URL schemes or HTTPS links from web pages.

Once configured, your app can interpret incoming URLs and display the appropriate screen or content dynamically.

Declaring a custom URL scheme

To enable your app to handle a custom URL scheme, declare your custom URL scheme in your Info.plist Be sure to update the scheme to match yours.

With this configuration, links such as com.example://example.com/product?id=1 will automatically open your application.

Handling Deep Links

When a user opens a deep link — either from a notification or a web page — your app will handle the link. Here are two possible ways to handle those links:

SceneDelegate

class SceneDelegate: NSObject, UIWindowSceneDelegate {
    func scene(_ scene: UIScene, openURLContexts URLContexts: Set<UIOpenURLContext>) {
        guard let url = URLContexts.first?.url else { return }

        print("Received deep link: \(url.absoluteString).")
    }

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

        if Actito.shared.handleDynamicLinkUrl(url) {
            // This method resolves dynamic links generated in our dashboard and opens the defined deep link
            // To receive the deep link, implement scene(_:openURLContexts:)
            return
        }
    }

    // If your app is not running, the system delivers the dynamic links to the scene(_:willConnectTo:options:) delegate method
    func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
        guard let userActivity = connectionOptions.userActivities.first,
            userActivity.activityType == NSUserActivityTypeBrowsingWeb,
            let url = userActivity.webpageURL
        else {
            return
        }

        if Actito.shared.handleDynamicLinkUrl(url) {
            // This method resolves dynamic links generated in our dashboard and opens the defined deep link
            // To receive the deep link, implement scene(_:openURLContexts:)
            return
        }
    }
}

iOS

@main
internal struct Sample: App {
    @UIApplicationDelegateAdaptor(AppDelegate.self) internal var appDelegate

    internal var body: some Scene {
        WindowGroup {
            NavigationView {
                HomeView()
            }
            .onOpenURL { url in
                handleUrl(url: url)
            }
            .onContinueUserActivity(NSUserActivityTypeBrowsingWeb) { userActivity in
                guard let url = userActivity.webpageURL else {
                    return
                }

                handleUrl(url: url)
            }
        }
    }

    private func handleUrl(url: URL) {
        if Actito.shared.handleDynamicLinkUrl(url) {
            return
        }

        print("Received deep link: \(url.absoluteString).")
    }
}

This implementation ensures that both standard deep links and Actito dynamic links are properly handled.

Handling Notification Links

Deep links are also used within HTML and Web Page notification types. To handle links clicked inside these notifications, declare all the URL schemes that you want to handle in your ActitoOptions.plist.

note

This functionality is available only when notifications are presented using the ActitoPushUIKit module. If you handle notification presentation manually, you are responsible for processing clicked URLs within your own implementation.

Step 1 - Add URL schemes in the ActitoOptions.plist

<plist version="1.0">
<dict>
	  <key>URL_SCHEMES</key>
	  <array>
		    <string>com.example</string>
        <string>com.example2</string>
        <string>com.example3</string>
	  </array>
</dict>
</plist>

This configuration allows the SDK to intercept links matching any of the defined schemes and trigger a callback when clicked.

Step 2 - Implement the event listener

When a user taps a hyperlink within an HTML or Web Page notification, the SDK automatically invokes didClickURL from ActitoPushUIDelegate. You can use this event to handle the navigation logic for custom URL schemes:

internal class AppDelegate: NSObject, UIApplicationDelegate {
    internal func application(_: UIApplication, didFinishLaunchingWithOptions _: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        Actito.shared.pushUI().delegate = self

        // ...

        return true
    }
}

extension AppDelegate: ActitoPushUIDelegate {
    internal func actito(_: ActitoPushUI, didClickURL url: URL, in notification: ActitoNotification) {
        // Handle the deep link according to your app’s routing logic
    }

    // ...
}