AppsFlyer Migration

Remove AppsFlyer:

1. Remove the AppsFlyerFramework package (CocoaPods, or SPM: AppsFlyerSDK/AppsFlyerFramework on SDK versions before 6.12.0, AppsFlyerFramework-Static/-Dynamic/-Strict on 6.12.0 and later)
2. Remove AppsFlyerLib.shared().appsFlyerDevKey, .appleAppID, and the .start() call
3. Remove the NSAdvertisingAttributionReportEndpoint and AdAttributionKit keys from Info.plist
4. Remove the AppsFlyerDeepLinkDelegate conformance and didResolveDeepLink(_:) (or the legacy onAppOpenAttribution)

Add WarpLink:

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

Remove AppsFlyer:

// Remove from build.gradle.kts
// implementation("com.appsflyer:af-android-sdk:<version>")

Also remove the MultipleInstallBroadcastReceiver manifest entry, the AppsFlyerLib.getInstance().init(...) / .start(context) calls, and any DeepLinkListener implementation.

Add WarpLink:

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

Remove AppsFlyer:

npm uninstall react-native-appsflyer

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 AppsFlyer:

flutter pub remove appsflyer_sdk

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

AppsFlyerLib.shared().appsFlyerDevKey = "<DEV_KEY>"
AppsFlyerLib.shared().appleAppID = "<APPLE_APP_ID>"
AppsFlyerLib.shared().start()

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

AppsFlyerLib.getInstance().init(devKey, conversionListener, context)
AppsFlyerLib.getInstance().start(context)

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

import appsFlyer from 'react-native-appsflyer';

appsFlyer.initSdk();
appsFlyer.startSdk();

Method names shown are react-native-appsflyer's current documented API. A newer SDK version may rename these; check your installed version before porting the surrounding config.

After (WarpLink):

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

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

Before (AppsFlyer):

import 'package:appsflyer_sdk/appsflyer_sdk.dart';

final appsflyerSdk = AppsFlyerSdk.instance;

await appsflyerSdk.registerDeepLinkListener(onDeepLinking: (result) {
  // handle result.deepLink
});
await appsflyerSdk.init(devKey: '{YourDevKey}', appId: '{YourAppleAppId}');
await appsflyerSdk.registerSessionReadyListener(() async {
  await appsflyerSdk.start();
});

Method names shown are appsflyer_sdk's current documented API. A newer SDK version may rename these; check your installed version before porting the surrounding config.

After (WarpLink):

import 'dart:async';

import 'package:flutter/material.dart';
import 'package:warplink_flutter/warplink_flutter.dart';

class _AppState extends State<App> {
  @override
  void initState() {
    super.initState();
    unawaited(
      WarpLink.configure(
        apiKey: 'wl_live_yoursdkkeyhere000000000000000000',
        onLink: (event) {
          if (event is! LinkEvent) return;
          final deepLink = event.deepLink;
          navigateTo(deepLink.deepLinkUrl ?? deepLink.destination);
        },
      ),
    );
  }
}

Call configure() once from your root widget's initState, without awaiting it. deepLinkUrl is the app route; destination is the web URL and serves only as the fallback. A link that launches the app can arrive before the first frame, so make navigateTo wait for the navigator, as in With a Navigator Key.

In Signing & Capabilities > Associated Domains:

- applinks:yoursubdomain.onelink.me
+ applinks:yourapp.aplnk.to

In AndroidManifest.xml, update the intent filter host:

  <data
      android:scheme="https"
-     android:host="yoursubdomain.onelink.me" />
+     android:host="yourapp.aplnk.to" />

Delete the AppsFlyerDeepLinkDelegate conformance and didResolveDeepLink(_:) (or the legacy onAppOpenAttribution). 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 DeepLinkListener implementation and its onDeepLinking(deepLinkResult) handling. 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 onDeepLink() and onAppOpenAttribution() listeners. Cold and warm start flow into onLink automatically.

On iOS you are removing the AppsFlyer call from a delegate method that already exists and already forwards to your linking library. Swap the AppsFlyer 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 AppsFlyerLib...
  }
  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 registerDeepLinkListener(onDeepLinking: ...) registration. Cold and warm start flow into onLink automatically.

Switch off Flutter's own link handling so it does not also route the link as a page. In ios/Runner/Info.plist:

<key>FlutterDeepLinkingEnabled</key>
<false/>

In android/app/src/main/AndroidManifest.xml, inside your main <activity>:

<meta-data android:name="flutter_deeplinking_enabled" android:value="false" />

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

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:

import 'dart:async';

import 'package:flutter/material.dart';
import 'package:warplink_flutter/warplink_flutter.dart';

class _AppState extends State<App> {
  @override
  void initState() {
    super.initState();
    unawaited(
      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.deepLinkUrl ?? deepLink.destination);
        },
      ),
    );
  }
}