Firebase Dynamic Links Migration

Remove Firebase:

1. Remove the FirebaseDynamicLinks package (SPM from firebase-ios-sdk.git, or CocoaPods Firebase/DynamicLinks)
2. Remove DynamicLinks.dynamicLinks().handleUniversalLink(...) and DynamicLinks.dynamicLinks().dynamicLink(fromCustomSchemeURL:)
3. Remove the -ObjC linker flag if it was added solely for this SDK, the Associated Domains entitlement for your old Dynamic Links domain, and (if set) the FirebaseDeepLinkPasteboardRetrievalEnabled Info.plist key
4. Remove FirebaseApp.configure() unless you use other Firebase services

Add WarpLink:

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

Remove Firebase:

// Remove from build.gradle.kts
// implementation(platform("com.google.firebase:firebase-bom:33.0.0"))
// implementation("com.google.firebase:firebase-dynamic-links")

Also remove the <intent-filter> tied to your old Dynamic Links domain, and any Firebase.dynamicLinks.getDynamicLink(intent) handling.

Add WarpLink:

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

Remove Firebase:

npm uninstall @react-native-firebase/dynamic-links
# If no other Firebase packages:
npm uninstall @react-native-firebase/app
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

Remove Firebase:

flutter pub remove firebase_dynamic_links
# If no other Firebase packages:
flutter pub remove firebase_core

Also remove FirebaseDynamicLinks.instance.getInitialLink() and FirebaseDynamicLinks.instance.onLink from your Dart code, and Firebase.initializeApp() unless you use other Firebase services.

Add WarpLink:

flutter pub add warplink_flutter

The iOS SDK is distributed through Swift Package Manager, so there is no Podfile change. If your Flutter version does not use Swift Package Manager by default, run flutter config --enable-swift-package-manager once.

Before (Firebase):

import FirebaseCore
FirebaseApp.configure()

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 (Firebase):

// Firebase auto-initializes via FirebaseApp, no explicit call

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 (Firebase):

// Firebase auto-initializes via @react-native-firebase/app

After (WarpLink):

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

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

Before (Firebase):

await Firebase.initializeApp();

After (WarpLink):

import 'package:warplink_flutter/warplink_flutter.dart';

await WarpLink.configure(
  apiKey: 'wl_live_yoursdkkeyhere000000000000000000',
  onLink: (event) {
    if (event is LinkEvent) navigateTo(event.deepLink.destination);
  },
);

In Signing & Capabilities > Associated Domains:

- applinks:yourapp.page.link
+ applinks:yourapp.aplnk.to

Find your app's subdomain in the dashboard: open the app, then Settings. Or see Your app's own link address.

In AndroidManifest.xml, update the intent filter host:

  <data
      android:scheme="https"
-     android:host="yourapp.page.link" />
+     android:host="yourapp.aplnk.to" />

Delete the DynamicLinks.dynamicLinks().handleUniversalLink(...) and DynamicLinks.dynamicLinks().dynamicLink(fromCustomSchemeURL:) calls. Forward the incoming activity to WarpLink (or set your scene delegate class to WarpLinkSceneDelegate):

func scene(_ scene: UIScene, continue userActivity: NSUserActivity) {
    WarpLink.continue(userActivity)
}

Resolved links arrive in your onLink callback.

Delete the Firebase.dynamicLinks.getDynamicLink(intent).addOnSuccessListener { ... }.addOnFailureListener { ... } block. Cold start is automatic. For warm start, forward new intents and set android:launchMode="singleTask" on the Activity:

override fun onNewIntent(intent: Intent) {
    super.onNewIntent(intent)
    WarpLink.onNewIntent(intent)
}

Resolved links arrive in your onLink callback.

Delete the dynamicLinks().getInitialLink() and dynamicLinks().onLink(...) calls. Cold and warm start flow into onLink automatically.

On iOS you are removing the Firebase call from a delegate method that already exists and already forwards to your linking library. Swap the Firebase line 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 DynamicLinks...handleUniversalLink
  }
  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.

Delete the FirebaseDynamicLinks.instance.getInitialLink() call and the FirebaseDynamicLinks.instance.onLink.listen(...) subscription. Cold and warm start flow into onLink automatically.

There is no delegate or Activity code to port. The plugin registers with Flutter's iOS and Android lifecycles, so the Firebase forwarding you may have added to AppDelegate or MainActivity can go. Set minSdk = 26 in android/app/build.gradle.kts, and see the Flutter SDK guide for the Associated Domains capability, the intent filter, and Flutter's own link handling.

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);
    },
});

Handle the deferred case inside your onLink callback:

await WarpLink.configure(
  apiKey: 'wl_live_yoursdkkeyhere000000000000000000',
  onLink: (event) {
    if (event is! LinkEvent) return;
    final deepLink = event.deepLink;
    if (deepLink.isDeferred) debugPrint('Match confidence: ${deepLink.matchConfidence}');
    navigateTo(deepLink.destination);
  },
);