Attribution

await PNLightSDK.shared.addAttribution(
    provider: .appsFlyer,
    data: ["af_status": "Non-organic"],
    identifier: "appsFlyerCustomerId"
)

await PNLightSDK.shared.updateIdfa()

import { addAttribution, updateIdfa } from "@pnlight/sdk-react-native";

await addAttribution(
  "appsFlyer",
  { af_status: "Non-organic" },
  "appsFlyerCustomerId"
);

await updateIdfa();

import AppTrackingTransparency
import AppsFlyerLib
import PNLightSDK
import UIKit

final class AppDelegate: NSObject, UIApplicationDelegate, AppsFlyerLibDelegate {
    func application(
        _ application: UIApplication,
        didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]? = nil
    ) -> Bool {
        AppsFlyerLib.shared().appsFlyerDevKey = "your-appsflyer-dev-key"
        AppsFlyerLib.shared().appleAppID = "your-ios-app-id"
        AppsFlyerLib.shared().delegate = self

        Task {
            await PNLightSDK.shared.initialize(apiKey: "pnlight_sdk_token")
            await ATTrackingManager.requestTrackingAuthorization()
            await PNLightSDK.shared.updateIdfa()
            AppsFlyerLib.shared().customerUserID = PNLightSDK.shared.getUserId()
            AppsFlyerLib.shared().start()
        }

        return true
    }

    func onConversionDataSuccess(_ installData: [AnyHashable: Any]) {
        let data = Dictionary(uniqueKeysWithValues: installData.compactMap { key, value in
            guard let key = key as? String else { return nil }
            return (key, value)
        })

        Task {
            await PNLightSDK.shared.addAttribution(
                provider: .appsFlyer,
                data: data,
                identifier: AppsFlyerLib.shared().getAppsFlyerUID()
            )
        }
    }

    func onConversionDataFail(_ error: Error) {
        print("AppsFlyer conversion data error:", error)
    }
}

import appsFlyer from "react-native-appsflyer";
import { requestTrackingPermission } from "react-native-tracking-transparency";
import {
  addAttribution,
  getUserId,
  initialize,
  updateIdfa,
} from "@pnlight/sdk-react-native";

const getAppsFlyerUID = () =>
  new Promise<string | null>((resolve) => {
    appsFlyer.getAppsFlyerUID((error, uid) => {
      if (error) {
        console.error("AppsFlyer UID error", error);
        resolve(null);
        return;
      }

      resolve(uid);
    });
  });

appsFlyer.onInstallConversionData(async (conversionData) => {
  const appsFlyerId = await getAppsFlyerUID();

  await addAttribution(
    "appsFlyer",
    conversionData?.data ?? conversionData,
    appsFlyerId
  );
});

await initialize("pnlight_sdk_token");
await requestTrackingPermission();
await updateIdfa();

appsFlyer.initSdk({
  devKey: "your-appsflyer-dev-key",
  appId: "your-ios-app-id",
  isDebug: false,
  onInstallConversionDataListener: true,
}, async () => {
  const pnlightUserId = await getUserId();
  appsFlyer.setCustomerUserId(pnlightUserId);
});

import 'package:app_tracking_transparency/app_tracking_transparency.dart';
import 'package:appsflyer_sdk/appsflyer_sdk.dart';
import 'package:pnlight_sdk/pnlight_sdk.dart';

final appsFlyerOptions = AppsFlyerOptions(
  afDevKey: 'your-appsflyer-dev-key',
  appId: 'your-ios-app-id',
  showDebug: false,
);

final appsFlyerSdk = AppsflyerSdk(appsFlyerOptions);

await PNLightSDK.initialize('pnlight_sdk_token');
await AppTrackingTransparency.requestTrackingAuthorization();
await PNLightSDK.updateIdfa();

appsFlyerSdk.onInstallConversionData((conversionData) async {
  final appsFlyerId = await appsFlyerSdk.getAppsFlyerUID();
  final payload = conversionData['payload'] ?? conversionData;

  await PNLightSDK.addAttribution(
    provider: 'appsFlyer',
    data: Map<String, dynamic>.from(payload as Map),
    identifier: appsFlyerId,
  );
});

await appsFlyerSdk.initSdk(
  registerConversionDataCallback: true,
  registerOnAppOpenAttributionCallback: false,
  registerOnDeepLinkingCallback: false,
);