@rejourneyco/react-native 1.0.0 → 1.0.2

package/src/sdk/autoTracking.ts

@@ -42,9 +42,7 @@ function getDimensions() {
   return getRN()?.Dimensions;
 }
 
-function getNativeModules() {
-  return getRN()?.NativeModules;
-}
+
 
 function getRejourneyNativeModule() {
   const RN = getRN();
@@ -57,7 +55,7 @@ function getRejourneyNativeModule() {
     try {
       nativeModule = TurboModuleRegistry.get('Rejourney');
     } catch {
-      // Ignore and fall back to NativeModules
+      // Ignore
     }
   }
 
@@ -68,8 +66,6 @@ function getRejourneyNativeModule() {
   return nativeModule;
 }
 
-// Type declarations for browser globals (only used in hybrid apps where DOM is available)
-// These don't exist in pure React Native but are needed for error tracking in hybrid scenarios
 type OnErrorEventHandler = ((
   event: Event | string,
   source?: string,
@@ -83,7 +79,6 @@ interface PromiseRejectionEvent {
   promise?: Promise<any>;
 }
 
-// Cast globalThis to work with both RN and hybrid scenarios
 const _globalThis = globalThis as typeof globalThis & {
   onerror?: OnErrorEventHandler;
   addEventListener?: (type: string, handler: (event: any) => void) => void;
@@ -94,10 +89,6 @@ const _globalThis = globalThis as typeof globalThis & {
   };
 };
 
-// =============================================================================
-// Types
-// =============================================================================
-
 export interface TapEvent {
   x: number;
   y: number;
@@ -106,93 +97,63 @@ export interface TapEvent {
 }
 
 export interface SessionMetrics {
-  // Core counts
   totalEvents: number;
   touchCount: number;
   scrollCount: number;
   gestureCount: number;
   inputCount: number;
   navigationCount: number;
-
-  // Issue tracking
   errorCount: number;
   rageTapCount: number;
-
-  // API metrics
   apiSuccessCount: number;
   apiErrorCount: number;
   apiTotalCount: number;
-
-  // Network timing (for avg calculation)
-  netTotalDurationMs: number;  // Sum of all API durations
-  netTotalBytes: number;       // Sum of all response bytes
-
-  // Screen tracking for funnels
+  netTotalDurationMs: number;
+  netTotalBytes: number;
   screensVisited: string[];
   uniqueScreensCount: number;
 
-  // Scores (0-100)
   interactionScore: number;
   explorationScore: number;
   uxScore: number;
 }
 
 export interface AutoTrackingConfig {
-  // Rage tap detection
-  rageTapThreshold?: number;    // Number of taps (default: 3)
-  rageTapTimeWindow?: number;   // Time window in ms (default: 500)
-  rageTapRadius?: number;       // Max radius in pixels (default: 50)
-
-  // Error tracking
-  trackJSErrors?: boolean;      // Track window errors (default: true)
-  trackPromiseRejections?: boolean; // Track unhandled rejections (default: true)
-  trackReactNativeErrors?: boolean; // Track RN ErrorUtils (default: true)
-
-  // Session settings
-  collectDeviceInfo?: boolean;  // Collect device info (default: true)
-  maxSessionDurationMs?: number; // Clamp to 1–10 minutes; default set from server/config
+  rageTapThreshold?: number;
+  rageTapTimeWindow?: number;
+  rageTapRadius?: number;
+  trackJSErrors?: boolean;
+  trackPromiseRejections?: boolean;
+  trackReactNativeErrors?: boolean;
+  collectDeviceInfo?: boolean;
+  maxSessionDurationMs?: number;
 }
 
-// =============================================================================
-// State
-// =============================================================================
-
 let isInitialized = false;
 let config: AutoTrackingConfig = {};
 
-// Rage tap tracking
 const recentTaps: TapEvent[] = [];
-let tapHead = 0; // Circular buffer head pointer
-let tapCount = 0; // Actual count of taps in buffer
+let tapHead = 0;
+let tapCount = 0;
 const MAX_RECENT_TAPS = 10;
 
-// Session metrics
 let metrics: SessionMetrics = createEmptyMetrics();
 let sessionStartTime: number = 0;
 let maxSessionDurationMs: number = 10 * 60 * 1000;
-
-// Screen tracking
 let currentScreen = '';
 let screensVisited: string[] = [];
 
-// Anonymous ID
 let anonymousId: string | null = null;
 let anonymousIdPromise: Promise<string> | null = null;
 
-// Callbacks
 let onRageTapDetected: ((count: number, x: number, y: number) => void) | null = null;
 let onErrorCaptured: ((error: ErrorEvent) => void) | null = null;
 let onScreenChange: ((screenName: string, previousScreen?: string) => void) | null = null;
 
-// Original error handlers (for restoration)
 let originalErrorHandler: ((error: Error, isFatal: boolean) => void) | undefined;
 let originalOnError: OnErrorEventHandler | null = null;
 let originalOnUnhandledRejection: ((event: PromiseRejectionEvent) => void) | null = null;
 
-// =============================================================================
-// Initialization
-// =============================================================================
-
 /**
  * Initialize auto tracking features
  * Called automatically by Rejourney.init() - no user action needed
@@ -219,7 +180,6 @@ export function initAutoTracking(
     ...trackingConfig,
   };
 
-  // Session timing
   sessionStartTime = Date.now();
   setMaxSessionDurationMinutes(
     trackingConfig.maxSessionDurationMs
@@ -227,21 +187,14 @@ export function initAutoTracking(
       : undefined
   );
 
-  // Set callbacks
   onRageTapDetected = callbacks.onRageTap || null;
   onErrorCaptured = callbacks.onError || null;
   onScreenChange = callbacks.onScreen || null;
-
-  // Initialize metrics
-  metrics = createEmptyMetrics();
-  sessionStartTime = Date.now();
-  anonymousId = generateAnonymousId();
-
-  // Setup error tracking
   setupErrorTracking();
-
-  // Setup React Navigation tracking (if available)
   setupNavigationTracking();
+  loadAnonymousId().then(id => {
+    anonymousId = id;
+  });
 
   isInitialized = true;
 }
@@ -252,10 +205,7 @@ export function initAutoTracking(
 export function cleanupAutoTracking(): void {
   if (!isInitialized) return;
 
-  // Restore original error handlers
   restoreErrorHandlers();
-
-  // Cleanup navigation tracking
   cleanupNavigationTracking();
 
   // Reset state
@@ -269,10 +219,6 @@ export function cleanupAutoTracking(): void {
   isInitialized = false;
 }
 
-// =============================================================================
-// Rage Tap Detection
-// =============================================================================
-
 /**
  * Track a tap event for rage tap detection
  * Called automatically from touch interceptor
@@ -282,18 +228,14 @@ export function trackTap(tap: TapEvent): void {
 
   const now = Date.now();
 
-  // Add to circular buffer (O(1) instead of shift() which is O(n))
   const insertIndex = (tapHead + tapCount) % MAX_RECENT_TAPS;
   if (tapCount < MAX_RECENT_TAPS) {
     recentTaps[insertIndex] = { ...tap, timestamp: now };
     tapCount++;
   } else {
-    // Buffer full, overwrite oldest
     recentTaps[tapHead] = { ...tap, timestamp: now };
     tapHead = (tapHead + 1) % MAX_RECENT_TAPS;
   }
-
-  // Evict old taps outside time window
   const windowStart = now - (config.rageTapTimeWindow || 500);
   while (tapCount > 0) {
     const oldestTap = recentTaps[tapHead];
@@ -305,10 +247,7 @@ export function trackTap(tap: TapEvent): void {
     }
   }
 
-  // Check for rage tap
   detectRageTap();
-
-  // Update metrics
   metrics.touchCount++;
   metrics.totalEvents++;
 }
@@ -321,14 +260,12 @@ function detectRageTap(): void {
   const radius = config.rageTapRadius || 50;
 
   if (tapCount < threshold) return;
-  // Check last N taps from circular buffer
   const tapsToCheck: TapEvent[] = [];
   for (let i = 0; i < threshold; i++) {
     const idx = (tapHead + tapCount - threshold + i) % MAX_RECENT_TAPS;
     tapsToCheck.push(recentTaps[idx]!);
   }
 
-  // Calculate center point
   let centerX = 0;
   let centerY = 0;
   for (const tap of tapsToCheck) {
@@ -338,7 +275,6 @@ function detectRageTap(): void {
   centerX /= tapsToCheck.length;
   centerY /= tapsToCheck.length;
 
-  // Check if all taps are within radius of center
   let allWithinRadius = true;
   for (const tap of tapsToCheck) {
     const dx = tap.x - centerX;
@@ -351,9 +287,7 @@ function detectRageTap(): void {
   }
 
   if (allWithinRadius) {
-    // Rage tap detected!
     metrics.rageTapCount++;
-    // Clear circular buffer to prevent duplicate detection
     tapHead = 0;
     tapCount = 0;
 
@@ -364,10 +298,6 @@ function detectRageTap(): void {
   }
 }
 
-// =============================================================================
-// State Change Notification
-// =============================================================================
-
 /**
  * Notify that a state change occurred (navigation, modal, etc.)
  * Kept for API compatibility
@@ -376,25 +306,18 @@ export function notifyStateChange(): void {
   // No-op - kept for backward compatibility
 }
 
-// =============================================================================
-// Error Tracking
-// =============================================================================
-
 /**
  * Setup automatic error tracking
  */
 function setupErrorTracking(): void {
-  // Track React Native errors
   if (config.trackReactNativeErrors !== false) {
     setupReactNativeErrorHandler();
   }
 
-  // Track JavaScript errors (only works in web/debug)
   if (config.trackJSErrors !== false && typeof _globalThis !== 'undefined') {
     setupJSErrorHandler();
   }
 
-  // Track unhandled promise rejections
   if (config.trackPromiseRejections !== false && typeof _globalThis !== 'undefined') {
     setupPromiseRejectionHandler();
   }
@@ -405,16 +328,12 @@ function setupErrorTracking(): void {
  */
 function setupReactNativeErrorHandler(): void {
   try {
-    // Access ErrorUtils from global scope
     const ErrorUtils = _globalThis.ErrorUtils;
     if (!ErrorUtils) return;
 
-    // Store original handler
     originalErrorHandler = ErrorUtils.getGlobalHandler();
 
-    // Set new handler
     ErrorUtils.setGlobalHandler((error: Error, isFatal: boolean) => {
-      // Track the error
       trackError({
         type: 'error',
         timestamp: Date.now(),
@@ -423,13 +342,12 @@ function setupReactNativeErrorHandler(): void {
         name: error.name || 'Error',
       });
 
-      // Call original handler
       if (originalErrorHandler) {
         originalErrorHandler(error, isFatal);
       }
     });
   } catch {
-    // ErrorUtils not available
+    // Ignore
   }
 }
 
@@ -438,8 +356,6 @@ function setupReactNativeErrorHandler(): void {
  */
 function setupJSErrorHandler(): void {
   if (typeof _globalThis.onerror !== 'undefined') {
-    // Note: In React Native, this typically doesn't fire
-    // But we set it up anyway for hybrid apps
     originalOnError = _globalThis.onerror;
 
     _globalThis.onerror = (
@@ -457,7 +373,6 @@ function setupJSErrorHandler(): void {
         name: error?.name || 'Error',
       });
 
-      // Call original handler
       if (originalOnError) {
         return originalOnError(message, source, lineno, colno, error);
       }
@@ -491,7 +406,6 @@ function setupPromiseRejectionHandler(): void {
  * Restore original error handlers
  */
 function restoreErrorHandlers(): void {
-  // Restore React Native handler
   if (originalErrorHandler) {
     try {
       const ErrorUtils = _globalThis.ErrorUtils;
@@ -504,13 +418,11 @@ function restoreErrorHandlers(): void {
     originalErrorHandler = undefined;
   }
 
-  // Restore global onerror
   if (originalOnError !== null) {
     _globalThis.onerror = originalOnError;
     originalOnError = null;
   }
 
-  // Remove promise rejection handler
   if (originalOnUnhandledRejection && typeof _globalThis.removeEventListener !== 'undefined') {
     _globalThis.removeEventListener!('unhandledrejection', originalOnUnhandledRejection);
     originalOnUnhandledRejection = null;
@@ -546,15 +458,10 @@ export function captureError(
   });
 }
 
-// =============================================================================
-// Screen/Funnel Tracking - Automatic Navigation Detection
-// =============================================================================
-
-// Navigation detection state
 let navigationPollingInterval: ReturnType<typeof setInterval> | null = null;
 let lastDetectedScreen = '';
 let navigationSetupDone = false;
-let navigationPollingErrors = 0; // Track consecutive errors
+let navigationPollingErrors = 0;
 const MAX_POLLING_ERRORS = 10; // Stop polling after 10 consecutive errors
 
 /**
@@ -578,7 +485,6 @@ export function trackNavigationState(state: any): void {
   try {
     const { normalizeScreenName } = require('./navigation');
 
-    // Find the active screen recursively
     const findActiveScreen = (navState: any): string | null => {
       if (!navState?.routes) return null;
       const index = navState.index ?? navState.routes.length - 1;
@@ -594,7 +500,7 @@ export function trackNavigationState(state: any): void {
       trackScreen(screenName);
     }
   } catch {
-    // Navigation tracking error
+    // Ignore
   }
 }
 
@@ -624,14 +530,11 @@ export function trackNavigationState(state: any): void {
  * ```
  */
 export function useNavigationTracking() {
-  // Use React's useRef and useCallback to create stable references
   const React = require('react');
   const { createNavigationContainerRef } = require('@react-navigation/native');
 
-  // Create a stable navigation ref
   const navigationRef = React.useRef(createNavigationContainerRef());
 
-  // Track initial screen when navigation is ready
   const onReady = React.useCallback(() => {
     try {
       const currentRoute = navigationRef.current?.getCurrentRoute?.();
@@ -644,11 +547,10 @@ export function useNavigationTracking() {
         }
       }
     } catch {
-      // Navigation not ready yet
+      // Ignore
     }
   }, []);
 
-  // Return props to spread on NavigationContainer
   return {
     ref: navigationRef.current,
     onReady,
@@ -674,22 +576,21 @@ function setupNavigationTracking(): void {
   // We retry a few times with increasing delays
   let attempts = 0;
   const maxAttempts = 5;
-  
+
   const trySetup = () => {
     attempts++;
     if (__DEV__) {
       logger.debug('Navigation setup attempt', attempts, 'of', maxAttempts);
     }
-    
+
     const success = trySetupExpoRouter();
-    
+
     if (success) {
       if (__DEV__) {
         logger.debug('Expo Router setup: SUCCESS on attempt', attempts);
       }
     } else if (attempts < maxAttempts) {
-      // Retry with exponential backoff
-      const delay = 200 * attempts; // 200, 400, 600, 800ms
+      const delay = 200 * attempts;
       if (__DEV__) {
         logger.debug('Expo Router not ready, retrying in', delay, 'ms');
       }
@@ -702,7 +603,6 @@ function setupNavigationTracking(): void {
     }
   };
 
-  // Start first attempt after 200ms
   setTimeout(trySetup, 200);
 }
 
@@ -729,13 +629,10 @@ function trySetupExpoRouter(): boolean {
 
     const { normalizeScreenName, getScreenNameFromPath } = require('./navigation');
 
-    // Poll for route changes (expo-router doesn't expose a listener API outside hooks)
     navigationPollingInterval = setInterval(() => {
       try {
         let state = null;
         let stateSource = '';
-
-        // Method 1: Public accessors on router object
         if (typeof router.getState === 'function') {
           state = router.getState();
           stateSource = 'router.getState()';
@@ -744,33 +641,28 @@ function trySetupExpoRouter(): boolean {
           stateSource = 'router.rootState';
         }
 
-        // Method 2: Internal store access (works for both v3 and v6+)
         if (!state) {
           try {
             const storeModule = require('expo-router/build/global-state/router-store');
             if (storeModule?.store) {
-              // v6+: store.state or store.navigationRef
               state = storeModule.store.state;
               if (state) stateSource = 'store.state';
 
-              // v6+: Try navigationRef if state is undefined
               if (!state && storeModule.store.navigationRef?.current) {
                 state = storeModule.store.navigationRef.current.getRootState?.();
                 if (state) stateSource = 'navigationRef.getRootState()';
               }
 
-              // v3: store.rootState or store.initialState
               if (!state) {
                 state = storeModule.store.rootState || storeModule.store.initialState;
                 if (state) stateSource = 'store.rootState/initialState';
               }
             }
           } catch {
-            // Store not available
+            // Ignore
           }
         }
 
-        // Method 3: Try accessing via a different export path for v6
         if (!state) {
           try {
             const imperative = require('expo-router/build/imperative-api');
@@ -779,12 +671,12 @@ function trySetupExpoRouter(): boolean {
               if (state) stateSource = 'imperative-api';
             }
           } catch {
-            // Imperative API not available
+            // Ignore
           }
         }
 
         if (state) {
-          // Reset error count on success
+          navigationPollingErrors = 0;
           navigationPollingErrors = 0;
           const screenName = extractScreenNameFromRouterState(state, getScreenNameFromPath, normalizeScreenName);
           if (screenName && screenName !== lastDetectedScreen) {
@@ -795,21 +687,15 @@ function trySetupExpoRouter(): boolean {
             trackScreen(screenName);
           }
         } else {
-          // Track consecutive failures to get state
           navigationPollingErrors++;
           if (__DEV__ && navigationPollingErrors === 1) {
             logger.debug('Expo Router: Could not get navigation state');
           }
           if (navigationPollingErrors >= MAX_POLLING_ERRORS) {
-            // Stop polling after too many errors to save CPU
-            if (__DEV__) {
-              logger.debug('Expo Router: Stopped polling after', MAX_POLLING_ERRORS, 'errors');
-            }
             cleanupNavigationTracking();
           }
         }
       } catch (e) {
-        // Error - track and potentially stop
         navigationPollingErrors++;
         if (__DEV__ && navigationPollingErrors === 1) {
           logger.debug('Expo Router polling error:', e);
@@ -818,14 +704,13 @@ function trySetupExpoRouter(): boolean {
           cleanupNavigationTracking();
         }
       }
-    }, 500); // 500ms polling (reduced from 300ms for lower CPU usage)
+    }, 500);
 
     return true;
   } catch (e) {
     if (__DEV__) {
       logger.debug('Expo Router not available:', e);
     }
-    // expo-router not installed
     return false;
   }
 }
@@ -847,10 +732,8 @@ function extractScreenNameFromRouterState(
   const route = state.routes[state.index ?? state.routes.length - 1];
   if (!route) return null;
 
-  // Add current route name to accumulated segments
   const newSegments = [...accumulatedSegments, route.name];
 
-  // If this route has nested state, recurse deeper
   if (route.state) {
     return extractScreenNameFromRouterState(
       route.state,
@@ -860,13 +743,9 @@ function extractScreenNameFromRouterState(
     );
   }
 
-  // We've reached the deepest level - build the screen name
-  // Filter out group markers like (tabs), (main), (auth)
   const cleanSegments = newSegments.filter(s => !s.startsWith('(') && !s.endsWith(')'));
 
-  // If after filtering we have no segments, use the last meaningful name
   if (cleanSegments.length === 0) {
-    // Find the last non-group segment
     for (let i = newSegments.length - 1; i >= 0; i--) {
       const seg = newSegments[i];
       if (seg && !seg.startsWith('(') && !seg.endsWith(')')) {
@@ -907,14 +786,10 @@ export function trackScreen(screenName: string): void {
 
   const previousScreen = currentScreen;
   currentScreen = screenName;
-  // Add to screens visited (only track for unique set, avoid large array copies)
   screensVisited.push(screenName);
 
-  // Update unique screens count
   const uniqueScreens = new Set(screensVisited);
   metrics.uniqueScreensCount = uniqueScreens.size;
-
-  // Update navigation count
   metrics.navigationCount++;
   metrics.totalEvents++;
 
@@ -922,13 +797,10 @@ export function trackScreen(screenName: string): void {
     logger.debug('trackScreen:', screenName, '(total screens:', metrics.uniqueScreensCount, ')');
   }
 
-  // Notify callback
   if (onScreenChange) {
     onScreenChange(screenName, previousScreen);
   }
 
-  // IMPORTANT: Also notify native module to send to backend
-  // This is the key fix - without this, screens don't get recorded!
   try {
     const RejourneyNative = getRejourneyNativeModule();
     if (RejourneyNative?.screenChanged) {
@@ -950,10 +822,6 @@ export function trackScreen(screenName: string): void {
   }
 }
 
-// =============================================================================
-// API Metrics Tracking
-// =============================================================================
-
 /**
  * Track an API request with timing data
  */
@@ -967,7 +835,6 @@ export function trackAPIRequest(
 
   metrics.apiTotalCount++;
 
-  // Accumulate timing and size for avg calculation
   if (durationMs > 0) {
     metrics.netTotalDurationMs += durationMs;
   }
@@ -979,16 +846,10 @@ export function trackAPIRequest(
     metrics.apiSuccessCount++;
   } else {
     metrics.apiErrorCount++;
-
-    // API errors also count toward error count for UX score
     metrics.errorCount++;
   }
 }
 
-// =============================================================================
-// Session Metrics
-// =============================================================================
-
 /**
  * Create empty metrics object
  */
@@ -1046,19 +907,15 @@ export function trackInput(): void {
  * Get current session metrics
  */
 export function getSessionMetrics(): SessionMetrics & { netAvgDurationMs: number } {
-  // Calculate scores before returning
   calculateScores();
 
-  // Compute average API response time
   const netAvgDurationMs = metrics.apiTotalCount > 0
     ? Math.round(metrics.netTotalDurationMs / metrics.apiTotalCount)
     : 0;
 
-  // Lazily populate screensVisited only when metrics are retrieved
-  // This avoids expensive array copies on every screen change
   return {
     ...metrics,
-    screensVisited: [...screensVisited], // Only copy here when needed
+    screensVisited: [...screensVisited],
     netAvgDurationMs,
   };
 }
@@ -1067,38 +924,26 @@ export function getSessionMetrics(): SessionMetrics & { netAvgDurationMs: number
  * Calculate session scores
  */
 function calculateScores(): void {
-  // Interaction Score (0-100)
-  // Based on total interactions normalized to a baseline
   const totalInteractions =
     metrics.touchCount +
     metrics.scrollCount +
     metrics.gestureCount +
     metrics.inputCount;
 
-  // Assume 50 interactions is "average" for a session
   const avgInteractions = 50;
   metrics.interactionScore = Math.min(100, Math.round((totalInteractions / avgInteractions) * 100));
 
-  // Exploration Score (0-100)
-  // Based on unique screens visited
-  // Assume 5 screens is "average" exploration
   const avgScreens = 5;
   metrics.explorationScore = Math.min(100, Math.round((metrics.uniqueScreensCount / avgScreens) * 100));
 
-  // UX Score (0-100)
-  // Starts at 100, deducts for issues
   let uxScore = 100;
 
-  // Deduct for errors
-  uxScore -= Math.min(30, metrics.errorCount * 15); // Max 30 point deduction
+  uxScore -= Math.min(30, metrics.errorCount * 15);
 
-  // Deduct for rage taps
-  uxScore -= Math.min(24, metrics.rageTapCount * 8); // Max 24 point deduction
+  uxScore -= Math.min(24, metrics.rageTapCount * 8);
 
-  // Deduct for API errors
-  uxScore -= Math.min(20, metrics.apiErrorCount * 10); // Max 20 point deduction
+  uxScore -= Math.min(20, metrics.apiErrorCount * 10);
 
-  // Bonus for completing funnel (if screens > 3)
   if (metrics.uniqueScreensCount >= 3) {
     uxScore += 5;
   }
@@ -1118,44 +963,33 @@ export function resetMetrics(): void {
   sessionStartTime = Date.now();
 }
 
-// =============================================================================
-// Session duration helpers
-// =============================================================================
-
-/** Clamp and set max session duration in minutes (1–10). Defaults to 10. */
 export function setMaxSessionDurationMinutes(minutes?: number): void {
   const clampedMinutes = Math.min(10, Math.max(1, minutes ?? 10));
   maxSessionDurationMs = clampedMinutes * 60 * 1000;
 }
-
-/** Returns true if the current session exceeded the configured max duration. */
 export function hasExceededMaxSessionDuration(): boolean {
   if (!sessionStartTime) return false;
   return Date.now() - sessionStartTime >= maxSessionDurationMs;
 }
 
-/** Returns remaining milliseconds until the session should stop. */
 export function getRemainingSessionDurationMs(): number {
   if (!sessionStartTime) return maxSessionDurationMs;
   const remaining = maxSessionDurationMs - (Date.now() - sessionStartTime);
   return Math.max(0, remaining);
 }
 
-// =============================================================================
-// Device Info Collection
-// =============================================================================
-
 /**
  * Collect device information
  */
-export function collectDeviceInfo(): DeviceInfo {
+/**
+ * Collect device information
+ */
+export async function collectDeviceInfo(): Promise<DeviceInfo> {
   const Dimensions = getDimensions();
   const Platform = getPlatform();
-  const NativeModules = getNativeModules();
-  
-  // Default values if react-native isn't available
+
   let width = 0, height = 0, scale = 1;
-  
+
   if (Dimensions) {
     const windowDims = Dimensions.get('window');
     const screenDims = Dimensions.get('screen');
@@ -1164,105 +998,46 @@ export function collectDeviceInfo(): DeviceInfo {
     scale = screenDims?.scale || 1;
   }
 
-  // Get device model - this varies by platform
-  let model = 'Unknown';
-  let manufacturer: string | undefined;
-  let osVersion = 'Unknown';
-  let appVersion: string | undefined;
-  let appId: string | undefined;
+  // Basic JS-side info
   let locale: string | undefined;
   let timezone: string | undefined;
 
   try {
-    // Try to get from react-native-device-info if available
-    // This is optional - falls back to basic info if not installed
-    const DeviceInfo = require('react-native-device-info');
-    model = DeviceInfo.getModel?.() || model;
-    manufacturer = DeviceInfo.getBrand?.() || undefined;
-    osVersion = DeviceInfo.getSystemVersion?.() || osVersion;
-    appVersion = DeviceInfo.getVersion?.() || undefined;
-    appId = DeviceInfo.getBundleId?.() || undefined;
-    locale = DeviceInfo.getDeviceLocale?.() || undefined;
-    timezone = DeviceInfo.getTimezone?.() || undefined;
+    timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    locale = Intl.DateTimeFormat().resolvedOptions().locale;
   } catch {
-    // react-native-device-info not installed, try Expo packages
-    try {
-      // Try expo-application for app version/id
-      const Application = require('expo-application');
-      appVersion = Application.nativeApplicationVersion || Application.applicationVersion || undefined;
-      appId = Application.applicationId || undefined;
-    } catch {
-      // expo-application not available
-    }
-
-    try {
-      // Try expo-constants for additional info
-      const Constants = require('expo-constants');
-      const expoConfig = Constants.expoConfig || Constants.manifest2?.extra?.expoClient || Constants.manifest;
-      if (!appVersion && expoConfig?.version) {
-        appVersion = expoConfig.version;
-      }
-      if (!appId && (expoConfig?.ios?.bundleIdentifier || expoConfig?.android?.package)) {
-        appId = Platform?.OS === 'ios'
-          ? expoConfig?.ios?.bundleIdentifier
-          : expoConfig?.android?.package;
-      }
-    } catch {
-      // expo-constants not available
-    }
-
-    // Fall back to basic platform info
-    if (Platform?.OS === 'ios') {
-      // Get basic info from constants
-      const PlatformConstants = NativeModules?.PlatformConstants;
-      osVersion = Platform.Version?.toString() || osVersion;
-      model = PlatformConstants?.interfaceIdiom === 'pad' ? 'iPad' : 'iPhone';
-    } else if (Platform?.OS === 'android') {
-      osVersion = Platform.Version?.toString() || osVersion;
-      model = 'Android Device';
-    }
+    // Ignore
   }
 
-  // Get timezone
-  if (!timezone) {
-    try {
-      timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
-    } catch {
-      timezone = undefined;
-    }
-  }
+  // Get native info
+  const nativeModule = getRejourneyNativeModule();
+  let nativeInfo: any = {};
 
-  // Get locale
-  if (!locale) {
+  if (nativeModule && nativeModule.getDeviceInfo) {
     try {
-      locale = Intl.DateTimeFormat().resolvedOptions().locale;
-    } catch {
-      locale = undefined;
+      nativeInfo = await nativeModule.getDeviceInfo();
+    } catch (e) {
+      if (__DEV__) {
+        console.warn('[Rejourney] Failed to get native device info:', e);
+      }
     }
   }
 
   return {
-    model,
-    manufacturer,
+    model: nativeInfo.model || 'Unknown',
+    manufacturer: nativeInfo.brand,
     os: (Platform?.OS || 'ios') as 'ios' | 'android',
-    osVersion,
+    osVersion: nativeInfo.systemVersion || Platform?.Version?.toString() || 'Unknown',
     screenWidth: Math.round(width),
     screenHeight: Math.round(height),
     pixelRatio: scale,
-    appVersion,
-    appId,
-    locale,
-    timezone,
+    appVersion: nativeInfo.appVersion,
+    appId: nativeInfo.bundleId,
+    locale: locale,
+    timezone: timezone,
   };
 }
 
-// =============================================================================
-// Anonymous ID Generation
-// =============================================================================
-
-// Storage key for anonymous ID
-const ANONYMOUS_ID_KEY = '@rejourney_anonymous_id';
-
 /**
  * Generate a persistent anonymous ID
  */
@@ -1272,40 +1047,12 @@ function generateAnonymousId(): string {
   return `anon_${timestamp}_${random}`;
 }
 
-/**
- * Initialize anonymous ID - tries to load from storage, generates new if not found
- * This is called internally and runs asynchronously
- */
-async function initAnonymousId(): Promise<void> {
-  try {
-    // Try to load from AsyncStorage
-    const AsyncStorage = require('@react-native-async-storage/async-storage').default;
-    const storedId = await AsyncStorage.getItem(ANONYMOUS_ID_KEY);
-
-    if (storedId) {
-      anonymousId = storedId;
-    } else {
-      // Generate new ID and persist
-      anonymousId = generateAnonymousId();
-      await AsyncStorage.setItem(ANONYMOUS_ID_KEY, anonymousId);
-    }
-  } catch {
-    // AsyncStorage not available or error - just generate without persistence
-    if (!anonymousId) {
-      anonymousId = generateAnonymousId();
-    }
-  }
-}
-
 /**
  * Get the anonymous ID (synchronous - returns generated ID immediately)
- * For persistent ID, call initAnonymousId() first
  */
 export function getAnonymousId(): string {
   if (!anonymousId) {
     anonymousId = generateAnonymousId();
-    // Try to persist asynchronously (fire and forget)
-    initAnonymousId().catch(() => { });
   }
   return anonymousId;
 }
@@ -1318,11 +1065,9 @@ export async function ensurePersistentAnonymousId(): Promise<string> {
   if (anonymousId) return anonymousId;
   if (!anonymousIdPromise) {
     anonymousIdPromise = (async () => {
-      await initAnonymousId();
-      if (!anonymousId) {
-        anonymousId = generateAnonymousId();
-      }
-      return anonymousId;
+      const id = await loadAnonymousId();
+      anonymousId = id;
+      return id;
     })();
   }
   return anonymousIdPromise;
@@ -1333,28 +1078,24 @@ export async function ensurePersistentAnonymousId(): Promise<string> {
  * Call this at app startup for best results
  */
 export async function loadAnonymousId(): Promise<string> {
-  await initAnonymousId();
-  return anonymousId || generateAnonymousId();
+  const nativeModule = getRejourneyNativeModule();
+  if (nativeModule && nativeModule.getUserIdentity) {
+    try {
+      return await nativeModule.getUserIdentity() || generateAnonymousId();
+    } catch {
+      return generateAnonymousId();
+    }
+  }
+  return generateAnonymousId();
 }
 
 /**
- * Set a custom anonymous ID (e.g., from persistent storage)
+ * Set a custom anonymous ID
  */
 export function setAnonymousId(id: string): void {
   anonymousId = id;
-  // Try to persist asynchronously
-  try {
-    const AsyncStorage = require('@react-native-async-storage/async-storage').default;
-    AsyncStorage.setItem(ANONYMOUS_ID_KEY, id).catch(() => { });
-  } catch {
-    // Ignore if AsyncStorage not available
-  }
 }
 
-// =============================================================================
-// Exports
-// =============================================================================
-
 export default {
   init: initAutoTracking,
   cleanup: cleanupAutoTracking,