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

package/src/services/NotificationService.ts

@@ -15,35 +15,40 @@ import messaging, {
   FirebaseMessagingTypes,
 } from '@react-native-firebase/messaging';
 import { Linking, Platform } from 'react-native';
-import { ClixPushNotificationPayload } from '../models/ClixPushNotificationPayload';
+import type { ClixPushNotificationPayload } from '../models/ClixPushNotificationPayload';
 import { ClixLogger } from '../utils/logging/ClixLogger';
-import { UUID } from '../utils/UUID';
 import { DeviceService } from './DeviceService';
 import { EventService } from './EventService';
-import { StorageService } from './StorageService';
 import { TokenService } from './TokenService';
 
-interface NotificationContent {
-  title: string;
-  body: string;
-  imageUrl?: string;
-}
-
 type NotificationData = Record<string, any>;
 
-export type ForegroundMessageHandler = (
+export type MessageHandler = (
   data: NotificationData
 ) => Promise<boolean> | boolean;
 export type BackgroundMessageHandler = (
   data: NotificationData
 ) => Promise<void> | void;
-export type NotificationOpenedHandler = (
+export type NotificationOpenedAppHandler = (
   data: NotificationData
 ) => Promise<void> | void;
-export type FcmTokenErrorHandler = (error: Error) => Promise<void> | void;
+export type TokenRefreshHandler = (token: string) => Promise<void> | void;
+export type ForegroundEventHandler = (event: Event) => Promise<void> | void;
 
 export class NotificationService {
-  private static instance: NotificationService | null = null;
+  autoHandleLandingUrl = true;
+  messageHandler?: MessageHandler;
+  backgroundMessageHandler?: BackgroundMessageHandler;
+  notificationOpenedAppHandler?: NotificationOpenedAppHandler;
+  tokenRefreshHandler?: TokenRefreshHandler;
+  foregroundEventHandler?: ForegroundEventHandler;
+
+  private isInitialized = false;
+  private processedMessageIds = new Set<string>();
+  private unsubscribeMessage?: () => void;
+  private unsubscribeNotificationOpenedApp?: () => void;
+  private unsubscribeTokenRefresh?: () => void;
+  private unsubscribeForegroundEvent?: () => void;
 
   private static readonly DEFAULT_CHANNEL: AndroidChannel = {
     id: 'clix_channel',
@@ -56,214 +61,161 @@ export class NotificationService {
   };
   private static readonly ANDROID_GROUP_ID = 'clix_notification_group';
 
-  private messagingService = messaging();
-  private isInitialized = false;
-  private currentPushToken: string | null = null;
-  private processedMessageIds = new Set<string>();
-
-  private eventService!: EventService;
-  private storageService!: StorageService;
-  private deviceService?: DeviceService;
-  private tokenService?: TokenService;
+  constructor(
+    private readonly deviceService: DeviceService,
+    private readonly tokenService: TokenService,
+    private readonly eventService: EventService
+  ) {}
 
-  private autoHandleLandingUrl = true;
-  private messageHandler?: ForegroundMessageHandler;
-  private backgroundMessageHandler?: BackgroundMessageHandler;
-  private openedHandler?: NotificationOpenedHandler;
-  private fcmTokenErrorHandler?: FcmTokenErrorHandler;
-
-  private unsubscribeForegroundMessage?: () => void;
-  private unsubscribeNotificationOpened?: () => void;
-  private unsubscribeTokenRefresh?: () => void;
-  private unsubscribeNotificationEvents?: () => void;
-
-  private constructor() {}
-
-  public static getInstance(): NotificationService {
-    if (!NotificationService.instance) {
-      NotificationService.instance = new NotificationService();
-    }
-    return NotificationService.instance;
-  }
-
-  public static resetInstance(): void {
-    if (NotificationService.instance) {
-      NotificationService.instance.cleanup();
-      NotificationService.instance = null;
-    }
-  }
-
-  async initialize(
-    eventService: EventService,
-    storageService: StorageService,
-    deviceService?: DeviceService,
-    tokenService?: TokenService
-  ): Promise<NotificationService> {
+  async initialize(): Promise<void> {
     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');
+      ClixLogger.debug('Initializing notification service...');
 
-      this.eventService = eventService;
-      this.storageService = storageService;
-      this.deviceService = deviceService;
-      this.tokenService = tokenService;
+      this.setupTokenRefreshListener();
+      this.setupPushReceivedHandler(); // NOTE(nyanxyz): must be set up before any await calls
+      await this.setupPushTappedHandler();
 
-      await this.initializeMessageService();
-      await this.initializeNotificationDisplayService();
+      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(): Promise<string | null> {
-    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(): void {
-    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?: ForegroundMessageHandler): void {
-    this.messageHandler = handler;
-  }
-
-  setBackgroundMessageHandler(handler?: BackgroundMessageHandler): void {
-    this.backgroundMessageHandler = handler;
-  }
-
-  setNotificationOpenedHandler(handler?: NotificationOpenedHandler): void {
-    this.openedHandler = handler;
-  }
-
-  setFcmTokenErrorHandler(handler?: FcmTokenErrorHandler): void {
-    this.fcmTokenErrorHandler = handler;
-  }
+  async requestPermission(): Promise<NotificationSettings> {
+    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);
 
-  setAutoHandleLandingUrl(enable: boolean): void {
-    this.autoHandleLandingUrl = enable;
-  }
+    const isGranted =
+      settings.authorizationStatus === AuthorizationStatus.AUTHORIZED ||
+      settings.authorizationStatus === AuthorizationStatus.PROVISIONAL;
 
-  private async initializeNotificationDisplayService(): Promise<void> {
-    if (Platform.OS === 'android') {
-      await this.createNotificationChannels();
-    }
-    this.setupNotificationEventListeners();
+    await this.setPermissionGranted(isGranted);
+    return settings;
   }
 
-  private async createNotificationChannels(): Promise<void> {
+  async setPermissionGranted(isGranted: boolean): Promise<void> {
     try {
-      await notifee.createChannel(NotificationService.DEFAULT_CHANNEL);
-      ClixLogger.debug('Notification channels created successfully');
+      await this.deviceService.updatePushPermission(isGranted);
+      ClixLogger.debug(
+        `Push permission status reported to server: ${
+          isGranted ? 'granted' : 'denied'
+        }`
+      );
     } catch (error) {
-      ClixLogger.error('Failed to create notification channels', error);
+      ClixLogger.warn('Failed to upsert push permission status', error);
     }
   }
 
-  private setupNotificationEventListeners(): void {
-    this.unsubscribeNotificationEvents = notifee.onForegroundEvent(
-      async (event: Event) => {
-        await this.handleNotificationEvent(event);
-      }
+  private setupPushReceivedHandler(): void {
+    /**
+     * Android: background message handler
+     */
+    messaging().setBackgroundMessageHandler(
+      this.handleBackgroundMessage.bind(this)
     );
-    notifee.onBackgroundEvent(async (event: Event) => {
-      await this.handleNotificationEvent(event);
-    });
+    /**
+     * iOS & Android: foreground message handler
+     */
+    this.unsubscribeMessage = messaging().onMessage(
+      this.handleForegroundMessage.bind(this)
+    );
+    /**
+     * iOS: background messages are handled in the Notification Service Extension
+     */
+  }
+
+  private async setupPushTappedHandler(): Promise<void> {
+    /**
+     * 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();
   }
 
-  private async handleNotificationEvent(event: Event): Promise<void> {
-    const { type, detail } = event;
-
-    switch (type) {
-      case EventType.PRESS:
-        if (detail.notification?.data) {
-          await this.handleNotificationTap(detail.notification.data);
+  private setupTokenRefreshListener(): void {
+    this.unsubscribeTokenRefresh = messaging().onTokenRefresh(
+      async (token: string) => {
+        try {
+          await this.tokenRefreshHandler?.(token);
+        } catch (error) {
+          ClixLogger.error('Token refresh handler failed', error);
         }
-        break;
-      case EventType.ACTION_PRESS:
-        if (detail.pressAction?.id) {
-          await this.handleActionPress(
-            detail.pressAction.id,
-            detail.notification?.data
-          );
+
+        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);
         }
-        break;
-      case EventType.DISMISSED:
-        ClixLogger.debug('Notification dismissed');
-        break;
-      default:
-        ClixLogger.debug('Unhandled notification event type:', type);
-    }
+      }
+    );
   }
 
-  private async handleActionPress(
-    actionId: string,
-    data?: Record<string, any>
-  ): Promise<void> {
-    ClixLogger.debug('Action pressed:', actionId);
-    if (data) {
-      await this.handleNotificationTap(data);
+  private async createNotificationChannels(): Promise<void> {
+    try {
+      await notifee.createChannel(NotificationService.DEFAULT_CHANNEL);
+      ClixLogger.debug('Notification channels created successfully');
+    } catch (error) {
+      ClixLogger.error('Failed to create notification channels', error);
     }
   }
 
-  private async initializeMessageService(): Promise<void> {
-    this.setupMessageHandlers();
-    await this.getAndUpdateToken();
-    this.setupTokenRefreshListener();
-  }
-
-  private setupMessageHandlers(): void {
-    this.messagingService.setBackgroundMessageHandler(
-      async (remoteMessage: FirebaseMessagingTypes.RemoteMessage) => {
-        await this.handleBackgroundMessage(remoteMessage);
-      }
-    );
-    this.unsubscribeForegroundMessage = this.messagingService.onMessage(
-      async (remoteMessage: FirebaseMessagingTypes.RemoteMessage) => {
-        await this.handleForegroundMessage(remoteMessage);
-      }
-    );
-    this.unsubscribeNotificationOpened =
-      this.messagingService.onNotificationOpenedApp(
-        async (remoteMessage: FirebaseMessagingTypes.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
+   */
   private async handleBackgroundMessage(
     remoteMessage: FirebaseMessagingTypes.RemoteMessage
   ): Promise<void> {
     ClixLogger.debug('Handling background message:', remoteMessage.messageId);
 
+    setTimeout(() => ClixLogger.debug('still alive after 3s'), 3000);
+
     const data = remoteMessage.data ?? {};
     try {
       await this.backgroundMessageHandler?.(data);
@@ -278,180 +230,212 @@ export class NotificationService {
         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
+   */
   private async handleForegroundMessage(
     remoteMessage: FirebaseMessagingTypes.RemoteMessage
   ): Promise<void> {
     ClixLogger.debug('Handling foreground message:', remoteMessage.messageId);
 
-    try {
-      const messageId = remoteMessage.messageId;
-      if (!messageId) {
-        ClixLogger.warn('No messageId found in foreground message');
-        return;
-      }
+    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;
+    }
 
-      if (this.processedMessageIds.has(messageId)) {
+    const data = remoteMessage.data ?? {};
+    try {
+      const result = await this.messageHandler?.(data);
+      if (result === false) {
         ClixLogger.debug(
-          'Message already processed, skipping duplicate:',
-          messageId
+          'Foreground message suppressed by user handler:',
+          remoteMessage.messageId
         );
         return;
       }
+    } catch (error) {
+      ClixLogger.error('Foreground message handler failed', error);
+    }
 
-      const data = remoteMessage.data ?? {};
+    try {
       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 (!clixPayload) {
+        ClixLogger.warn('No Clix payload found in background message');
+        return;
+      }
 
-        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(): Promise<NotificationSettings> {
-    const settings = await notifee.requestPermission({
-      alert: true,
-      badge: true,
-      sound: true,
-      provisional: false,
-      announcement: false,
-      carPlay: false,
-      criticalAlert: false,
+  /**
+   * iOS: background notification tap handler
+   */
+  private async handleNotificationOpenedApp(
+    remoteMessage: FirebaseMessagingTypes.RemoteMessage
+  ): Promise<void> {
+    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: boolean): Promise<void> {
-    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);
     }
-  }
 
-  private setupTokenRefreshListener(): void {
-    this.unsubscribeTokenRefresh = this.messagingService.onTokenRefresh(
-      async (token: string) => {
-        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
+      );
+    }
   }
 
-  private async checkInitialNotification(): Promise<void> {
+  /**
+   * iOS: app launched from a quit state via a notification
+   */
+  private async handleInitialNotification(): Promise<void> {
     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);
     }
   }
 
-  private async getAndUpdateToken(): Promise<void> {
-    try {
-      const token = await this.getCurrentToken();
-      if (token) {
-        await this.registerTokenWithServer(token);
+  /**
+   * Android: background notification tap handler
+   */
+  private async handleNotificationEvent(event: Event): Promise<void> {
+    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;
       }
-    } catch (error) {
-      ClixLogger.error('Failed to update push token', error);
+      case EventType.DISMISSED:
+        ClixLogger.debug('Notification dismissed');
+        break;
+      default:
+        ClixLogger.debug('Unhandled notification event type:', type);
     }
   }
 
-  private async getOrFetchToken(): Promise<string | null> {
-    if (this.tokenService) {
-      const savedToken = this.tokenService.getCurrentToken();
-      if (savedToken) return savedToken;
+  /**
+   * iOS & Android: foreground notification tap handler
+   */
+  private async handleForegroundNotificationEvent(event: Event): Promise<void> {
+    try {
+      await this.foregroundEventHandler?.(event);
+    } catch (error) {
+      ClixLogger.error('Foreground notification event handler failed', error);
     }
 
-    const token = await this.messagingService.getToken();
-
-    if (token) {
-      ClixLogger.debug('Got push token:', token.substring(0, 20) + '...');
-      this.tokenService?.saveToken(token);
-    }
-    return token;
+    await this.handleNotificationEvent(event);
   }
 
-  private async saveAndRegisterToken(token: string): Promise<void> {
-    if (this.tokenService) {
-      this.tokenService.saveToken(token);
-      ClixLogger.debug('New push token saved via TokenService');
+  private async trackPushReceivedEvent(
+    payload: ClixPushNotificationPayload
+  ): Promise<void> {
+    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);
   }
 
-  private async registerTokenWithServer(token: string): Promise<void> {
-    if (this.deviceService) {
-      await this.deviceService.upsertToken(token);
-      ClixLogger.debug('Push token registered with server');
+  private async trackPushTappedEvent(
+    payload: ClixPushNotificationPayload
+  ): Promise<void> {
+    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);
     }
   }
 
@@ -460,29 +444,23 @@ export class NotificationService {
     clixPayload: ClixPushNotificationPayload
   ): Promise<void> {
     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
       );
 
       await notifee.displayNotification(notificationConfig);
       ClixLogger.debug(
         'Notification displayed successfully:',
-        notificationContent.title
+        clixPayload.title
       );
     } catch (error) {
       ClixLogger.error('Failed to display notification', error);
@@ -501,16 +479,15 @@ export class NotificationService {
   private async createNotificationConfig(
     remoteMessage: FirebaseMessagingTypes.RemoteMessage,
     clixPayload: ClixPushNotificationPayload,
-    notificationContent: NotificationContent,
     channelId: string
   ) {
-    const imageUrl = notificationContent.imageUrl;
+    const imageUrl = clixPayload.imageUrl;
 
     const config: Notification &
       Required<Pick<Notification, 'android' | 'ios'>> = {
       id: remoteMessage.messageId || Date.now().toString(),
-      title: notificationContent.title,
-      body: notificationContent.body,
+      title: clixPayload.title,
+      body: clixPayload.body,
       data: remoteMessage.data ?? {},
       android: {
         channelId,
@@ -521,11 +498,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',
@@ -549,122 +525,6 @@ export class NotificationService {
     return config;
   }
 
-  private createNotificationActions(clixPayload: ClixPushNotificationPayload) {
-    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;
-  }
-
-  private isValidImageUrl(url: string): boolean {
-    return url.trim() !== '' && url.startsWith('http');
-  }
-
-  private extractNotificationContent(
-    fcmNotification: FirebaseMessagingTypes.Notification | null | undefined,
-    clixPayload: ClixPushNotificationPayload
-  ): NotificationContent {
-    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: string | undefined;
-    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,
-    };
-  }
-
-  private async handlePushReceived(data: Record<string, any>): Promise<void> {
-    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);
-    }
-  }
-
-  private async handlePushTapped(data: Record<string, any>): Promise<void> {
-    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);
-    }
-  }
-
-  private async handleNotificationTap(
-    data: Record<string, any>
-  ): Promise<void> {
-    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);
-    }
-  }
-
   private async handleUrlNavigation(data: Record<string, any>): Promise<void> {
     try {
       let url: string | undefined;
@@ -699,128 +559,55 @@ export class NotificationService {
     userInfo: Record<string, any>
   ): ClixPushNotificationPayload | null {
     try {
-      let payload: any = userInfo;
-      if (userInfo.clix) {
-        if (typeof userInfo.clix === 'object') {
-          payload = userInfo.clix;
-        } else if (typeof userInfo.clix === 'string') {
-          payload = JSON.parse(userInfo.clix);
-        }
-      }
-      const toCamel = (s: string) =>
-        s.replace(/_([a-z])/g, (g) => (g[1] ?? '').toUpperCase());
-      const result: any = {};
-      if (!payload) return null;
-      for (const key in payload) {
-        result[toCamel(key)] = payload[key];
+      let data = userInfo?.clix;
+      if (data == null) {
+        ClixLogger.debug("No 'clix' entry found in notification data");
+        return null;
       }
 
-      ClixLogger.debug('Parsed Clix payload result:', result);
-
-      if (!result.messageId) return null;
+      if (typeof data === 'string') {
+        try {
+          data = JSON.parse(data);
+        } catch (parseError) {
+          ClixLogger.error(
+            'Failed to parse Clix payload JSON string',
+            parseError
+          );
+          return null;
+        }
+      }
 
-      // Extract title and body into customProperties if they exist
-      const customProperties: Record<string, any> = {};
-      if (result.title) customProperties.title = result.title;
-      if (result.body) customProperties.body = result.body;
+      ClixLogger.debug('Parsing Clix payload from notification data:', data);
 
-      const finalResult = {
-        ...result,
-        customProperties:
-          Object.keys(customProperties).length > 0
-            ? customProperties
-            : undefined,
+      const payload: ClixPushNotificationPayload = {
+        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);
+      ClixLogger.debug('Constructed Clix payload:', payload);
 
-      return new ClixPushNotificationPayload(finalResult);
-    } catch (error) {
-      ClixLogger.error('Failed to parse Clix payload', error);
-      return null;
-    }
-  }
-
-  private async trackPushEvent(
-    eventType: string,
-    clixPayload: ClixPushNotificationPayload
-  ): Promise<void> {
-    const properties = this.extractTrackingProperties(clixPayload);
-    const messageId = clixPayload.messageId;
-    await this.eventService.trackEvent(eventType, properties, messageId);
-    ClixLogger.debug(`${eventType} tracked:`, messageId);
-  }
-
-  private extractTrackingProperties(
-    clixPayload: ClixPushNotificationPayload
-  ): Record<string, any> {
-    const properties: Record<string, any> = {};
-    if (clixPayload.messageId) properties.messageId = clixPayload.messageId;
-    if (clixPayload.campaignId) properties.campaignId = clixPayload.campaignId;
-    if (clixPayload.trackingId) properties.trackingId = clixPayload.trackingId;
-    return properties;
-  }
-
-  private async trackEventInBackground(
-    clixPayload: ClixPushNotificationPayload
-  ): Promise<void> {
-    const messageId = clixPayload.messageId;
-    if (!messageId) {
-      ClixLogger.warn('No messageId found in payload, skipping event tracking');
-      return;
-    }
-    try {
-      const configData =
-        this.storageService.get<Record<string, any>>('clix_config');
-      if (!configData) {
-        ClixLogger.error('No Clix config found in storage');
-        return;
+      if (!payload.messageId) {
+        ClixLogger.error('No messageId found in Clix payload');
+        return null;
       }
-      let deviceId = this.storageService.get<string>('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;
+      }
+      if (!payload.body) {
+        ClixLogger.error('No body 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'
-      );
+      return payload;
     } catch (error) {
-      ClixLogger.error('Error tracking event in background', error);
-    }
-  }
-
-  private async shouldDisplayForegroundNotification(
-    data: Record<string, any>
-  ): Promise<boolean> {
-    try {
-      const result = await this.messageHandler?.(data);
-      return result !== false;
-    } catch (error) {
-      ClixLogger.warn(
-        'Foreground message handler failed, displaying notification by default',
-        error
-      );
-      return true;
-    }
-  }
-
-  private async handleFcmTokenError(error: any): Promise<void> {
-    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;
     }
   }
 }