@clix-so/react-native-sdk 1.0.0 → 1.1.1-beta.1

package/lib/module/services/NotificationService.js

@@ -3,11 +3,11 @@
 import notifee, { AndroidCategory, AndroidGroupAlertBehavior, AndroidImportance, AndroidStyle, AndroidVisibility, AuthorizationStatus, EventType } from '@notifee/react-native';
 import messaging from '@react-native-firebase/messaging';
 import { Linking, Platform } from 'react-native';
-import { ClixPushNotificationPayload } from "../models/ClixPushNotificationPayload.js";
 import { ClixLogger } from "../utils/logging/ClixLogger.js";
-import { UUID } from "../utils/UUID.js";
 export class NotificationService {
-  static instance = null;
+  autoHandleLandingUrl = true;
+  isInitialized = false;
+  processedMessageIds = new Set();
   static DEFAULT_CHANNEL = {
     id: 'clix_channel',
     name: 'Clix Notifications',
@@ -18,84 +18,110 @@ export class NotificationService {
     lights: true
   };
   static ANDROID_GROUP_ID = 'clix_notification_group';
-  messagingService = messaging();
-  isInitialized = false;
-  currentPushToken = null;
-  processedMessageIds = new Set();
-  autoHandleLandingUrl = true;
-  constructor() {}
-  static getInstance() {
-    if (!NotificationService.instance) {
-      NotificationService.instance = new NotificationService();
-    }
-    return NotificationService.instance;
+  constructor(deviceService, tokenService, eventService) {
+    this.deviceService = deviceService;
+    this.tokenService = tokenService;
+    this.eventService = eventService;
   }
-  static resetInstance() {
-    if (NotificationService.instance) {
-      NotificationService.instance.cleanup();
-      NotificationService.instance = null;
-    }
-  }
-  async initialize(eventService, storageService, deviceService, tokenService) {
+  async initialize() {
     if (this.isInitialized) {
-      ClixLogger.debug('Notification service already initialized, returning existing instance');
-      return this;
+      ClixLogger.debug('Notification service already initialized');
+      return;
     }
     try {
-      ClixLogger.debug('Initializing notification service');
-      this.eventService = eventService;
-      this.storageService = storageService;
-      this.deviceService = deviceService;
-      this.tokenService = tokenService;
-      await this.initializeMessageService();
-      await this.initializeNotificationDisplayService();
+      ClixLogger.debug('Initializing notification service...');
+      this.setupTokenRefreshListener();
+      this.setupPushReceivedHandler(); // NOTE(nyanxyz): must be set up before any await calls
+      await this.setupPushTappedHandler();
+      if (Platform.OS === 'android') {
+        await this.createNotificationChannels();
+      }
       this.isInitialized = true;
       ClixLogger.debug('Notification service initialized successfully');
-      return this;
     } catch (error) {
       ClixLogger.error('Failed to initialize notification service', error);
       throw error;
     }
   }
-  async getCurrentToken() {
-    try {
-      this.currentPushToken = await this.getOrFetchToken();
-      return this.currentPushToken;
-    } catch (error) {
-      ClixLogger.error('Failed to get push token', error);
-      await this.handleFcmTokenError(error);
-      return null;
-    }
-  }
   cleanup() {
-    this.unsubscribeForegroundMessage?.();
-    this.unsubscribeNotificationOpened?.();
+    this.unsubscribeMessage?.();
+    this.unsubscribeNotificationOpenedApp?.();
     this.unsubscribeTokenRefresh?.();
-    this.unsubscribeNotificationEvents?.();
+    this.unsubscribeForegroundEvent?.();
     this.isInitialized = false;
     this.processedMessageIds.clear();
     ClixLogger.debug('Notification service cleaned up');
   }
-  setMessageHandler(handler) {
-    this.messageHandler = handler;
-  }
-  setBackgroundMessageHandler(handler) {
-    this.backgroundMessageHandler = handler;
-  }
-  setNotificationOpenedHandler(handler) {
-    this.openedHandler = handler;
+  async requestPermission() {
+    const settings = await notifee.requestPermission({
+      alert: true,
+      badge: true,
+      sound: true,
+      provisional: false,
+      announcement: false,
+      carPlay: false,
+      criticalAlert: false
+    });
+    ClixLogger.debug('Push notification permission status:', settings);
+    const isGranted = settings.authorizationStatus === AuthorizationStatus.AUTHORIZED || settings.authorizationStatus === AuthorizationStatus.PROVISIONAL;
+    await this.setPermissionGranted(isGranted);
+    return settings;
   }
-  setFcmTokenErrorHandler(handler) {
-    this.fcmTokenErrorHandler = handler;
+  async setPermissionGranted(isGranted) {
+    try {
+      await this.deviceService.updatePushPermission(isGranted);
+      ClixLogger.debug(`Push permission status reported to server: ${isGranted ? 'granted' : 'denied'}`);
+    } catch (error) {
+      ClixLogger.warn('Failed to upsert push permission status', error);
+    }
   }
-  setAutoHandleLandingUrl(enable) {
-    this.autoHandleLandingUrl = enable;
+  setupPushReceivedHandler() {
+    /**
+     * Android: background message handler
+     */
+    messaging().setBackgroundMessageHandler(this.handleBackgroundMessage.bind(this));
+    /**
+     * iOS & Android: foreground message handler
+     */
+    this.unsubscribeMessage = messaging().onMessage(this.handleForegroundMessage.bind(this));
+    /**
+     * iOS: background messages are handled in the Notification Service Extension
+     */
+  }
+  async setupPushTappedHandler() {
+    /**
+     * Android: background notification tap handler
+     *          & app launched from quit state via a notification
+     */
+    notifee.onBackgroundEvent(this.handleNotificationEvent.bind(this));
+    /**
+     * iOS & Android: foreground notification tap handler
+     */
+    this.unsubscribeForegroundEvent = notifee.onForegroundEvent(this.handleForegroundNotificationEvent.bind(this));
+    /**
+     * iOS: background notification tap handler
+     */
+    this.unsubscribeNotificationOpenedApp = messaging().onNotificationOpenedApp(this.handleNotificationOpenedApp.bind(this));
+    /**
+     * iOS: app launched from a quit state via a notification
+     */
+    await this.handleInitialNotification();
   }
-  async initializeNotificationDisplayService() {
-    if (Platform.OS === 'android') {
-      await this.createNotificationChannels();
-    }
-    this.setupNotificationEventListeners();
+  setupTokenRefreshListener() {
+    this.unsubscribeTokenRefresh = messaging().onTokenRefresh(async token => {
+      try {
+        await this.tokenRefreshHandler?.(token);
+      } catch (error) {
+        ClixLogger.error('Token refresh handler failed', error);
+      }
+      try {
+        ClixLogger.debug(`Push token refreshed: ${token}`);
+        this.tokenService.saveToken(token);
+        await this.deviceService.updatePushToken(token, 'FCM');
+      } catch (error) {
+        ClixLogger.error('Failed to handle token refresh', error);
+      }
+    });
   }
   async createNotificationChannels() {
     try {
@@ -105,66 +131,13 @@ export class NotificationService {
       ClixLogger.error('Failed to create notification channels', error);
     }
   }
-  setupNotificationEventListeners() {
-    this.unsubscribeNotificationEvents = notifee.onForegroundEvent(async event => {
-      await this.handleNotificationEvent(event);
-    });
-    notifee.onBackgroundEvent(async event => {
-      await this.handleNotificationEvent(event);
-    });
-  }
-  async handleNotificationEvent(event) {
-    const {
-      type,
-      detail
-    } = event;
-    switch (type) {
-      case EventType.PRESS:
-        if (detail.notification?.data) {
-          await this.handleNotificationTap(detail.notification.data);
-        }
-        break;
-      case EventType.ACTION_PRESS:
-        if (detail.pressAction?.id) {
-          await this.handleActionPress(detail.pressAction.id, detail.notification?.data);
-        }
-        break;
-      case EventType.DISMISSED:
-        ClixLogger.debug('Notification dismissed');
-        break;
-      default:
-        ClixLogger.debug('Unhandled notification event type:', type);
-    }
-  }
-  async handleActionPress(actionId, data) {
-    ClixLogger.debug('Action pressed:', actionId);
-    if (data) {
-      await this.handleNotificationTap(data);
-    }
-  }
-  async initializeMessageService() {
-    this.setupMessageHandlers();
-    await this.getAndUpdateToken();
-    this.setupTokenRefreshListener();
-  }
-  setupMessageHandlers() {
-    this.messagingService.setBackgroundMessageHandler(async remoteMessage => {
-      await this.handleBackgroundMessage(remoteMessage);
-    });
-    this.unsubscribeForegroundMessage = this.messagingService.onMessage(async remoteMessage => {
-      await this.handleForegroundMessage(remoteMessage);
-    });
-    this.unsubscribeNotificationOpened = this.messagingService.onNotificationOpenedApp(async remoteMessage => {
-      ClixLogger.debug('Notification opened from background state:', {
-        messageId: remoteMessage.messageId,
-        data: remoteMessage.data
-      });
-      await this.handleNotificationTap(remoteMessage.data ?? {});
-    });
-    this.checkInitialNotification();
-  }
+
+  /**
+   * Android: background message handler
+   */
   async handleBackgroundMessage(remoteMessage) {
     ClixLogger.debug('Handling background message:', remoteMessage.messageId);
+    setTimeout(() => ClixLogger.debug('still alive after 3s'), 3000);
     const data = remoteMessage.data ?? {};
     try {
       await this.backgroundMessageHandler?.(data);
@@ -177,152 +150,173 @@ export class NotificationService {
         ClixLogger.warn('No Clix payload found in background message');
         return;
       }
-      this.storageService.set('last_background_notification', {
-        messageId: remoteMessage.messageId,
-        data: data,
-        timestamp: Date.now(),
-        clixMessageId: clixPayload.messageId,
-        campaignId: clixPayload.campaignId,
-        trackingId: clixPayload.trackingId
-      });
-      await this.trackEventInBackground(clixPayload);
       if (!remoteMessage.notification) {
         await this.displayNotification(remoteMessage, clixPayload);
       }
+      await this.trackPushReceivedEvent(clixPayload);
     } catch (error) {
       ClixLogger.error('Background message handler error:', error);
     }
   }
+
+  /**
+   * iOS & Android: foreground message handler
+   */
   async handleForegroundMessage(remoteMessage) {
     ClixLogger.debug('Handling foreground message:', remoteMessage.messageId);
+    const messageId = remoteMessage.messageId;
+    if (!messageId) {
+      ClixLogger.warn('No messageId found in foreground message');
+      return;
+    }
+    if (this.processedMessageIds.has(messageId)) {
+      ClixLogger.debug('Message already processed, skipping duplicate:', messageId);
+      return;
+    }
+    const data = remoteMessage.data ?? {};
     try {
-      const messageId = remoteMessage.messageId;
-      if (!messageId) {
-        ClixLogger.warn('No messageId found in foreground message');
+      const result = await this.messageHandler?.(data);
+      if (result === false) {
+        ClixLogger.debug('Foreground message suppressed by user handler:', remoteMessage.messageId);
         return;
       }
-      if (this.processedMessageIds.has(messageId)) {
-        ClixLogger.debug('Message already processed, skipping duplicate:', messageId);
+    } catch (error) {
+      ClixLogger.error('Foreground message handler failed', error);
+    }
+    try {
+      const clixPayload = this.parseClixPayload(data);
+      if (!clixPayload) {
+        ClixLogger.warn('No Clix payload found in background message');
         return;
       }
-      const data = remoteMessage.data ?? {};
-      const clixPayload = this.parseClixPayload(data);
-      if (clixPayload) {
-        ClixLogger.debug('Parsed Clix payload:', clixPayload);
-        this.processedMessageIds.add(messageId);
-        if (Platform.OS === 'android') {
-          // NOTE(nyanxyz): on iOS, Received event is tracked in NSE
-          await this.handlePushReceived(data);
-        }
-        if (await this.shouldDisplayForegroundNotification(data)) {
-          await this.displayNotification(remoteMessage, clixPayload);
-        } else {
-          ClixLogger.debug('Foreground message suppressed by user handler:', messageId);
-        }
-      } else {
-        ClixLogger.warn('No Clix payload found in foreground message');
+      this.processedMessageIds.add(messageId);
+      await this.displayNotification(remoteMessage, clixPayload);
+      if (Platform.OS === 'android') {
+        // NOTE(nyanxyz): on iOS, Received event is tracked in Notification Service Extension
+        await this.trackPushReceivedEvent(clixPayload);
       }
     } catch (error) {
       ClixLogger.error('Failed to handle foreground message', error);
     }
   }
-  async requestPermission() {
-    const settings = await notifee.requestPermission({
-      alert: true,
-      badge: true,
-      sound: true,
-      provisional: false,
-      announcement: false,
-      carPlay: false,
-      criticalAlert: false
+
+  /**
+   * iOS: background notification tap handler
+   */
+  async handleNotificationOpenedApp(remoteMessage) {
+    ClixLogger.debug('Handling notification opened from background:', {
+      messageId: remoteMessage.messageId,
+      data: remoteMessage.data
     });
-    ClixLogger.debug('Push notification permission status:', settings);
-    const isGranted = settings.authorizationStatus === AuthorizationStatus.AUTHORIZED || settings.authorizationStatus === AuthorizationStatus.PROVISIONAL;
-    await this.setPermissionGranted(isGranted);
-    return settings;
-  }
-  async setPermissionGranted(isGranted) {
-    if (!this.deviceService) {
-      ClixLogger.debug('Device service is not initialized, skipping push permission upsert');
-      return;
-    }
+    const data = remoteMessage.data ?? {};
     try {
-      await this.deviceService.upsertIsPushPermissionGranted(isGranted);
-      ClixLogger.debug(`Push permission status reported to server: ${isGranted ? 'granted' : 'denied'}`);
+      await this.notificationOpenedAppHandler?.(data);
     } catch (error) {
-      ClixLogger.warn('Failed to upsert push permission status', error);
+      ClixLogger.error('Notification opened app handler failed', error);
     }
-  }
-  setupTokenRefreshListener() {
-    this.unsubscribeTokenRefresh = this.messagingService.onTokenRefresh(async token => {
-      try {
-        ClixLogger.debug('Push token refreshed');
-        this.currentPushToken = token;
-        await this.saveAndRegisterToken(token);
-      } catch (error) {
-        ClixLogger.error('Failed to handle token refresh', error);
-        await this.handleFcmTokenError(error);
+    try {
+      const clixPayload = this.parseClixPayload(data);
+      if (clixPayload) {
+        await this.trackPushTappedEvent(clixPayload);
       }
-    });
+      if (this.autoHandleLandingUrl) {
+        await this.handleUrlNavigation(data);
+      }
+    } catch (error) {
+      ClixLogger.error('Failed to handle notification opened from background', error);
+    }
   }
-  async checkInitialNotification() {
+
+  /**
+   * iOS: app launched from a quit state via a notification
+   */
+  async handleInitialNotification() {
     try {
-      const initialNotification = await this.messagingService.getInitialNotification();
+      const initialNotification = await messaging().getInitialNotification();
       if (initialNotification) {
         ClixLogger.debug('App launched from notification:', initialNotification.messageId);
-        await this.handleNotificationTap(initialNotification.data ?? {});
+        const data = initialNotification.data ?? {};
+        const clixPayload = this.parseClixPayload(data);
+        if (clixPayload) {
+          await this.trackPushTappedEvent(clixPayload);
+        }
+        if (this.autoHandleLandingUrl) {
+          await this.handleUrlNavigation(data);
+        }
       }
     } catch (error) {
       ClixLogger.error('Failed to handle initial notification', error);
     }
   }
-  async getAndUpdateToken() {
-    try {
-      const token = await this.getCurrentToken();
-      if (token) {
-        await this.registerTokenWithServer(token);
-      }
-    } catch (error) {
-      ClixLogger.error('Failed to update push token', error);
+
+  /**
+   * Android: background notification tap handler
+   */
+  async handleNotificationEvent(event) {
+    const {
+      type,
+      detail
+    } = event;
+    switch (type) {
+      case EventType.PRESS:
+      case EventType.ACTION_PRESS:
+        {
+          const data = detail.notification?.data || {};
+          const clixPayload = this.parseClixPayload(data);
+          if (clixPayload) {
+            await this.trackPushTappedEvent(clixPayload);
+          }
+          if (this.autoHandleLandingUrl) {
+            await this.handleUrlNavigation(data);
+          }
+          break;
+        }
+      case EventType.DISMISSED:
+        ClixLogger.debug('Notification dismissed');
+        break;
+      default:
+        ClixLogger.debug('Unhandled notification event type:', type);
     }
   }
-  async getOrFetchToken() {
-    if (this.tokenService) {
-      const savedToken = this.tokenService.getCurrentToken();
-      if (savedToken) return savedToken;
-    }
-    const token = await this.messagingService.getToken();
-    if (token) {
-      ClixLogger.debug('Got push token:', token.substring(0, 20) + '...');
-      this.tokenService?.saveToken(token);
+
+  /**
+   * iOS & Android: foreground notification tap handler
+   */
+  async handleForegroundNotificationEvent(event) {
+    try {
+      await this.foregroundEventHandler?.(event);
+    } catch (error) {
+      ClixLogger.error('Foreground notification event handler failed', error);
     }
-    return token;
+    await this.handleNotificationEvent(event);
   }
-  async saveAndRegisterToken(token) {
-    if (this.tokenService) {
-      this.tokenService.saveToken(token);
-      ClixLogger.debug('New push token saved via TokenService');
+  async trackPushReceivedEvent(payload) {
+    try {
+      await this.eventService.trackEvent('PUSH_NOTIFICATION_RECEIVED', {}, payload.messageId, payload.userJourneyId, payload.userJourneyNodeId);
+      ClixLogger.debug('PUSH_NOTIFICATION_RECEIVED event tracked:', payload.messageId);
+    } catch (error) {
+      ClixLogger.error('Failed to track PUSH_NOTIFICATION_RECEIVED event', error);
     }
-    await this.registerTokenWithServer(token);
   }
-  async registerTokenWithServer(token) {
-    if (this.deviceService) {
-      await this.deviceService.upsertToken(token);
-      ClixLogger.debug('Push token registered with server');
+  async trackPushTappedEvent(payload) {
+    try {
+      await this.eventService.trackEvent('PUSH_NOTIFICATION_TAPPED', {}, payload.messageId, payload.userJourneyId, payload.userJourneyNodeId);
+      ClixLogger.debug('PUSH_NOTIFICATION_TAPPED event tracked:', payload.messageId);
+    } catch (error) {
+      ClixLogger.error('Failed to track PUSH_NOTIFICATION_TAPPED event', error);
     }
   }
   async displayNotification(remoteMessage, clixPayload) {
     try {
-      const notificationContent = this.extractNotificationContent(remoteMessage.notification, clixPayload);
       ClixLogger.debug('Creating notification config with content:', {
-        title: notificationContent.title,
-        body: notificationContent.body,
-        hasImage: !!notificationContent.imageUrl,
-        imageUrl: notificationContent.imageUrl
+        title: clixPayload.title,
+        body: clixPayload.body,
+        hasImage: !!clixPayload.imageUrl,
+        imageUrl: clixPayload.imageUrl
       });
-      const notificationConfig = await this.createNotificationConfig(remoteMessage, clixPayload, notificationContent, NotificationService.DEFAULT_CHANNEL.id);
+      const notificationConfig = await this.createNotificationConfig(remoteMessage, clixPayload, NotificationService.DEFAULT_CHANNEL.id);
       await notifee.displayNotification(notificationConfig);
-      ClixLogger.debug('Notification displayed successfully:', notificationContent.title);
+      ClixLogger.debug('Notification displayed successfully:', clixPayload.title);
     } catch (error) {
       ClixLogger.error('Failed to display notification', error);
       if (error instanceof Error) {
@@ -336,12 +330,12 @@ export class NotificationService {
       }
     }
   }
-  async createNotificationConfig(remoteMessage, clixPayload, notificationContent, channelId) {
-    const imageUrl = notificationContent.imageUrl;
+  async createNotificationConfig(remoteMessage, clixPayload, channelId) {
+    const imageUrl = clixPayload.imageUrl;
     const config = {
       id: remoteMessage.messageId || Date.now().toString(),
-      title: notificationContent.title,
-      body: notificationContent.body,
+      title: clixPayload.title,
+      body: clixPayload.body,
       data: remoteMessage.data ?? {},
       android: {
         channelId,
@@ -352,11 +346,10 @@ export class NotificationService {
         groupSummary: false,
         groupAlertBehavior: AndroidGroupAlertBehavior.CHILDREN,
         sound: 'default',
-        ticker: notificationContent.body,
-        actions: this.createNotificationActions(clixPayload),
+        ticker: clixPayload.body,
         style: {
           type: AndroidStyle.BIGTEXT,
-          text: notificationContent.body ?? ''
+          text: clixPayload.body
         },
         pressAction: {
           id: 'default'
@@ -377,103 +370,6 @@ export class NotificationService {
     }
     return config;
   }
-  createNotificationActions(clixPayload) {
-    const actions = [];
-    actions.push({
-      title: 'Open',
-      pressAction: {
-        id: 'default'
-      }
-    });
-    if (clixPayload.customProperties?.actions) {
-      const customActions = clixPayload.customProperties.actions;
-      if (Array.isArray(customActions)) {
-        customActions.forEach(action => {
-          if (action.title && action.actionId) {
-            actions.push({
-              title: action.title,
-              pressAction: {
-                id: action.actionId
-              }
-            });
-          }
-        });
-      }
-    }
-    return actions;
-  }
-  isValidImageUrl(url) {
-    return url.trim() !== '' && url.startsWith('http');
-  }
-  extractNotificationContent(fcmNotification, clixPayload) {
-    ClixLogger.debug('Extracting notification content from payload:', {
-      fcmTitle: fcmNotification?.title,
-      fcmBody: fcmNotification?.body,
-      customProperties: clixPayload.customProperties,
-      messageId: clixPayload.messageId,
-      imageUrl: clixPayload.imageUrl
-    });
-    const title = fcmNotification?.title || clixPayload.customProperties?.title || 'New Message';
-    const body = fcmNotification?.body || clixPayload.customProperties?.body || '';
-    ClixLogger.debug('Extracted notification content:', {
-      title,
-      body
-    });
-
-    // Validate imageUrl before using it
-    let imageUrl;
-    if (clixPayload.imageUrl) {
-      ClixLogger.debug('Processing image URL:', clixPayload.imageUrl);
-      if (this.isValidImageUrl(clixPayload.imageUrl)) {
-        imageUrl = clixPayload.imageUrl;
-        ClixLogger.debug('Image URL validated successfully');
-      } else {
-        ClixLogger.warn('Invalid image URL, skipping:', clixPayload.imageUrl);
-      }
-    }
-    return {
-      title,
-      body,
-      imageUrl
-    };
-  }
-  async handlePushReceived(data) {
-    try {
-      const clixPayload = this.parseClixPayload(data);
-      if (clixPayload) {
-        await this.trackPushEvent('PUSH_NOTIFICATION_RECEIVED', clixPayload);
-      }
-      ClixLogger.debug('Push notification received and processed');
-    } catch (error) {
-      ClixLogger.error('Failed to handle push received', error);
-    }
-  }
-  async handlePushTapped(data) {
-    try {
-      const clixPayload = this.parseClixPayload(data);
-      if (clixPayload) {
-        await this.trackPushEvent('PUSH_NOTIFICATION_TAPPED', clixPayload);
-      }
-      if (this.autoHandleLandingUrl) {
-        await this.handleUrlNavigation(data);
-      }
-      ClixLogger.debug('Push notification tapped and processed');
-    } catch (error) {
-      ClixLogger.error('Failed to handle push tapped', error);
-    }
-  }
-  async handleNotificationTap(data) {
-    try {
-      await this.openedHandler?.(data);
-    } catch (error) {
-      ClixLogger.error('Failed to handle notification tap', error);
-    }
-    try {
-      await this.handlePushTapped(data);
-    } catch (error) {
-      ClixLogger.error('Failed to handle notification tap', error);
-    }
-  }
   async handleUrlNavigation(data) {
     try {
       let url;
@@ -504,91 +400,46 @@ export class NotificationService {
   }
   parseClixPayload(userInfo) {
     try {
-      let payload = userInfo;
-      if (userInfo.clix) {
-        if (typeof userInfo.clix === 'object') {
-          payload = userInfo.clix;
-        } else if (typeof userInfo.clix === 'string') {
-          payload = JSON.parse(userInfo.clix);
-        }
+      let data = userInfo?.clix;
+      if (data == null) {
+        ClixLogger.debug("No 'clix' entry found in notification data");
+        return null;
       }
-      const toCamel = s => s.replace(/_([a-z])/g, g => (g[1] ?? '').toUpperCase());
-      const result = {};
-      if (!payload) return null;
-      for (const key in payload) {
-        result[toCamel(key)] = payload[key];
+      if (typeof data === 'string') {
+        try {
+          data = JSON.parse(data);
+        } catch (parseError) {
+          ClixLogger.error('Failed to parse Clix payload JSON string', parseError);
+          return null;
+        }
       }
-      ClixLogger.debug('Parsed Clix payload result:', result);
-      if (!result.messageId) return null;
-
-      // Extract title and body into customProperties if they exist
-      const customProperties = {};
-      if (result.title) customProperties.title = result.title;
-      if (result.body) customProperties.body = result.body;
-      const finalResult = {
-        ...result,
-        customProperties: Object.keys(customProperties).length > 0 ? customProperties : undefined
+      ClixLogger.debug('Parsing Clix payload from notification data:', data);
+      const payload = {
+        messageId: data.message_id,
+        title: data.title,
+        body: data.body,
+        imageUrl: data.image_url || undefined,
+        landingUrl: data.landing_url || undefined,
+        userJourneyId: data.user_journey_id || undefined,
+        userJourneyNodeId: data.user_journey_node_id || undefined
       };
-      ClixLogger.debug('Final Clix payload result:', finalResult);
-      return new ClixPushNotificationPayload(finalResult);
-    } catch (error) {
-      ClixLogger.error('Failed to parse Clix payload', error);
-      return null;
-    }
-  }
-  async trackPushEvent(eventType, clixPayload) {
-    const properties = this.extractTrackingProperties(clixPayload);
-    const messageId = clixPayload.messageId;
-    await this.eventService.trackEvent(eventType, properties, messageId);
-    ClixLogger.debug(`${eventType} tracked:`, messageId);
-  }
-  extractTrackingProperties(clixPayload) {
-    const properties = {};
-    if (clixPayload.messageId) properties.messageId = clixPayload.messageId;
-    if (clixPayload.campaignId) properties.campaignId = clixPayload.campaignId;
-    if (clixPayload.trackingId) properties.trackingId = clixPayload.trackingId;
-    return properties;
-  }
-  async trackEventInBackground(clixPayload) {
-    const messageId = clixPayload.messageId;
-    if (!messageId) {
-      ClixLogger.warn('No messageId found in payload, skipping event tracking');
-      return;
-    }
-    try {
-      const configData = this.storageService.get('clix_config');
-      if (!configData) {
-        ClixLogger.error('No Clix config found in storage');
-        return;
+      ClixLogger.debug('Constructed Clix payload:', payload);
+      if (!payload.messageId) {
+        ClixLogger.error('No messageId found in Clix payload');
+        return null;
       }
-      let deviceId = this.storageService.get('clix_device_id');
-      if (!deviceId) {
-        ClixLogger.warn('No device ID found in storage, generating new device ID');
-        deviceId = UUID.generate();
-        this.storageService.set('clix_device_id', deviceId);
+      if (!payload.title) {
+        ClixLogger.error('No title found in Clix payload');
+        return null;
       }
-      const properties = this.extractTrackingProperties(clixPayload);
-      await this.eventService.trackEvent('PUSH_NOTIFICATION_RECEIVED', properties, messageId);
-      ClixLogger.debug('PUSH_NOTIFICATION_RECEIVED event tracked in background');
-    } catch (error) {
-      ClixLogger.error('Error tracking event in background', error);
-    }
-  }
-  async shouldDisplayForegroundNotification(data) {
-    try {
-      const result = await this.messageHandler?.(data);
-      return result !== false;
+      if (!payload.body) {
+        ClixLogger.error('No body found in Clix payload');
+        return null;
+      }
+      return payload;
     } catch (error) {
-      ClixLogger.warn('Foreground message handler failed, displaying notification by default', error);
-      return true;
-    }
-  }
-  async handleFcmTokenError(error) {
-    try {
-      const errorInstance = error instanceof Error ? error : new Error(String(error));
-      await this.fcmTokenErrorHandler?.(errorInstance);
-    } catch (handlerError) {
-      ClixLogger.warn('FCM token error handler failed', handlerError);
+      ClixLogger.error('Failed to parse Clix payload', error);
+      return null;
     }
   }
 }