Quickstart

// App.js
import { useEffect } from "react";
import { Linking } from "react-native";

useEffect(() => {
  const handleDeepLink = (url) => {
    try {
      // Call the tracking endpoint with the full deep link URL
      trackDeepLinkClick(url);
    } catch (error) {
      console.error("Error handling deep link URL:", error);
    }
  };

  // Handle deep link when app is already running
  const subscription = Linking.addEventListener("url", (event) => {
    handleDeepLink(event.url);
  });

  // Handle deep link when app is opened from a deep link
  Linking.getInitialURL().then((url) => {
    if (url) {
      handleDeepLink(url);
    }
  });

  return () => {
    subscription?.remove();
  };
}, []);

// AppDelegate.swift
func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey : Any] = [:]) -> Bool {
    handleDeepLink(url: url)
    return true
}

func handleDeepLink(url: URL) {
    // Call the tracking endpoint with the full deep link URL
    trackDeepLinkClick(deepLink: url.absoluteString)
}

// ContentView.swift
struct ContentView: View {

    var body: some View {
        NavigationStack {
            VStack {
              //... your app content
            }
            .onOpenURL { url in
                // Call the tracking endpoint with the full deep link URL
                trackDeepLinkClick(deepLink: url.absoluteString)
            }
        }
    }
}

// MainActivity.kt
override fun onNewIntent(intent: Intent?) {
    super.onNewIntent(intent)
    intent?.data?.let { uri ->
        handleDeepLink(uri)
    }
}

private fun handleDeepLink(uri: Uri) {
    // Call the tracking endpoint with the full deep link URL
    trackDeepLinkClick(uri.toString())
}

// DeepLinkTracker.js
async function trackDeepLinkClick(deepLink) {
  try {
    const response = await fetch(`https://api.dub.co/track/open`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
      },
      body: JSON.stringify({
        deepLink,
      }),
    });

    if (response.ok) {
      const data = await response.json();
      const destinationUrl = data.link.url;

      // Navigate to the destination URL in your app
      navigateToDestination(destinationUrl);
    }
  } catch (error) {
    console.error("Error tracking deep link:", error);
  }
}

// DeepLinkTracker.swift
func trackDeepLinkClick(deepLink: String) {
    let url = URL(string: "https://api.dub.co/track/open")!
    var request = URLRequest(url: url)
    request.httpMethod = "POST"
    request.setValue("application/json", forHTTPHeaderField: "Content-Type")

    let body = [
        "deepLink": deepLink,
    ]

    request.httpBody = try? JSONSerialization.data(withJSONObject: body)

    URLSession.shared.dataTask(with: request) { data, response, error in
        if let data = data,
           let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
           let link = json["link"] as? [String: Any],
           let destinationUrl = link["url"] as? String {
            DispatchQueue.main.async {
                self.navigateToDestination(destinationUrl)
            }
        }
    }.resume()
}

// DeepLinkTracker.kt
private fun trackDeepLinkClick(deepLink: String) {
    val url = URL("https://api.dub.co/track/open")
    val connection = url.openConnection() as HttpURLConnection

    connection.requestMethod = "POST"
    connection.setRequestProperty("Content-Type", "application/json")
    connection.doOutput = true

    val body = JSONObject().apply {
        put("deepLink", deepLink)
    }

    connection.outputStream.use { os ->
        os.write(body.toString().toByteArray())
    }

    val response = connection.inputStream.bufferedReader().use { it.readText() }
    val jsonResponse = JSONObject(response)
    val link = jsonResponse.getJSONObject("link")
    val destinationUrl = link.getString("url")

    runOnUiThread {
        navigateToDestination(destinationUrl)
    }
}

// ❌ Bad: Short-circuit OR — if FBSDKApplicationDelegate returns YES, 
// RCTLinkingManager never fires
- (BOOL)application:(UIApplication *)app
            openURL:(NSURL *)url
            options:(NSDictionary<UIApplicationOpenURLOptionsKey, id> *)options {
  return [[FBSDKApplicationDelegate sharedInstance] application:app openURL:url options:options]
      || [RCTLinkingManager application:app openURL:url options:options];
}

// ✅ Good: Non-short-circuit OR — both handlers always run
- (BOOL)application:(UIApplication *)app
            openURL:(NSURL *)url
            options:(NSDictionary<UIApplicationOpenURLOptionsKey, id> *)options {
  BOOL fbHandled = [[FBSDKApplicationDelegate sharedInstance] application:app openURL:url options:options];
  BOOL rnHandled = [RCTLinkingManager application:app openURL:url options:options];
  return fbHandled || rnHandled;
}

// ❌ Bad: Short-circuit OR — if the Facebook SDK returns true,
// handleDeepLink never fires
func application(_ app: UIApplication, open url: URL,
                 options: [UIApplication.OpenURLOptionsKey: Any] = [:]) -> Bool {
    return ApplicationDelegate.shared.application(app, open: url, options: options)
        || handleDeepLink(url: url)
}

// ✅ Good: Call each handler independently
func application(_ app: UIApplication, open url: URL,
                 options: [UIApplication.OpenURLOptionsKey: Any] = [:]) -> Bool {
    let fbHandled = ApplicationDelegate.shared.application(app, open: url, options: options)
    let dubHandled = handleDeepLink(url: url)
    return fbHandled || dubHandled
}