@datalyr/react-native 1.3.0 → 1.4.0

package/ios/DatalyrSKAdNetworkModule.swift

@@ -0,0 +1,333 @@
+import ExpoModulesCore
+import StoreKit
+
+public class DatalyrSKAdNetworkModule: Module {
+  public func definition() -> ModuleDefinition {
+    Name("DatalyrSKAdNetwork")
+
+    // SKAN 3.0 - Legacy method for iOS 14.0-16.0
+    AsyncFunction("updateConversionValue") { (value: Int, promise: Promise) in
+      if #available(iOS 14.0, *) {
+        SKAdNetwork.updateConversionValue(value)
+        promise.resolve(true)
+      } else {
+        promise.reject("ios_version_error", "SKAdNetwork requires iOS 14.0+")
+      }
+    }
+
+    // SKAN 4.0 / AdAttributionKit - Method for iOS 16.1+ with coarse value and lock window support
+    // On iOS 17.4+, this uses AdAttributionKit under the hood
+    AsyncFunction("updatePostbackConversionValue") { (fineValue: Int, coarseValue: String, lockWindow: Bool, promise: Promise) in
+      guard fineValue >= 0 && fineValue <= 63 else {
+        promise.reject("invalid_value", "Conversion value must be between 0 and 63")
+        return
+      }
+
+      if #available(iOS 16.1, *) {
+        let coarse = Self.mapCoarseValue(coarseValue)
+
+        SKAdNetwork.updatePostbackConversionValue(fineValue, coarseValue: coarse, lockWindow: lockWindow) { error in
+          if let error = error {
+            promise.reject("skadnetwork_error", error.localizedDescription)
+          } else {
+            var framework = "SKAdNetwork"
+            if #available(iOS 17.4, *) {
+              framework = "AdAttributionKit"
+            }
+            promise.resolve([
+              "success": true,
+              "framework": framework,
+              "fineValue": fineValue,
+              "coarseValue": coarseValue,
+              "lockWindow": lockWindow
+            ] as [String: Any])
+          }
+        }
+      } else if #available(iOS 14.0, *) {
+        // Fallback to SKAN 3.0 for iOS 14.0-16.0
+        SKAdNetwork.updateConversionValue(fineValue)
+        promise.resolve([
+          "success": true,
+          "framework": "SKAdNetwork",
+          "fineValue": fineValue,
+          "coarseValue": "n/a",
+          "lockWindow": false
+        ] as [String: Any])
+      } else {
+        promise.reject("ios_version_error", "SKAdNetwork requires iOS 14.0+")
+      }
+    }
+
+    // Check if SKAN 4.0 is available (iOS 16.1+)
+    AsyncFunction("isSKAN4Available") { (promise: Promise) in
+      if #available(iOS 16.1, *) {
+        promise.resolve(true)
+      } else {
+        promise.resolve(false)
+      }
+    }
+
+    // Check if AdAttributionKit is available (iOS 17.4+)
+    AsyncFunction("isAdAttributionKitAvailable") { (promise: Promise) in
+      if #available(iOS 17.4, *) {
+        promise.resolve(true)
+      } else {
+        promise.resolve(false)
+      }
+    }
+
+    // Check if overlapping windows are available (iOS 18.4+)
+    AsyncFunction("isOverlappingWindowsAvailable") { (promise: Promise) in
+      if #available(iOS 18.4, *) {
+        promise.resolve(true)
+      } else {
+        promise.resolve(false)
+      }
+    }
+
+    // Register for ad network attribution (supports both AdAttributionKit and SKAdNetwork)
+    AsyncFunction("registerForAttribution") { (promise: Promise) in
+      if #available(iOS 17.4, *) {
+        SKAdNetwork.updatePostbackConversionValue(0, coarseValue: .low, lockWindow: false) { error in
+          if let error = error {
+            promise.reject("attribution_error", error.localizedDescription)
+          } else {
+            promise.resolve(["framework": "AdAttributionKit", "registered": true] as [String: Any])
+          }
+        }
+      } else if #available(iOS 14.0, *) {
+        SKAdNetwork.registerAppForAdNetworkAttribution()
+        promise.resolve(["framework": "SKAdNetwork", "registered": true] as [String: Any])
+      } else {
+        promise.reject("ios_version_error", "Attribution requires iOS 14.0+")
+      }
+    }
+
+    // Get attribution framework info
+    AsyncFunction("getAttributionInfo") { (promise: Promise) in
+      promise.resolve(Self.buildAttributionInfo())
+    }
+
+    // Update conversion value for re-engagement (AdAttributionKit iOS 17.4+ only)
+    AsyncFunction("updateReengagementConversionValue") { (fineValue: Int, coarseValue: String, lockWindow: Bool, promise: Promise) in
+      if #available(iOS 17.4, *) {
+        guard fineValue >= 0 && fineValue <= 63 else {
+          promise.reject("invalid_value", "Conversion value must be between 0 and 63")
+          return
+        }
+
+        let coarse = Self.mapCoarseValue(coarseValue)
+
+        SKAdNetwork.updatePostbackConversionValue(fineValue, coarseValue: coarse, lockWindow: lockWindow) { error in
+          if let error = error {
+            promise.reject("reengagement_error", error.localizedDescription)
+          } else {
+            promise.resolve([
+              "success": true,
+              "type": "reengagement",
+              "framework": "AdAttributionKit",
+              "fineValue": fineValue,
+              "coarseValue": coarseValue,
+              "lockWindow": lockWindow
+            ] as [String: Any])
+          }
+        }
+      } else {
+        promise.reject("unsupported", "Re-engagement attribution requires iOS 17.4+ (AdAttributionKit)")
+      }
+    }
+
+    // iOS 18.4+ - Check if geo-level postback data is available
+    AsyncFunction("isGeoPostbackAvailable") { (promise: Promise) in
+      if #available(iOS 18.4, *) {
+        promise.resolve(true)
+      } else {
+        promise.resolve(false)
+      }
+    }
+
+    // iOS 18.4+ - Set postback environment for testing
+    AsyncFunction("setPostbackEnvironment") { (environment: String, promise: Promise) in
+      if #available(iOS 18.4, *) {
+        let isSandbox = environment == "sandbox"
+        NSLog("[Datalyr] Postback environment set to: %@ (note: actual sandbox mode is controlled via device Developer Mode)", environment)
+        promise.resolve([
+          "environment": environment,
+          "isSandbox": isSandbox,
+          "note": "Enable Developer Mode in iOS Settings for sandbox postbacks"
+        ] as [String: Any])
+      } else {
+        promise.reject("unsupported", "Development postbacks require iOS 18.4+")
+      }
+    }
+
+    // iOS 18.4+ - Get enhanced attribution info including geo availability
+    AsyncFunction("getEnhancedAttributionInfo") { (promise: Promise) in
+      promise.resolve(Self.buildEnhancedAttributionInfo())
+    }
+
+    // iOS 18.4+ - Update postback with overlapping window support
+    AsyncFunction("updatePostbackWithWindow") { (fineValue: Int, coarseValue: String, lockWindow: Bool, windowIndex: Int, promise: Promise) in
+      guard fineValue >= 0 && fineValue <= 63 else {
+        promise.reject("invalid_value", "Conversion value must be between 0 and 63")
+        return
+      }
+
+      guard windowIndex >= 0 && windowIndex <= 2 else {
+        promise.reject("invalid_window", "Window index must be 0, 1, or 2")
+        return
+      }
+
+      if #available(iOS 16.1, *) {
+        let coarse = Self.mapCoarseValue(coarseValue)
+
+        SKAdNetwork.updatePostbackConversionValue(fineValue, coarseValue: coarse, lockWindow: lockWindow) { error in
+          if let error = error {
+            promise.reject("postback_error", error.localizedDescription)
+          } else {
+            var framework = "SKAdNetwork"
+            var version = "4.0"
+            var overlapping = false
+
+            if #available(iOS 18.4, *) {
+              framework = "AdAttributionKit"
+              version = "2.0"
+              overlapping = true
+            } else if #available(iOS 17.4, *) {
+              framework = "AdAttributionKit"
+              version = "1.0"
+            }
+
+            promise.resolve([
+              "success": true,
+              "framework": framework,
+              "version": version,
+              "fineValue": fineValue,
+              "coarseValue": coarseValue,
+              "lockWindow": lockWindow,
+              "windowIndex": windowIndex,
+              "overlappingWindows": overlapping,
+            ] as [String: Any])
+          }
+        }
+      } else {
+        promise.reject("unsupported", "This method requires iOS 16.1+")
+      }
+    }
+  }
+
+  // MARK: - Helper Methods
+
+  @available(iOS 16.1, *)
+  private static func mapCoarseValue(_ value: String) -> SKAdNetwork.CoarseConversionValue {
+    switch value {
+    case "high": return .high
+    case "medium": return .medium
+    default: return .low
+    }
+  }
+
+  private static func buildAttributionInfo() -> [String: Any] {
+    var info: [String: Any] = [:]
+
+    if #available(iOS 17.4, *) {
+      info["framework"] = "AdAttributionKit"
+      info["version"] = "1.0"
+      info["reengagement_available"] = true
+      info["fine_value_range"] = ["min": 0, "max": 63]
+      info["coarse_values"] = ["low", "medium", "high"]
+      if #available(iOS 18.4, *) {
+        info["overlapping_windows"] = true
+      } else {
+        info["overlapping_windows"] = false
+      }
+    } else if #available(iOS 16.1, *) {
+      info["framework"] = "SKAdNetwork"
+      info["version"] = "4.0"
+      info["reengagement_available"] = false
+      info["overlapping_windows"] = false
+      info["fine_value_range"] = ["min": 0, "max": 63]
+      info["coarse_values"] = ["low", "medium", "high"]
+    } else if #available(iOS 14.0, *) {
+      info["framework"] = "SKAdNetwork"
+      info["version"] = "3.0"
+      info["reengagement_available"] = false
+      info["overlapping_windows"] = false
+      info["fine_value_range"] = ["min": 0, "max": 63]
+      info["coarse_values"] = [] as [String]
+    } else {
+      info["framework"] = "none"
+      info["version"] = "0"
+      info["reengagement_available"] = false
+      info["overlapping_windows"] = false
+      info["fine_value_range"] = ["min": 0, "max": 0]
+      info["coarse_values"] = [] as [String]
+    }
+
+    return info
+  }
+
+  private static func buildEnhancedAttributionInfo() -> [String: Any] {
+    if #available(iOS 18.4, *) {
+      return [
+        "framework": "AdAttributionKit",
+        "version": "2.0",
+        "reengagement_available": true,
+        "overlapping_windows": true,
+        "geo_postback_available": true,
+        "development_postbacks": true,
+        "fine_value_range": ["min": 0, "max": 63],
+        "coarse_values": ["low", "medium", "high"],
+        "features": ["overlapping_windows", "geo_level_postbacks", "development_postbacks", "reengagement"]
+      ] as [String: Any]
+    } else if #available(iOS 17.4, *) {
+      return [
+        "framework": "AdAttributionKit",
+        "version": "1.0",
+        "reengagement_available": true,
+        "overlapping_windows": false,
+        "geo_postback_available": false,
+        "development_postbacks": false,
+        "fine_value_range": ["min": 0, "max": 63],
+        "coarse_values": ["low", "medium", "high"],
+        "features": ["reengagement"]
+      ] as [String: Any]
+    } else if #available(iOS 16.1, *) {
+      return [
+        "framework": "SKAdNetwork",
+        "version": "4.0",
+        "reengagement_available": false,
+        "overlapping_windows": false,
+        "geo_postback_available": false,
+        "development_postbacks": false,
+        "fine_value_range": ["min": 0, "max": 63],
+        "coarse_values": ["low", "medium", "high"],
+        "features": [] as [String]
+      ] as [String: Any]
+    } else if #available(iOS 14.0, *) {
+      return [
+        "framework": "SKAdNetwork",
+        "version": "3.0",
+        "reengagement_available": false,
+        "overlapping_windows": false,
+        "geo_postback_available": false,
+        "development_postbacks": false,
+        "fine_value_range": ["min": 0, "max": 63],
+        "coarse_values": [] as [String],
+        "features": [] as [String]
+      ] as [String: Any]
+    } else {
+      return [
+        "framework": "none",
+        "version": "0",
+        "reengagement_available": false,
+        "overlapping_windows": false,
+        "geo_postback_available": false,
+        "development_postbacks": false,
+        "fine_value_range": ["min": 0, "max": 0],
+        "coarse_values": [] as [String],
+        "features": [] as [String]
+      ] as [String: Any]
+    }
+  }
+}

package/ios/PrivacyInfo.xcprivacy

@@ -0,0 +1,48 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>NSPrivacyTracking</key>
+    <false/>
+    <key>NSPrivacyTrackingDomains</key>
+    <array/>
+    <key>NSPrivacyCollectedDataTypes</key>
+    <array>
+        <dict>
+            <key>NSPrivacyCollectedDataType</key>
+            <string>NSPrivacyCollectedDataTypeDeviceID</string>
+            <key>NSPrivacyCollectedDataTypeLinked</key>
+            <false/>
+            <key>NSPrivacyCollectedDataTypeTracking</key>
+            <false/>
+            <key>NSPrivacyCollectedDataTypePurposes</key>
+            <array>
+                <string>NSPrivacyCollectedDataTypePurposeAnalytics</string>
+            </array>
+        </dict>
+        <dict>
+            <key>NSPrivacyCollectedDataType</key>
+            <string>NSPrivacyCollectedDataTypeProductInteraction</string>
+            <key>NSPrivacyCollectedDataTypeLinked</key>
+            <false/>
+            <key>NSPrivacyCollectedDataTypeTracking</key>
+            <false/>
+            <key>NSPrivacyCollectedDataTypePurposes</key>
+            <array>
+                <string>NSPrivacyCollectedDataTypePurposeAnalytics</string>
+            </array>
+        </dict>
+    </array>
+    <key>NSPrivacyAccessedAPITypes</key>
+    <array>
+        <dict>
+            <key>NSPrivacyAccessedAPIType</key>
+            <string>NSPrivacyAccessedAPICategoryUserDefaults</string>
+            <key>NSPrivacyAccessedAPITypeReasons</key>
+            <array>
+                <string>CA92.1</string>
+            </array>
+        </dict>
+    </array>
+</dict>
+</plist>

package/lib/datalyr-sdk.d.ts

@@ -8,6 +8,7 @@ export declare class DatalyrSDK {
     private eventQueue;
     private autoEventsManager;
     private appStateSubscription;
+    private networkStatusUnsubscribe;
     private static conversionEncoder?;
     private static debugEnabled;
     constructor();
@@ -193,6 +194,11 @@ export declare class DatalyrSDK {
      * Persist user data to storage
      */
     private persistUserData;
+    /**
+     * Initialize network status monitoring
+     * Automatically updates event queue when network status changes
+     */
+    private initializeNetworkMonitoring;
     /**
      * Set up app state monitoring for lifecycle events (optimized)
      */

package/lib/datalyr-sdk.js

@@ -8,10 +8,12 @@ import { AutoEventsManager } from './auto-events';
 import { ConversionValueEncoder, ConversionTemplates } from './ConversionValueEncoder';
 import { SKAdNetworkBridge } from './native/SKAdNetworkBridge';
 import { metaIntegration, tiktokIntegration, appleSearchAdsIntegration, playInstallReferrerIntegration } from './integrations';
+import { networkStatusManager } from './network-status';
 export class DatalyrSDK {
     constructor() {
         this.autoEventsManager = null;
         this.appStateSubscription = null;
+        this.networkStatusUnsubscribe = null;
         // Initialize state with defaults
         this.state = {
             initialized: false,
@@ -73,18 +75,20 @@ export class DatalyrSDK {
                 flushInterval: this.state.config.flushInterval || 30000,
                 maxRetryCount: this.state.config.maxRetries || 3,
             });
-            // Initialize visitor ID, anonymous ID and session
-            this.state.visitorId = await getOrCreateVisitorId();
-            this.state.anonymousId = await getOrCreateAnonymousId();
-            this.state.sessionId = await getOrCreateSessionId();
-            // Load persisted user data
-            await this.loadPersistedUserData();
-            // Initialize attribution manager
-            if (this.state.config.enableAttribution) {
-                await attributionManager.initialize();
-            }
-            // Initialize journey tracking (for first-touch, last-touch, touchpoints)
-            await journeyManager.initialize();
+            // PARALLEL INITIALIZATION: IDs and core managers
+            // Run ID creation and core manager initialization in parallel for faster startup
+            const [visitorId, anonymousId, sessionId] = await Promise.all([
+                getOrCreateVisitorId(),
+                getOrCreateAnonymousId(),
+                getOrCreateSessionId(),
+                // These run concurrently but don't return values we need to capture
+                this.loadPersistedUserData(),
+                this.state.config.enableAttribution ? attributionManager.initialize() : Promise.resolve(),
+                journeyManager.initialize(),
+            ]);
+            this.state.visitorId = visitorId;
+            this.state.anonymousId = anonymousId;
+            this.state.sessionId = sessionId;
             // Record initial attribution to journey if this is a new session with attribution
             const initialAttribution = attributionManager.getAttributionData();
             if (initialAttribution.utm_source || initialAttribution.fbclid || initialAttribution.gclid || initialAttribution.lyr) {
@@ -122,7 +126,7 @@ export class DatalyrSDK {
                     errorLog('Error setting up app state monitoring (non-blocking):', error);
                 }
             }, 50);
-            // Initialize SKAdNetwork conversion encoder
+            // Initialize SKAdNetwork conversion encoder (synchronous, no await needed)
             if (config.skadTemplate) {
                 const template = ConversionTemplates[config.skadTemplate];
                 if (template) {
@@ -134,25 +138,34 @@ export class DatalyrSDK {
                     }
                 }
             }
-            // Initialize Meta SDK if configured
+            // PARALLEL INITIALIZATION: Network monitoring and platform integrations
+            // These are independent and can run concurrently for faster startup
+            const platformInitPromises = [
+                // Network monitoring
+                this.initializeNetworkMonitoring(),
+                // Apple Search Ads (iOS only)
+                appleSearchAdsIntegration.initialize(config.debug),
+                // Google Play Install Referrer (Android only)
+                playInstallReferrerIntegration.initialize(),
+            ];
+            // Add Meta initialization if configured
             if ((_b = config.meta) === null || _b === void 0 ? void 0 : _b.appId) {
-                await metaIntegration.initialize(config.meta, config.debug);
-                // Fetch deferred deep link and merge with attribution
-                if (config.enableAttribution !== false) {
-                    const deferredLink = await metaIntegration.fetchDeferredDeepLink();
-                    if (deferredLink) {
-                        await this.handleDeferredDeepLink(deferredLink);
+                platformInitPromises.push(metaIntegration.initialize(config.meta, config.debug).then(async () => {
+                    // After Meta initializes, fetch deferred deep link
+                    if (config.enableAttribution !== false) {
+                        const deferredLink = await metaIntegration.fetchDeferredDeepLink();
+                        if (deferredLink) {
+                            await this.handleDeferredDeepLink(deferredLink);
+                        }
                     }
-                }
+                }));
             }
-            // Initialize TikTok SDK if configured
+            // Add TikTok initialization if configured
             if (((_c = config.tiktok) === null || _c === void 0 ? void 0 : _c.appId) && ((_d = config.tiktok) === null || _d === void 0 ? void 0 : _d.tiktokAppId)) {
-                await tiktokIntegration.initialize(config.tiktok, config.debug);
+                platformInitPromises.push(tiktokIntegration.initialize(config.tiktok, config.debug));
             }
-            // Initialize Apple Search Ads attribution (iOS only, auto-fetches on init)
-            await appleSearchAdsIntegration.initialize(config.debug);
-            // Initialize Google Play Install Referrer (Android only)
-            await playInstallReferrerIntegration.initialize();
+            // Wait for all platform integrations to complete
+            await Promise.all(platformInitPromises);
             debugLog('Platform integrations initialized', {
                 meta: metaIntegration.isAvailable(),
                 tiktok: tiktokIntegration.isAvailable(),
@@ -900,6 +913,41 @@ export class DatalyrSDK {
             errorLog('Error persisting user data:', error);
         }
     }
+    /**
+     * Initialize network status monitoring
+     * Automatically updates event queue when network status changes
+     */
+    async initializeNetworkMonitoring() {
+        try {
+            await networkStatusManager.initialize();
+            // Update event queue with current network status
+            this.state.isOnline = networkStatusManager.isOnline();
+            this.eventQueue.setOnlineStatus(this.state.isOnline);
+            // Subscribe to network changes
+            this.networkStatusUnsubscribe = networkStatusManager.subscribe((state) => {
+                const isOnline = state.isConnected && (state.isInternetReachable !== false);
+                this.state.isOnline = isOnline;
+                this.eventQueue.setOnlineStatus(isOnline);
+                // Track network status change event (only if SDK is fully initialized)
+                if (this.state.initialized) {
+                    this.track('$network_status_change', {
+                        is_online: isOnline,
+                        network_type: state.type,
+                        is_internet_reachable: state.isInternetReachable,
+                    }).catch(() => {
+                        // Ignore errors for network status events
+                    });
+                }
+            });
+            debugLog(`Network monitoring initialized, online: ${this.state.isOnline}`);
+        }
+        catch (error) {
+            errorLog('Error initializing network monitoring (non-blocking):', error);
+            // Default to online if monitoring fails
+            this.state.isOnline = true;
+            this.eventQueue.setOnlineStatus(true);
+        }
+    }
     /**
      * Set up app state monitoring for lifecycle events (optimized)
      */
@@ -920,6 +968,8 @@ export class DatalyrSDK {
                 else if (nextAppState === 'active') {
                     // App became active, ensure we have fresh session if needed
                     this.refreshSession();
+                    // Refresh network status when coming back from background
+                    networkStatusManager.refresh();
                     // Notify auto-events manager for session handling
                     if (this.autoEventsManager) {
                         this.autoEventsManager.handleAppForeground();
@@ -957,6 +1007,13 @@ export class DatalyrSDK {
                 this.appStateSubscription.remove();
                 this.appStateSubscription = null;
             }
+            // Remove network status listener
+            if (this.networkStatusUnsubscribe) {
+                this.networkStatusUnsubscribe();
+                this.networkStatusUnsubscribe = null;
+            }
+            // Destroy network status manager
+            networkStatusManager.destroy();
             // Destroy event queue
             this.eventQueue.destroy();
             // Reset state

package/lib/index.d.ts

@@ -12,6 +12,8 @@ export * from './event-queue';
 export { DatalyrSDK };
 export { ConversionValueEncoder, ConversionTemplates } from './ConversionValueEncoder';
 export { SKAdNetworkBridge } from './native/SKAdNetworkBridge';
-export { metaIntegration, tiktokIntegration, appleSearchAdsIntegration } from './integrations';
+export { metaIntegration, tiktokIntegration, appleSearchAdsIntegration, playInstallReferrerIntegration } from './integrations';
+export { networkStatusManager } from './network-status';
+export type { NetworkState, NetworkStateListener } from './network-status';
 export type { AppleSearchAdsAttribution } from './native/DatalyrNativeBridge';
 export default DatalyrSDK;

package/lib/index.js

@@ -20,6 +20,8 @@ export { DatalyrSDK };
 export { ConversionValueEncoder, ConversionTemplates } from './ConversionValueEncoder';
 export { SKAdNetworkBridge } from './native/SKAdNetworkBridge';
 // Export platform integrations
-export { metaIntegration, tiktokIntegration, appleSearchAdsIntegration } from './integrations';
+export { metaIntegration, tiktokIntegration, appleSearchAdsIntegration, playInstallReferrerIntegration } from './integrations';
+// Export network status manager
+export { networkStatusManager } from './network-status';
 // Default export for compatibility
 export default DatalyrSDK;

package/lib/integrations/play-install-referrer.d.ts

@@ -19,7 +19,9 @@
  * - referrer_url: Full referrer URL from Play Store
  * - referrer_click_timestamp: When the referrer link was clicked
  * - install_begin_timestamp: When the install began
- * - gclid: Google Ads click ID (if present)
+ * - gclid: Google Ads click ID (standard)
+ * - gbraid: Google Ads privacy-safe click ID (iOS App campaigns)
+ * - wbraid: Google Ads privacy-safe click ID (Web-to-App campaigns)
  * - utm_source, utm_medium, utm_campaign, etc.
  */
 export interface PlayInstallReferrer {
@@ -28,6 +30,8 @@ export interface PlayInstallReferrer {
     installBeginTimestamp: number;
     installCompleteTimestamp?: number;
     gclid?: string;
+    gbraid?: string;
+    wbraid?: string;
     utmSource?: string;
     utmMedium?: string;
     utmCampaign?: string;

package/lib/integrations/play-install-referrer.js

@@ -19,7 +19,9 @@
  * - referrer_url: Full referrer URL from Play Store
  * - referrer_click_timestamp: When the referrer link was clicked
  * - install_begin_timestamp: When the install began
- * - gclid: Google Ads click ID (if present)
+ * - gclid: Google Ads click ID (standard)
+ * - gbraid: Google Ads privacy-safe click ID (iOS App campaigns)
+ * - wbraid: Google Ads privacy-safe click ID (Web-to-App campaigns)
  * - utm_source, utm_medium, utm_campaign, etc.
  */
 import { Platform, NativeModules } from 'react-native';
@@ -61,6 +63,8 @@ class PlayInstallReferrerIntegration {
                     utmSource: this.referrerData.utmSource,
                     utmMedium: this.referrerData.utmMedium,
                     hasGclid: !!this.referrerData.gclid,
+                    hasGbraid: !!this.referrerData.gbraid,
+                    hasWbraid: !!this.referrerData.wbraid,
                 });
             }
         }
@@ -109,11 +113,14 @@ class PlayInstallReferrerIntegration {
             params.utmCampaign = searchParams.get('utm_campaign') || undefined;
             params.utmTerm = searchParams.get('utm_term') || undefined;
             params.utmContent = searchParams.get('utm_content') || undefined;
-            // Extract click IDs
+            // Extract click IDs (gclid, gbraid, wbraid)
             params.gclid = searchParams.get('gclid') || undefined;
+            params.gbraid = searchParams.get('gbraid') || undefined;
+            params.wbraid = searchParams.get('wbraid') || undefined;
             // Store any additional parameters
+            const knownParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content', 'gclid', 'gbraid', 'wbraid'];
             searchParams.forEach((value, key) => {
-                if (!key.startsWith('utm_') && key !== 'gclid') {
+                if (!knownParams.includes(key) && !key.startsWith('utm_')) {
                     params[key] = value;
                 }
             });
@@ -141,8 +148,11 @@ class PlayInstallReferrerIntegration {
             install_referrer_url: this.referrerData.referrerUrl,
             referrer_click_timestamp: this.referrerData.referrerClickTimestamp,
             install_begin_timestamp: this.referrerData.installBeginTimestamp,
-            // Standard attribution fields
+            // Google Ads click IDs (gclid is standard, gbraid/wbraid are privacy-safe alternatives)
             gclid: this.referrerData.gclid,
+            gbraid: this.referrerData.gbraid,
+            wbraid: this.referrerData.wbraid,
+            // UTM parameters
             utm_source: this.referrerData.utmSource,
             utm_medium: this.referrerData.utmMedium,
             utm_campaign: this.referrerData.utmCampaign,