@loyalytics/swan-react-native-sdk 2.3.0 → 2.3.1-beta.1

package/lib/module/index.js

@@ -14,7 +14,7 @@
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import Base64 from 'react-native-base64';
 import uuid from 'react-native-uuid';
-import { StyleSheet, View, Modal, PermissionsAndroid, Platform, AppState, Linking } from 'react-native';
+import { StyleSheet, View, Modal, NativeModules, DeviceEventEmitter, PermissionsAndroid, Platform, AppState, Linking } from 'react-native';
 import { SDK_VERSION as PACKAGE_VERSION } from "./version.js";
 import PopUpView from "./components/PopUpView.js";
 import HeaderView from "./components/HeaderView.js";
@@ -23,7 +23,6 @@ import FullScreenView from "./components/FullScreenView.js";
 import { useState } from 'react';
 import SQLite from 'react-native-sqlite-2';
 import DeviceInfo from 'react-native-device-info';
-import Geolocation from '@react-native-community/geolocation';
 import Logger from "./utils/Logger.js";
 import { EventQueueManager } from "./core/EventQueueManager.js";
 import { FlushManager } from "./core/FlushManager.js";
@@ -39,6 +38,7 @@ import { DeviceRegistrationService } from "./services/DeviceRegistrationService.
 import { PushTokenService } from "./services/PushTokenService.js";
 import { NullPushProvider } from "./providers/NullPushProvider.js";
 import { SharedCredentialsManager } from "./utils/SharedCredentialsManager.js";
+import { resolveSoundFromPayload, buildIosSound, buildAndroidSound } from "./utils/NotificationSoundHelper.js";
 import URLS from "./constants/ApiUrls.js";
 
 // Predefined Notification Channels
@@ -110,6 +110,28 @@ function parseKeyValuePairs(data) {
   }
 }
 
+/**
+ * Click deduplication guard.
+ * Prevents double click handling if both Firebase (onNotificationOpenedApp) and
+ * Notifee handlers fire for the same notification.
+ */
+const processedClickIds = new Set();
+const CLICK_ID_TTL_MS = 10_000; // Clear after 10 seconds
+
+function markClickProcessed(id) {
+  if (processedClickIds.has(id)) {
+    return false; // Already processed
+  }
+  processedClickIds.add(id);
+  setTimeout(() => processedClickIds.delete(id), CLICK_ID_TTL_MS);
+  return true; // First time processing
+}
+
+/** @internal Test-only: reset click deduplication state */
+export function _resetClickDedup() {
+  processedClickIds.clear();
+}
+
 /**
  * Notification deep link payload
  * Emitted when user clicks on a push notification
@@ -151,6 +173,7 @@ export default class SwanSDK {
   pendingPushEventListeners = [];
   appStateSubscription = null;
   linkingSubscription = null;
+  carouselClickSubscription = null;
 
   // Track if initial notification was already handled to prevent duplicate ACKs
   initialNotificationHandled = false;
@@ -728,6 +751,29 @@ export default class SwanSDK {
         return;
       }
 
+      // Detect iOS carousel click via URL (Content Extension openURL pattern)
+      // URL format: scheme://route?existing=params&swan_carousel=1&swan_comm_id=messageId&swan_item_index=0
+      if (parsed.params.swan_carousel === '1') {
+        const messageId = parsed.params.swan_comm_id;
+        Logger.log('[SwanSDK] Carousel click via URL, route:', parsed.path, 'messageId:', messageId);
+        if (messageId) {
+          this.sendNotificationAck(messageId, 'clicked');
+          // Mark as processed so checkPendingCarouselClick() (App Group path)
+          // doesn't emit a duplicate NOTIFICATION_OPENED event
+          markClickProcessed(messageId);
+        }
+
+        // Reconstruct route with original query params (exclude swan_ tracking params)
+        const originalParams = Object.entries(parsed.params).filter(([key]) => !key.startsWith('swan_')).map(([key, value]) => `${key}=${encodeURIComponent(value)}`).join('&');
+        const route = originalParams ? `${parsed.path}?${originalParams}` : parsed.path;
+        const payload = {
+          route: route || undefined,
+          keyValuePairs: {}
+        };
+        this.emitNotificationOpened(payload);
+        return; // Handled — don't process as regular deep link
+      }
+
       // Extract swan_ prefixed parameters
       const swanParams = {};
       for (const [key, value] of Object.entries(parsed.params)) {
@@ -897,9 +943,16 @@ export default class SwanSDK {
       Logger.log('[SwanSDK] Tracking initial app launch event...');
       this.appLaunched();
 
+      // Check for pending carousel click (covers killed/quit → fresh launch)
+      this.checkPendingCarouselClick();
+
       // AppState listener setup (always runs)
       Logger.log('[SwanSDK] Setting up AppState listener...');
       this.setupAppStateListener();
+
+      // Listen for native carousel click events (covers foreground click case
+      // where AppState stays 'active' and polling never triggers)
+      this.setupCarouselClickListener();
       Logger.log('Event queue system initialized successfully');
     } catch (error) {
       Logger.error('Failed to initialize event queue:', error);
@@ -921,10 +974,47 @@ export default class SwanSDK {
       if (nextAppState === 'active') {
         Logger.log('[SwanSDK] App came to foreground, tracking appLaunched event');
         this.appLaunched();
+        this.checkPendingCarouselClick();
       }
     });
     Logger.log('[SwanSDK] AppState listener set up successfully');
   }
+
+  /**
+   * Listen for native carousel click events emitted via DeviceEventEmitter.
+   * Covers the foreground-click case where AppState stays 'active'.
+   */
+  setupCarouselClickListener() {
+    if (Platform.OS !== 'android') return;
+    if (this.carouselClickSubscription) {
+      this.carouselClickSubscription.remove();
+    }
+    this.carouselClickSubscription = DeviceEventEmitter.addListener('swanCarouselClick', clickData => {
+      Logger.log('[SwanSDK] Carousel click event from native:', JSON.stringify(clickData));
+
+      // Consume the pending click so polling doesn't fire again
+      const {
+        SwanNotificationModule
+      } = NativeModules;
+      SwanNotificationModule?.getPendingCarouselClick?.();
+      const {
+        messageId,
+        route,
+        title,
+        body
+      } = clickData;
+      if (messageId) {
+        this.sendNotificationAck(messageId, 'clicked');
+      }
+      const deepLinkPayload = {
+        route: route || undefined,
+        title: title || undefined,
+        body: body || undefined,
+        keyValuePairs: {}
+      };
+      this.emitNotificationOpened(deepLinkPayload);
+    });
+  }
   createTable(tableName) {
     return new Promise((resolve, reject) => {
       if (!this.db) {
@@ -1408,6 +1498,7 @@ export default class SwanSDK {
       // This will trigger the Info.plist strings we discussed
       // It handles the 'Not Determined' -> 'Requested' flow automatically
       try {
+        const Geolocation = require('@react-native-community/geolocation').default;
         Geolocation.requestAuthorization();
         return true; // iOS handles the dialog; if denied, getCurrentPosition will trigger the error callback
       } catch (e) {
@@ -1425,6 +1516,13 @@ export default class SwanSDK {
    * @param checkOnly - If true, only checks for existing permission without requesting (non-blocking)
    */
   async getDeviceLocation(checkOnly = false) {
+    let Geolocation;
+    try {
+      Geolocation = require('@react-native-community/geolocation').default;
+    } catch (e) {
+      Logger.warn('[SwanSDK] @react-native-community/geolocation is not installed, skipping location');
+      return null;
+    }
     const hasPermission = await this.hasLocationPermission(checkOnly);
     if (!hasPermission) {
       Logger.log('[SwanSDK] Location permission not granted (checkOnly mode), skipping location');
@@ -1690,6 +1788,72 @@ export default class SwanSDK {
     this.trackEvent(ECOM_EVENTS.APP_LAUNCHED, data || {});
   }
 
+  /**
+   * Check for a pending carousel click and emit NOTIFICATION_OPENED.
+   * Native carousel clicks bypass Notifee, so the JS event system never fires.
+   *
+   * Android: reads from SwanNotificationModule.getPendingCarouselClick()
+   * iOS: reads from App Group via SharedCredentialsManager.readTemplateClickData()
+   *   (Content Extension writes click data to App Group UserDefaults)
+   *
+   * @internal
+   */
+  async checkPendingCarouselClick() {
+    try {
+      let clickData = null;
+      if (Platform.OS === 'android') {
+        const {
+          SwanNotificationModule
+        } = NativeModules;
+        if (!SwanNotificationModule?.getPendingCarouselClick) return;
+        clickData = await SwanNotificationModule.getPendingCarouselClick();
+      } else if (Platform.OS === 'ios') {
+        // Read click data from App Group (written by Content Extension)
+        clickData = await SharedCredentialsManager.readTemplateClickData();
+
+        // If no data yet, retry after a short delay.
+        // The Content Extension may still be writing when the app foregrounds.
+        if (!clickData) {
+          await new Promise(r => setTimeout(r, 500));
+          clickData = await SharedCredentialsManager.readTemplateClickData();
+        }
+      }
+      if (!clickData) return;
+      Logger.log('[SwanSDK] Pending carousel click found:', JSON.stringify(clickData));
+      const {
+        messageId,
+        route,
+        title,
+        body
+      } = clickData;
+
+      // Deduplication: prevent double click handling.
+      // On iOS, multiple handlers can fire for the same carousel tap
+      // (Notifee foreground, Firebase onNotificationOpenedApp, AppState change).
+      // Use the same markClickProcessed() as other handlers to prevent duplicates.
+      if (messageId && !markClickProcessed(messageId)) {
+        Logger.log('[SwanSDK] Carousel click already processed for messageId:', messageId);
+        return;
+      }
+
+      // Send click ACK
+      if (messageId) {
+        this.sendNotificationAck(messageId, 'clicked');
+      }
+
+      // Emit NOTIFICATION_OPENED event (same as Notifee click handler)
+      const deepLinkPayload = {
+        route: route || undefined,
+        title: title || undefined,
+        body: body || undefined,
+        keyValuePairs: {}
+      };
+      this.emitNotificationOpened(deepLinkPayload);
+    } catch (error) {
+      Logger.error('[SwanSDK] Error checking pending carousel click:', error);
+    }
+  }
+
   /**
    * @param { { success: boolean } } data
    */
@@ -2113,6 +2277,11 @@ export default class SwanSDK {
       // Get priority from payload (for Android 7.1 and below)
       const priority = this.getPriorityFromPayload(remoteMessage);
 
+      // Resolve sound from data.sound payload field
+      const soundConfig = resolveSoundFromPayload(remoteMessage?.data?.sound);
+      const androidSound = buildAndroidSound(soundConfig);
+      const iosSound = buildIosSound(soundConfig);
+
       // Build notification config
       const notificationConfig = {
         id: remoteMessage?.messageId || String(Date.now()),
@@ -2143,7 +2312,7 @@ export default class SwanSDK {
           foregroundPresentationOptions: {
             alert: true,
             badge: true,
-            sound: true
+            sound: soundConfig.enabled
           },
           // Pass through category for Content Extension (e.g., carousel)
           ...(remoteMessage?.category && {
@@ -2152,6 +2321,14 @@ export default class SwanSDK {
         }
       };
 
+      // Add sound if resolved
+      if (androidSound !== undefined) {
+        notificationConfig.android.sound = androidSound;
+      }
+      if (iosSound !== undefined) {
+        notificationConfig.ios.sound = iosSound;
+      }
+
       // Add image if present
       if (imageUrl) {
         // Dynamically import AndroidStyle to avoid import errors
@@ -2170,8 +2347,7 @@ export default class SwanSDK {
       // Display notification
       Logger.log('[SwanSDK] Displaying notification on channel:', channelId, priority !== undefined ? `with priority: ${priority}` : '(using channel importance)');
       Logger.log('[SwanSDK] Notification config:', JSON.stringify(notificationConfig));
-      const notificationId = await notifee.displayNotification(notificationConfig);
-      Logger.log('[SwanSDK] Notification displayed successfully with ID:', notificationId);
+      await routeNotificationForDisplay(remoteMessage, notificationConfig, notifee);
     } catch (error) {
       Logger.error('[SwanSDK] Error displaying foreground notification:', error);
       // Emit event so app can handle display on error
@@ -2682,7 +2858,7 @@ export default class SwanSDK {
       if (initialNotification && !this.initialNotificationHandled) {
         const messageId = initialNotification?.notification?.id;
         const notificationData = initialNotification.data || {};
-        if (messageId) {
+        if (messageId && markClickProcessed(messageId)) {
           Logger.log('[SwanSDK] App opened from Notifee notification tap:', messageId);
           this.initialNotificationHandled = true;
           await this.sendNotificationAck(messageId, 'clicked');
@@ -2723,13 +2899,17 @@ export default class SwanSDK {
       const messaging = require('@react-native-firebase/messaging').default;
       const initialNotification = await messaging().getInitialNotification();
       if (initialNotification && !this.initialNotificationHandled) {
-        Logger.log('[SwanSDK] App opened from Firebase notification (killed state):', initialNotification.messageId);
+        const messageId = initialNotification.messageId;
+
+        // Deduplication: prevent double click handling
+        if (messageId && !markClickProcessed(messageId)) {
+          Logger.log('[SwanSDK] Firebase initial notification click already processed:', messageId);
+          return;
+        }
+        Logger.log('[SwanSDK] App opened from Firebase notification (killed state):', messageId);
 
         // Mark as handled to prevent duplicate ACKs
         this.initialNotificationHandled = true;
-
-        // Get messageId and notification data
-        const messageId = initialNotification.messageId;
         const notificationData = initialNotification.data || {};
 
         // Extract deep link information
@@ -2925,18 +3105,18 @@ export default class SwanSDK {
    * @param description - User visible description
    * @param channelId - Custom Channel ID (defaults to App ID)
    */
-  async createNotificationChannel(channelName = 'General Notifications', importance = 4, description, channelId) {
+  async createNotificationChannel(channelName = 'General Notifications', importance = 4, description, channelId, sound) {
     // Use provided channelId or fallback to appId
     const id = channelId || this.appId;
 
     // Use new PushTokenService if available
     if (this.pushService) {
-      return await this.pushService.createNotificationChannel(id, channelName, importance, description);
+      return await this.pushService.createNotificationChannel(id, channelName, importance, description, sound);
     }
 
     // Fallback to firebaseManager for backward compatibility
     if (this.firebaseManager) {
-      return await this.firebaseManager.createNotificationChannel(id, channelName, importance, description);
+      return await this.firebaseManager.createNotificationChannel(id, channelName, importance, description, sound);
     }
     Logger.warn('[SwanSDK] Push notifications not initialized');
     return null;
@@ -3257,6 +3437,43 @@ export default class SwanSDK {
   }
 }
 
+/**
+ * Routes notification display to either the native carousel module (Android)
+ * or Notifee's standard display. Shared between foreground and background handlers.
+ */
+async function routeNotificationForDisplay(remoteMessage, notificationConfig, notifee) {
+  const isAndroidCarousel = Platform.OS === 'android' && remoteMessage?.data?.notificationType === 'carousel';
+  if (isAndroidCarousel) {
+    Logger.log('[SwanSDK] Routing to native carousel template');
+    const {
+      SwanNotificationModule
+    } = NativeModules;
+    if (SwanNotificationModule) {
+      await SwanNotificationModule.displayTemplateNotification({
+        notificationType: remoteMessage.data.notificationType,
+        messageId: notificationConfig.id,
+        title: notificationConfig.title,
+        body: notificationConfig.body,
+        channelId: notificationConfig.android.channelId,
+        carouselMode: remoteMessage.data.carouselMode || 'manual',
+        carouselVariant: remoteMessage.data.carouselVariant || 'standard',
+        carouselItems: remoteMessage.data.carouselItems || '[]',
+        defaultRoute: remoteMessage.data.defaultRoute || '',
+        ...(remoteMessage.data.carouselInterval && {
+          carouselInterval: parseInt(remoteMessage.data.carouselInterval, 10)
+        })
+      });
+      Logger.log('[SwanSDK] Native carousel displayed successfully');
+    } else {
+      Logger.warn('[SwanSDK] SwanNotificationModule not available, falling back to Notifee');
+      await notifee.displayNotification(notificationConfig);
+    }
+  } else {
+    const notificationId = await notifee.displayNotification(notificationConfig);
+    Logger.log('[SwanSDK] Notification displayed successfully with ID:', notificationId);
+  }
+}
+
 /**
  * Foreground Message Handler for index.js
  *
@@ -3333,15 +3550,27 @@ export function createBackgroundMessageHandler() {
       return;
     }
 
+    // If iOS displayed the notification natively (aps.alert present),
+    // skip Notifee display to avoid duplicates. Just send delivery ACK.
+    if (Platform.OS === 'ios' && remoteMessage?.notification) {
+      Logger.log('[SwanSDK] iOS native notification (aps.alert), skipping Notifee display');
+      const sdkReady = sdkInstance && sdkInstance.isReady();
+      if (sdkReady) {
+        await sdkInstance.sendNotificationAck(messageId, 'delivered');
+      } else if (messageId) {
+        sendDirectNotificationAck(messageId, 'delivered').catch(err => {
+          Logger.log('[SwanSDK] Direct delivery ACK failed:', err);
+        });
+      }
+      return;
+    }
+
     // Handle silent push (no UI display)
     if (isSilent) {
       console.log('[SwanSDK] Silent push received in background, skipping notification display');
-      console.log('[SwanSDK] ✅ Silent push handled');
+      Logger.log('[SwanSDK] ✅ Silent push handled');
       return;
     }
-    if (sdkInstance && sdkInstance.isReady()) {
-      await sdkInstance.sendNotificationAck(messageId, 'delivered');
-    }
     try {
       // Import notifee dynamically to avoid issues if not installed
       let notifee;
@@ -3356,10 +3585,10 @@ export function createBackgroundMessageHandler() {
       // Android may kill headless JS task during network requests
       // So we must show notification before any network calls
       const messageId = remoteMessage?.messageId;
-      console.log('[SwanSDK] Background handler - messageId:', messageId);
+      Logger.log('[SwanSDK] Background handler - messageId:', messageId);
 
       // Extract notification data from data payload (data-only messages)
-      console.log('[SwanSDK] Extracting notification data from payload...');
+      Logger.log('[SwanSDK] Extracting notification data from payload...');
       const title = remoteMessage.data?.title || 'Notification';
       const body = remoteMessage.data?.body || 'New message';
       const imageUrl = remoteMessage.data?.image || remoteMessage.data?.fcm_options?.image || '';
@@ -3383,6 +3612,11 @@ export function createBackgroundMessageHandler() {
       };
       const priority = getPriority();
 
+      // Resolve sound from data.sound payload field
+      const soundConfig = resolveSoundFromPayload(remoteMessage?.data?.sound);
+      const androidSound = buildAndroidSound(soundConfig);
+      const iosSound = buildIosSound(soundConfig);
+
       // Use messageId as notification ID for click tracking
       const notificationId = messageId || `swan_bg_${Date.now()}`;
       const notificationConfig = {
@@ -3405,9 +3639,18 @@ export function createBackgroundMessageHandler() {
           pressAction: {
             id: 'default'
           }
-        }
+        },
+        ios: {}
       };
 
+      // Add sound if resolved
+      if (androidSound !== undefined) {
+        notificationConfig.android.sound = androidSound;
+      }
+      if (iosSound !== undefined) {
+        notificationConfig.ios.sound = iosSound;
+      }
+
       // Add iOS category for Content Extension (e.g., carousel)
       if (remoteMessage?.category) {
         notificationConfig.ios = {
@@ -3433,30 +3676,26 @@ export function createBackgroundMessageHandler() {
           }]
         };
       }
-
-      // STEP 1: Display notification FIRST (fast local operation)
-      console.log('[SwanSDK] STEP 1: Displaying notification...');
-      await notifee.displayNotification(notificationConfig);
-      console.log('[SwanSDK] ✅ Notification displayed successfully');
+      await routeNotificationForDisplay(remoteMessage, notificationConfig, notifee);
 
       // STEP 2: Send delivery ACK (network operation - may be killed by OS)
-      console.log('[SwanSDK] STEP 2: Sending delivery ACK...');
+      Logger.log('[SwanSDK] STEP 2: Sending delivery ACK...');
       const isSDKReady = sdkInstance && sdkInstance.isReady();
       if (isSDKReady) {
-        console.log('[SwanSDK] Using SDK instance for delivery ACK');
+        Logger.log('[SwanSDK] Using SDK instance for delivery ACK');
         await sdkInstance.sendNotificationAck(messageId, 'delivered');
       } else if (messageId) {
         // SDK not fully initialized (app was killed) - send delivery ACK directly via fetch
         console.log('[SwanSDK] SDK not ready, sending delivery ACK via direct fetch');
         // Fire and forget - don't await since OS may kill us
         sendDirectNotificationAck(messageId, 'delivered').catch(err => {
-          console.log('[SwanSDK] Direct delivery ACK failed:', err);
+          Logger.log('[SwanSDK] Direct delivery ACK failed:', err);
         });
       }
-      console.log('[SwanSDK] ✅ Background handler completed');
+      Logger.log('[SwanSDK] ✅ Background handler completed');
     } catch (error) {
-      console.log('[SwanSDK] ❌ Error handling background message:', error?.message || error);
-      console.log('[SwanSDK] Error stack:', error?.stack);
+      Logger.error('[SwanSDK] Error handling background message:', error?.message || error);
+      Logger.error('[SwanSDK] Error stack:', error?.stack);
     }
   };
 }
@@ -3477,18 +3716,26 @@ export function createNotificationOpenedHandler() {
       const messageId = event?.messageId;
       const notificationData = event?.data || {};
 
-      // For iOS carousel notifications, iOS displays the notification (not Notifee),
-      // so this handler MUST process the click regardless of NES status.
-      // For non-carousel, defer to Notifee click handlers unless NES is active.
-      const isIOSCarousel = Platform.OS === 'ios' && notificationData.notificationType === 'carousel';
-      if (!isIOSCarousel) {
-        const isNESActive = await SharedCredentialsManager.isNotificationServiceExtensionActive();
-        if (!isNESActive && Platform.OS === 'ios') {
-          Logger.log('[SwanSDK] Non-carousel iOS without NES, deferring to Notifee click handler');
-          return;
-        }
+      // Use custom messageId (from push payload data) for deduplication.
+      // On iOS, both Firebase onNotificationOpenedApp AND Notifee event handlers
+      // fire for the same notification tap (Content Extension performNotificationDefaultAction).
+      // Firebase uses its own messageId, Notifee uses data.messageId — they differ.
+      // Using the custom messageId ensures both handlers use the same dedup key.
+      const customMessageId = notificationData.messageId;
+      const dedupId = customMessageId || messageId;
+
+      // Deduplication: prevent double click handling
+      if (dedupId && !markClickProcessed(dedupId)) {
+        Logger.log('[SwanSDK] Click already processed for messageId:', dedupId);
+        return;
       }
 
+      // If onNotificationOpenedApp fires, it means iOS displayed the notification
+      // natively (aps.alert present). Notifee handlers won't fire for iOS-native
+      // notifications, so this handler MUST process the click.
+      // For data-only messages (no aps.alert), Firebase never calls this handler.
+      const isIOSCarousel = Platform.OS === 'ios' && notificationData.notificationType === 'carousel';
+
       // Extract deep link information
       // For carousel notifications, the default route is in 'defaultRoute' field
       let route = notificationData.route || notificationData.defaultRoute;
@@ -3521,6 +3768,11 @@ export function createNotificationOpenedHandler() {
       // Emit notificationOpened event for host app to handle
       sdkInstance.emitNotificationOpened(deepLinkPayload);
 
+      // Send delivery ACK (background handler may not have fired for aps.alert notifications)
+      if (messageId && Platform.OS === 'ios') {
+        await sdkInstance.sendNotificationAck(messageId, 'delivered');
+      }
+
       // Send click ACK
       if (messageId) {
         await sdkInstance.sendNotificationAck(messageId, 'clicked');
@@ -3577,6 +3829,12 @@ export function createNotifeeForegroundHandler() {
       const messageId = event?.detail?.notification?.data?.messageId;
       const notificationData = event?.detail?.notification?.data || {};
 
+      // Deduplication: prevent double click handling
+      if (messageId && !markClickProcessed(messageId)) {
+        Logger.log('[SwanSDK] Click already processed for messageId:', messageId);
+        return;
+      }
+
       // Extract deep link information
       // Note: route field can contain either a path (/products/123) or full URL (myapp://products/123)
       // For carousel notifications, the default route is in 'defaultRoute' field
@@ -3661,6 +3919,12 @@ export function createNotifeeBackgroundHandler() {
       const messageId = detail?.notification?.data?.messageId;
       const notificationData = detail?.notification?.data || {};
 
+      // Deduplication: prevent double click handling
+      if (messageId && !markClickProcessed(messageId)) {
+        Logger.log('[SwanSDK] Click already processed for messageId:', messageId);
+        return;
+      }
+
       // Extract deep link information
       // Note: route field can contain either a path (/products/123) or full URL (myapp://products/123)
       // For carousel notifications, the default route is in 'defaultRoute' field
@@ -3737,13 +4001,13 @@ async function sendDirectNotificationAck(messageId, event) {
     const Base64Module = require('react-native-base64').default;
 
     // Read credentials from AsyncStorage
-    console.log('[SwanSDK] Reading credentials from AsyncStorage...');
+    Logger.log('[SwanSDK] Reading credentials from AsyncStorage...');
     const encoded = await AsyncStorageModule.getItem('swanCredentials');
     if (!encoded) {
       console.log(`[SwanSDK] No credentials found, cannot send ${event} ACK`);
       return;
     }
-    console.log('[SwanSDK] Credentials found, decoding...');
+    Logger.log('[SwanSDK] Credentials found, decoding...');
     const credentials = JSON.parse(Base64Module.decode(encoded));
     const {
       appId,
@@ -3768,13 +4032,13 @@ async function sendDirectNotificationAck(messageId, event) {
     };
     const urlType = isProduction === 'PROD' ? 'PROD' : 'STAGE';
     console.log(`[SwanSDK] Sending ${event} ACK to: ${URLS.WEBHOOK_MOBILE_PUSH_URL[urlType]}`);
-    console.log('[SwanSDK] Payload:', JSON.stringify(payload));
+    Logger.log('[SwanSDK] Payload:', JSON.stringify(payload));
     const controller = new AbortController();
     const timeoutId = setTimeout(() => {
-      console.log('[SwanSDK] ACK request timeout triggered (10s)');
+      Logger.log('[SwanSDK] ACK request timeout triggered (10s)');
       controller.abort();
     }, 10000);
-    console.log('[SwanSDK] Starting fetch...');
+    Logger.log('[SwanSDK] Starting fetch...');
     const response = await fetch(URLS.WEBHOOK_MOBILE_PUSH_URL[urlType], {
       method: 'POST',
       headers: {
@@ -3784,7 +4048,7 @@ async function sendDirectNotificationAck(messageId, event) {
       body: JSON.stringify(payload),
       signal: controller.signal
     });
-    console.log('[SwanSDK] Fetch completed, status:', response.status);
+    Logger.log('[SwanSDK] Fetch completed, status:', response.status);
     clearTimeout(timeoutId);
     if (response.ok) {
       console.log(`[SwanSDK] ✅ ${event} ACK sent successfully via direct fetch`);
@@ -3793,7 +4057,7 @@ async function sendDirectNotificationAck(messageId, event) {
       console.log(`[SwanSDK] ${event} ACK failed - HTTP ${response.status}: ${responseText}`);
     }
   } catch (error) {
-    console.log('[SwanSDK] Caught error in sendDirectNotificationAck');
+    Logger.log('[SwanSDK] Caught error in sendDirectNotificationAck');
     if (error?.name === 'AbortError') {
       console.log(`[SwanSDK] ${event} ACK timed out (AbortError)`);
     } else {