Airbridge Migration

Remove Airbridge:

1. Remove the airbridge-ios-sdk CocoaPods pod, or the SPM package from https://github.com/ab180/airbridge-ios-sdk-deployment (product Airbridge)
2. Remove AirbridgeOptionBuilder(name:token:) and the Airbridge.initializeSDK(option:) call
3. Remove the deep link forwarding calls that exist solely to reach Airbridge: Airbridge.trackDeeplink(url:) / Airbridge.handleDeeplink(url:onSuccess:) in application(_:open:options:), and Airbridge.trackDeeplink(userActivity:) / Airbridge.handleDeeplink(userActivity:onSuccess:) in application(_:continue:restorationHandler:)
4. Remove the Airbridge.handleDeferredDeeplink(onSuccess:) call

Add WarpLink:

// Package.swift
dependencies: [
    .package(url: "https://github.com/WarpLinkApp/warplink-ios-sdk", from: "1.1.0")
]

Remove Airbridge:

// Remove from build.gradle
// implementation "io.airbridge:sdk-android:$LATEST_VERSION"
// implementation "io.airbridge:sdk-android-restricted:$LATEST_VERSION"

Also remove the AirbridgeOptionBuilder(name, token).build() / Airbridge.initializeSDK(context, option) call from your Application class, the Airbridge.handleDeeplink(intent, onSuccess, onFailure) and Airbridge.handleDeferredDeeplink { uri -> ... } calls from your Activity, and the App Links intent filter targeting your abr.ge (or custom domain) host.

Add WarpLink:

dependencies {
    implementation("app.warplink:sdk:1.1.0")
}

Remove Airbridge:

npm uninstall airbridge-react-native-sdk
cd ios && pod install

Add WarpLink:

npm install @warplink/react-native

The iOS SDK is distributed through Swift Package Manager and needs dynamic linkage, so add this to ios/Podfile inside your app target before installing pods:

# ios/Podfile, inside your app target
use_frameworks! :linkage => :dynamic

cd ios && pod install

Before (Airbridge):

import Airbridge

let option = AirbridgeOptionBuilder(name: "YOUR_APP_NAME", token: "YOUR_APP_SDK_TOKEN").build()
Airbridge.initializeSDK(option: option)

After (WarpLink):

import WarpLink

WarpLink.configure(
    apiKey: "wl_live_yoursdkkeyhere000000000000000000",
    options: WarpLinkOptions(onLink: { result in
        if case .success(let link) = result, let link {
            navigate(to: link) // taps AND deferred installs (check link.isDeferred)
        }
    })
)

Before (Airbridge):

import co.ab180.airbridge.Airbridge
import co.ab180.airbridge.AirbridgeOptionBuilder

class MyApp : Application() {
    override fun onCreate() {
        super.onCreate()
        val option = AirbridgeOptionBuilder("YOUR_APP_NAME", "YOUR_APP_SDK_TOKEN").build()
        Airbridge.initializeSDK(this, option)
    }
}

After (WarpLink):

import app.warplink.WarpLink
import app.warplink.WarpLinkOptions

class MyApp : Application() {
    override fun onCreate() {
        super.onCreate()
        WarpLink.configure(
            context = this,
            apiKey = "wl_live_yoursdkkeyhere000000000000000000",
            options = WarpLinkOptions(onLink = { result ->
                result.onSuccess { link -> navigateTo(link) }
            })
        )
    }
}

Before (Airbridge):

import { Airbridge } from 'airbridge-react-native-sdk';

Airbridge.setOnDeeplinkReceived((url) => {
    // handle url
});

After (WarpLink):

import { WarpLink } from '@warplink/react-native';

WarpLink.configure({
    apiKey: 'wl_live_yoursdkkeyhere000000000000000000',
    onLink: ({ deepLink }) => deepLink && navigateTo(deepLink.destination),
});

In Signing & Capabilities > Associated Domains:

- applinks:YOUR_APP_NAME.abr.ge
+ applinks:aplnk.to

In AndroidManifest.xml, update the intent filter host. Airbridge's own docs warn to keep separate <intent-filter> tags per host rather than combining multiple <data> entries in one filter:

  <data
      android:scheme="https"
-     android:host="YOUR_APP_NAME.abr.ge" />
+     android:host="aplnk.to" />

Delete the Airbridge.trackDeeplink(url:) / Airbridge.handleDeeplink(url:onSuccess:) pair from application(_:open:options:), and the Airbridge.trackDeeplink(userActivity:) / Airbridge.handleDeeplink(userActivity:onSuccess:) pair from application(_:continue:restorationHandler:). Forward the same URL or activity to WarpLink instead:

func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey: Any] = [:]) -> Bool {
    WarpLink.open(url) // was Airbridge.trackDeeplink(url:) + handleDeeplink(url:onSuccess:)
    return true
}

func application(
    _ application: UIApplication,
    continue userActivity: NSUserActivity,
    restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void
) -> Bool {
    WarpLink.continue(userActivity) // was Airbridge.trackDeeplink(userActivity:) + handleDeeplink(userActivity:onSuccess:)
    return true
}

Resolved links arrive in your onLink callback. Or set your delegate class to the drop-in WarpLinkAppDelegate / WarpLinkSceneDelegate and skip writing these methods yourself.

Delete the Airbridge.handleDeeplink(intent, onSuccess, onFailure) call from your Activity's onResume() or onCreate(). Cold start is automatic once onLink is set at configure(). For warm start, forward new intents and keep android:launchMode="singleTask" on the Activity:

override fun onNewIntent(intent: Intent) {
    super.onNewIntent(intent)
    WarpLink.onNewIntent(intent) // was Airbridge.handleDeeplink(intent, ...)
}

Resolved links arrive in your onLink callback.

Delete the Airbridge.setOnDeeplinkReceived((url) => { ... }) callback. WarpLink.configure()'s onLink callback covers cold start, warm start, and deferred installs in one callback, the same way that single Airbridge callback did.

On iOS you are removing the Airbridge calls from a delegate method that already exists and already forwards to your linking library. Swap them for the WarpLink call and leave the rest of the method alone. Do not let handleIncomingURL decide the return value: it returns nothing, and replacing the forwarded result breaks React Navigation, Expo Linking, and OAuth callbacks.

// ios/YourApp/AppDelegate.swift
import React
import warplink_react_native

func application(
  _ application: UIApplication,
  continue userActivity: NSUserActivity,
  restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void
) -> Bool {
  if userActivity.activityType == NSUserActivityTypeBrowsingWeb,
     let url = userActivity.webpageURL {
    WarpLinkModule.handleIncomingURL(url)   // was AirbridgeReactNative.trackDeeplink(userActivity:)
  }
  return RCTLinkingManager.application(
    application, continue: userActivity, restorationHandler: restorationHandler)
}

Android needs no host code, given android:launchMode="singleTask". See the React Native SDK guide for the Objective-C form and Expo prebuild, and the iOS SceneDelegate hook if your app has a SceneDelegate (Info.plist declares UIApplicationSceneManifest): iOS stops calling the AppDelegate method above once a scene exists.

Handle the deferred case inside your onLink callback:

options: WarpLinkOptions(onLink: { result in
    guard case .success(let deepLink) = result, let deepLink else { return }
    if deepLink.isDeferred {
        print("Match confidence: \(deepLink.matchConfidence ?? 0)")
    }
    navigate(to: deepLink)
})

Handle the deferred case inside your onLink callback:

options = WarpLinkOptions(onLink = { result ->
    result.onSuccess { deepLink ->
        if (deepLink.isDeferred) {
            Log.d("MyApp", "Match confidence: ${deepLink.matchConfidence}")
        }
        navigateTo(deepLink)
    }
})

Handle the deferred case inside your onLink callback:

WarpLink.configure({
    apiKey: 'wl_live_yoursdkkeyhere000000000000000000',
    onLink: ({ deepLink }) => {
        if (!deepLink) return;
        if (deepLink.isDeferred) console.log('Match confidence:', deepLink.matchConfidence);
        navigateTo(deepLink.destination);
    },
});