@datalyr/react-native 1.2.1 → 1.3.0

package/lib/journey.js

@@ -0,0 +1,258 @@
+/**
+ * Journey Tracking Module for React Native
+ * Mirrors the Web SDK's journey tracking capabilities:
+ * - First-touch attribution with 90-day expiration
+ * - Last-touch attribution with 90-day expiration
+ * - Up to 30 touchpoints stored
+ */
+import { Storage, debugLog, errorLog } from './utils';
+// Storage keys for journey data
+const JOURNEY_STORAGE_KEYS = {
+    FIRST_TOUCH: '@datalyr/first_touch',
+    LAST_TOUCH: '@datalyr/last_touch',
+    JOURNEY: '@datalyr/journey',
+};
+// 90-day attribution window (matching web SDK)
+const ATTRIBUTION_WINDOW_MS = 90 * 24 * 60 * 60 * 1000;
+// Maximum touchpoints to store
+const MAX_TOUCHPOINTS = 30;
+/**
+ * Journey manager for tracking customer touchpoints
+ */
+export class JourneyManager {
+    constructor() {
+        this.firstTouch = null;
+        this.lastTouch = null;
+        this.journey = [];
+        this.initialized = false;
+    }
+    /**
+     * Initialize journey tracking by loading persisted data
+     */
+    async initialize() {
+        if (this.initialized)
+            return;
+        try {
+            debugLog('Initializing journey manager...');
+            // Load first touch
+            const savedFirstTouch = await Storage.getItem(JOURNEY_STORAGE_KEYS.FIRST_TOUCH);
+            if (savedFirstTouch && !this.isExpired(savedFirstTouch)) {
+                this.firstTouch = savedFirstTouch;
+            }
+            else if (savedFirstTouch) {
+                // Expired, clear it
+                await Storage.removeItem(JOURNEY_STORAGE_KEYS.FIRST_TOUCH);
+            }
+            // Load last touch
+            const savedLastTouch = await Storage.getItem(JOURNEY_STORAGE_KEYS.LAST_TOUCH);
+            if (savedLastTouch && !this.isExpired(savedLastTouch)) {
+                this.lastTouch = savedLastTouch;
+            }
+            else if (savedLastTouch) {
+                await Storage.removeItem(JOURNEY_STORAGE_KEYS.LAST_TOUCH);
+            }
+            // Load journey
+            const savedJourney = await Storage.getItem(JOURNEY_STORAGE_KEYS.JOURNEY);
+            if (savedJourney) {
+                this.journey = savedJourney;
+            }
+            this.initialized = true;
+            debugLog('Journey manager initialized', {
+                hasFirstTouch: !!this.firstTouch,
+                hasLastTouch: !!this.lastTouch,
+                touchpointCount: this.journey.length,
+            });
+        }
+        catch (error) {
+            errorLog('Failed to initialize journey manager:', error);
+        }
+    }
+    /**
+     * Check if attribution has expired
+     */
+    isExpired(attribution) {
+        return Date.now() >= attribution.expires_at;
+    }
+    /**
+     * Store first touch attribution (only if not already set or expired)
+     */
+    async storeFirstTouch(attribution) {
+        try {
+            // Only store if no valid first touch exists
+            if (this.firstTouch && !this.isExpired(this.firstTouch)) {
+                debugLog('First touch already exists, not overwriting');
+                return;
+            }
+            const now = Date.now();
+            this.firstTouch = {
+                ...attribution,
+                timestamp: attribution.timestamp || now,
+                captured_at: now,
+                expires_at: now + ATTRIBUTION_WINDOW_MS,
+            };
+            await Storage.setItem(JOURNEY_STORAGE_KEYS.FIRST_TOUCH, this.firstTouch);
+            debugLog('First touch stored:', this.firstTouch);
+        }
+        catch (error) {
+            errorLog('Failed to store first touch:', error);
+        }
+    }
+    /**
+     * Get first touch attribution (null if expired)
+     */
+    getFirstTouch() {
+        if (this.firstTouch && this.isExpired(this.firstTouch)) {
+            this.firstTouch = null;
+            Storage.removeItem(JOURNEY_STORAGE_KEYS.FIRST_TOUCH).catch(() => { });
+        }
+        return this.firstTouch;
+    }
+    /**
+     * Store last touch attribution (always updates)
+     */
+    async storeLastTouch(attribution) {
+        try {
+            const now = Date.now();
+            this.lastTouch = {
+                ...attribution,
+                timestamp: attribution.timestamp || now,
+                captured_at: now,
+                expires_at: now + ATTRIBUTION_WINDOW_MS,
+            };
+            await Storage.setItem(JOURNEY_STORAGE_KEYS.LAST_TOUCH, this.lastTouch);
+            debugLog('Last touch stored:', this.lastTouch);
+        }
+        catch (error) {
+            errorLog('Failed to store last touch:', error);
+        }
+    }
+    /**
+     * Get last touch attribution (null if expired)
+     */
+    getLastTouch() {
+        if (this.lastTouch && this.isExpired(this.lastTouch)) {
+            this.lastTouch = null;
+            Storage.removeItem(JOURNEY_STORAGE_KEYS.LAST_TOUCH).catch(() => { });
+        }
+        return this.lastTouch;
+    }
+    /**
+     * Add a touchpoint to the customer journey
+     */
+    async addTouchpoint(sessionId, attribution) {
+        try {
+            const touchpoint = {
+                timestamp: Date.now(),
+                sessionId,
+                source: attribution.source,
+                medium: attribution.medium,
+                campaign: attribution.campaign,
+                clickIdType: attribution.clickIdType,
+            };
+            this.journey.push(touchpoint);
+            // Keep only last MAX_TOUCHPOINTS
+            if (this.journey.length > MAX_TOUCHPOINTS) {
+                this.journey = this.journey.slice(-MAX_TOUCHPOINTS);
+            }
+            await Storage.setItem(JOURNEY_STORAGE_KEYS.JOURNEY, this.journey);
+            debugLog('Touchpoint added, total:', this.journey.length);
+        }
+        catch (error) {
+            errorLog('Failed to add touchpoint:', error);
+        }
+    }
+    /**
+     * Get customer journey (all touchpoints)
+     */
+    getJourney() {
+        return [...this.journey];
+    }
+    /**
+     * Record attribution from a deep link or install
+     * Updates first-touch (if not set), last-touch, and adds touchpoint
+     */
+    async recordAttribution(sessionId, attribution) {
+        // Only process if we have meaningful attribution data
+        const hasAttribution = attribution.source || attribution.clickId || attribution.campaign || attribution.lyr;
+        if (!hasAttribution) {
+            debugLog('No attribution data to record');
+            return;
+        }
+        // Store first touch if not set
+        if (!this.getFirstTouch()) {
+            await this.storeFirstTouch(attribution);
+        }
+        // Always update last touch
+        await this.storeLastTouch(attribution);
+        // Add touchpoint
+        await this.addTouchpoint(sessionId, attribution);
+    }
+    /**
+     * Get attribution data for events (mirrors Web SDK format)
+     */
+    getAttributionData() {
+        const firstTouch = this.getFirstTouch();
+        const lastTouch = this.getLastTouch();
+        const journey = this.getJourney();
+        return {
+            // First touch (with snake_case and camelCase aliases)
+            first_touch_source: firstTouch === null || firstTouch === void 0 ? void 0 : firstTouch.source,
+            first_touch_medium: firstTouch === null || firstTouch === void 0 ? void 0 : firstTouch.medium,
+            first_touch_campaign: firstTouch === null || firstTouch === void 0 ? void 0 : firstTouch.campaign,
+            first_touch_timestamp: firstTouch === null || firstTouch === void 0 ? void 0 : firstTouch.timestamp,
+            firstTouchSource: firstTouch === null || firstTouch === void 0 ? void 0 : firstTouch.source,
+            firstTouchMedium: firstTouch === null || firstTouch === void 0 ? void 0 : firstTouch.medium,
+            firstTouchCampaign: firstTouch === null || firstTouch === void 0 ? void 0 : firstTouch.campaign,
+            // Last touch
+            last_touch_source: lastTouch === null || lastTouch === void 0 ? void 0 : lastTouch.source,
+            last_touch_medium: lastTouch === null || lastTouch === void 0 ? void 0 : lastTouch.medium,
+            last_touch_campaign: lastTouch === null || lastTouch === void 0 ? void 0 : lastTouch.campaign,
+            last_touch_timestamp: lastTouch === null || lastTouch === void 0 ? void 0 : lastTouch.timestamp,
+            lastTouchSource: lastTouch === null || lastTouch === void 0 ? void 0 : lastTouch.source,
+            lastTouchMedium: lastTouch === null || lastTouch === void 0 ? void 0 : lastTouch.medium,
+            lastTouchCampaign: lastTouch === null || lastTouch === void 0 ? void 0 : lastTouch.campaign,
+            // Journey metrics
+            touchpoint_count: journey.length,
+            touchpointCount: journey.length,
+            days_since_first_touch: (firstTouch === null || firstTouch === void 0 ? void 0 : firstTouch.timestamp)
+                ? Math.floor((Date.now() - firstTouch.timestamp) / 86400000)
+                : 0,
+            daysSinceFirstTouch: (firstTouch === null || firstTouch === void 0 ? void 0 : firstTouch.timestamp)
+                ? Math.floor((Date.now() - firstTouch.timestamp) / 86400000)
+                : 0,
+        };
+    }
+    /**
+     * Clear all journey data (for testing/reset)
+     */
+    async clearJourney() {
+        this.firstTouch = null;
+        this.lastTouch = null;
+        this.journey = [];
+        await Promise.all([
+            Storage.removeItem(JOURNEY_STORAGE_KEYS.FIRST_TOUCH),
+            Storage.removeItem(JOURNEY_STORAGE_KEYS.LAST_TOUCH),
+            Storage.removeItem(JOURNEY_STORAGE_KEYS.JOURNEY),
+        ]);
+        debugLog('Journey data cleared');
+    }
+    /**
+     * Get journey summary for debugging
+     */
+    getJourneySummary() {
+        const firstTouch = this.getFirstTouch();
+        const journey = this.getJourney();
+        const sources = [...new Set(journey.map(t => t.source).filter(Boolean))];
+        return {
+            hasFirstTouch: !!firstTouch,
+            hasLastTouch: !!this.getLastTouch(),
+            touchpointCount: journey.length,
+            daysSinceFirstTouch: (firstTouch === null || firstTouch === void 0 ? void 0 : firstTouch.timestamp)
+                ? Math.floor((Date.now() - firstTouch.timestamp) / 86400000)
+                : 0,
+            sources,
+        };
+    }
+}
+// Export singleton instance
+export const journeyManager = new JourneyManager();

package/lib/native/DatalyrNativeBridge.d.ts

@@ -1,9 +1,13 @@
 /**
- * Native Bridge for Meta, TikTok, and Apple Search Ads
+ * Native Bridge for Meta, TikTok, Apple Search Ads, and Play Install Referrer
  * Uses bundled native modules instead of separate npm packages
+ *
+ * Supported Platforms:
+ * - iOS: Meta SDK, TikTok SDK, Apple Search Ads (AdServices)
+ * - Android: Meta SDK, TikTok SDK, Play Install Referrer
  */
 /**
- * Apple Search Ads attribution data returned from AdServices API
+ * Apple Search Ads attribution data returned from AdServices API (iOS only)
  */
 export interface AppleSearchAdsAttribution {
     attribution: boolean;
@@ -19,17 +23,36 @@ export interface AppleSearchAdsAttribution {
     conversionType?: string;
     countryOrRegion?: string;
 }
+/**
+ * Play Install Referrer data (Android only)
+ */
+export interface PlayInstallReferrerData {
+    referrerUrl: string;
+    referrerClickTimestamp: number;
+    installBeginTimestamp: number;
+    installCompleteTimestamp?: number;
+    gclid?: string;
+    fbclid?: string;
+    ttclid?: string;
+    utmSource?: string;
+    utmMedium?: string;
+    utmCampaign?: string;
+    utmTerm?: string;
+    utmContent?: string;
+    referrer?: string;
+}
 /**
  * Check if native module is available
  */
 export declare const isNativeModuleAvailable: () => boolean;
 /**
- * Get SDK availability status
+ * Get SDK availability status for all platforms
  */
 export declare const getSDKAvailability: () => Promise<{
     meta: boolean;
     tiktok: boolean;
     appleSearchAds: boolean;
+    playInstallReferrer: boolean;
 }>;
 export declare const MetaNativeBridge: {
     initialize(appId: string, clientToken?: string, advertiserTrackingEnabled?: boolean): Promise<boolean>;
@@ -55,3 +78,19 @@ export declare const AppleSearchAdsNativeBridge: {
      */
     getAttribution(): Promise<AppleSearchAdsAttribution | null>;
 };
+export declare const PlayInstallReferrerNativeBridge: {
+    /**
+     * Check if Play Install Referrer is available
+     * Only available on Android with Google Play Services
+     */
+    isAvailable(): Promise<boolean>;
+    /**
+     * Get install referrer data from Google Play
+     *
+     * Returns UTM parameters, click IDs (gclid, fbclid, ttclid), and timestamps
+     * from the Google Play Store referrer.
+     *
+     * Call this on first app launch to capture install attribution.
+     */
+    getInstallReferrer(): Promise<PlayInstallReferrerData | null>;
+};

package/lib/native/DatalyrNativeBridge.js

@@ -1,10 +1,17 @@
 /**
- * Native Bridge for Meta, TikTok, and Apple Search Ads
+ * Native Bridge for Meta, TikTok, Apple Search Ads, and Play Install Referrer
  * Uses bundled native modules instead of separate npm packages
+ *
+ * Supported Platforms:
+ * - iOS: Meta SDK, TikTok SDK, Apple Search Ads (AdServices)
+ * - Android: Meta SDK, TikTok SDK, Play Install Referrer
  */
+var _a;
 import { NativeModules, Platform } from 'react-native';
-// Native module is only available on iOS
-const DatalyrNative = Platform.OS === 'ios' ? NativeModules.DatalyrNative : null;
+// Native modules - available on both iOS and Android
+const DatalyrNative = (_a = NativeModules.DatalyrNative) !== null && _a !== void 0 ? _a : null;
+// Play Install Referrer - Android only
+const DatalyrPlayInstallReferrer = Platform.OS === 'android' ? NativeModules.DatalyrPlayInstallReferrer : null;
 /**
  * Check if native module is available
  */
@@ -12,17 +19,28 @@ export const isNativeModuleAvailable = () => {
     return DatalyrNative !== null;
 };
 /**
- * Get SDK availability status
+ * Get SDK availability status for all platforms
  */
 export const getSDKAvailability = async () => {
+    const defaultAvailability = {
+        meta: false,
+        tiktok: false,
+        appleSearchAds: false,
+        playInstallReferrer: false,
+    };
     if (!DatalyrNative) {
-        return { meta: false, tiktok: false, appleSearchAds: false };
+        return defaultAvailability;
     }
     try {
-        return await DatalyrNative.getSDKAvailability();
+        const result = await DatalyrNative.getSDKAvailability();
+        return {
+            ...defaultAvailability,
+            ...result,
+            playInstallReferrer: Platform.OS === 'android' && DatalyrPlayInstallReferrer !== null,
+        };
     }
     catch (_a) {
-        return { meta: false, tiktok: false, appleSearchAds: false };
+        return defaultAvailability;
     }
 };
 // MARK: - Meta SDK Bridge
@@ -166,7 +184,7 @@ export const TikTokNativeBridge = {
         }
     },
 };
-// MARK: - Apple Search Ads Bridge
+// MARK: - Apple Search Ads Bridge (iOS only)
 export const AppleSearchAdsNativeBridge = {
     /**
      * Get Apple Search Ads attribution data
@@ -174,7 +192,7 @@ export const AppleSearchAdsNativeBridge = {
      * Returns null if user didn't come from Apple Search Ads or on older iOS
      */
     async getAttribution() {
-        if (!DatalyrNative)
+        if (!DatalyrNative || Platform.OS !== 'ios')
             return null;
         try {
             return await DatalyrNative.getAppleSearchAdsAttribution();
@@ -185,3 +203,39 @@ export const AppleSearchAdsNativeBridge = {
         }
     },
 };
+// MARK: - Play Install Referrer Bridge (Android only)
+export const PlayInstallReferrerNativeBridge = {
+    /**
+     * Check if Play Install Referrer is available
+     * Only available on Android with Google Play Services
+     */
+    async isAvailable() {
+        if (!DatalyrPlayInstallReferrer || Platform.OS !== 'android')
+            return false;
+        try {
+            return await DatalyrPlayInstallReferrer.isAvailable();
+        }
+        catch (_a) {
+            return false;
+        }
+    },
+    /**
+     * Get install referrer data from Google Play
+     *
+     * Returns UTM parameters, click IDs (gclid, fbclid, ttclid), and timestamps
+     * from the Google Play Store referrer.
+     *
+     * Call this on first app launch to capture install attribution.
+     */
+    async getInstallReferrer() {
+        if (!DatalyrPlayInstallReferrer || Platform.OS !== 'android')
+            return null;
+        try {
+            return await DatalyrPlayInstallReferrer.getInstallReferrer();
+        }
+        catch (error) {
+            console.error('[Datalyr/PlayInstallReferrer] Get referrer failed:', error);
+            return null;
+        }
+    },
+};

package/lib/native/SKAdNetworkBridge.d.ts

@@ -1,4 +1,25 @@
+export type SKANCoarseValue = 'low' | 'medium' | 'high';
+export interface SKANConversionResult {
+    fineValue: number;
+    coarseValue: SKANCoarseValue;
+    lockWindow: boolean;
+    priority: number;
+}
 export declare class SKAdNetworkBridge {
+    private static _isSKAN4Available;
+    /**
+     * SKAN 3.0 - Update conversion value (0-63)
+     * @deprecated Use updatePostbackConversionValue for iOS 16.1+
+     */
     static updateConversionValue(value: number): Promise<boolean>;
+    /**
+     * SKAN 4.0 - Update postback conversion value with coarse value and lock window
+     * Falls back to SKAN 3.0 on iOS 14.0-16.0
+     */
+    static updatePostbackConversionValue(result: SKANConversionResult): Promise<boolean>;
+    /**
+     * Check if SKAN 4.0 is available (iOS 16.1+)
+     */
+    static isSKAN4Available(): Promise<boolean>;
     static isAvailable(): boolean;
 }

package/lib/native/SKAdNetworkBridge.js

@@ -1,6 +1,10 @@
 import { NativeModules, Platform } from 'react-native';
 const { DatalyrSKAdNetwork } = NativeModules;
 export class SKAdNetworkBridge {
+    /**
+     * SKAN 3.0 - Update conversion value (0-63)
+     * @deprecated Use updatePostbackConversionValue for iOS 16.1+
+     */
     static async updateConversionValue(value) {
         if (Platform.OS !== 'ios') {
             return false; // Android doesn't support SKAdNetwork
@@ -19,7 +23,57 @@ export class SKAdNetworkBridge {
             return false;
         }
     }
+    /**
+     * SKAN 4.0 - Update postback conversion value with coarse value and lock window
+     * Falls back to SKAN 3.0 on iOS 14.0-16.0
+     */
+    static async updatePostbackConversionValue(result) {
+        if (Platform.OS !== 'ios') {
+            return false; // Android doesn't support SKAdNetwork
+        }
+        if (!DatalyrSKAdNetwork) {
+            console.warn('[Datalyr] SKAdNetwork native module not found. Ensure native bridge is properly configured.');
+            return false;
+        }
+        try {
+            const success = await DatalyrSKAdNetwork.updatePostbackConversionValue(result.fineValue, result.coarseValue, result.lockWindow);
+            const isSKAN4 = await this.isSKAN4Available();
+            if (isSKAN4) {
+                console.log(`[Datalyr] SKAN 4.0 postback updated: fineValue=${result.fineValue}, coarseValue=${result.coarseValue}, lockWindow=${result.lockWindow}`);
+            }
+            else {
+                console.log(`[Datalyr] SKAN 3.0 fallback: conversionValue=${result.fineValue}`);
+            }
+            return success;
+        }
+        catch (error) {
+            console.warn('[Datalyr] Failed to update SKAdNetwork postback conversion value:', error);
+            return false;
+        }
+    }
+    /**
+     * Check if SKAN 4.0 is available (iOS 16.1+)
+     */
+    static async isSKAN4Available() {
+        if (Platform.OS !== 'ios') {
+            return false;
+        }
+        if (this._isSKAN4Available !== null) {
+            return this._isSKAN4Available;
+        }
+        if (!(DatalyrSKAdNetwork === null || DatalyrSKAdNetwork === void 0 ? void 0 : DatalyrSKAdNetwork.isSKAN4Available)) {
+            return false;
+        }
+        try {
+            this._isSKAN4Available = await DatalyrSKAdNetwork.isSKAN4Available();
+            return this._isSKAN4Available;
+        }
+        catch (_a) {
+            return false;
+        }
+    }
     static isAvailable() {
         return Platform.OS === 'ios' && !!DatalyrSKAdNetwork;
     }
 }
+SKAdNetworkBridge._isSKAN4Available = null;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@datalyr/react-native",
-  "version": "1.2.1",
-  "description": "Datalyr SDK for React Native & Expo - Server-side attribution tracking with bundled Meta and TikTok SDKs",
+  "version": "1.3.0",
+  "description": "Datalyr SDK for React Native & Expo - Server-side attribution tracking with bundled Meta and TikTok SDKs for iOS and Android",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "scripts": {
@@ -15,6 +15,7 @@
     "lib/",
     "src/",
     "ios/",
+    "android/",
     "README.md",
     "CHANGELOG.md",
     "LICENSE",
@@ -38,11 +39,15 @@
     "tiktok-attribution",
     "google-attribution",
     "ios-attribution",
+    "android-attribution",
     "apple-search-ads",
+    "play-install-referrer",
+    "gclid",
     "conversion-tracking",
     "revenue-optimization",
     "deferred-deep-linking",
-    "fbclid"
+    "fbclid",
+    "ttclid"
   ],
   "author": "Datalyr",
   "license": "MIT",