react-native-notify-sphere 1.0.0 → 1.2.0

package/lib/module/index.js

@@ -1,42 +1,124 @@
 "use strict";
 
 import messaging from '@react-native-firebase/messaging';
-import notifee, { AndroidImportance, AndroidStyle, EventType // Import EventType if available
-} from '@notifee/react-native';
+import notifee, { AndroidImportance, AndroidStyle, EventType } from '@notifee/react-native';
 import axios from 'axios';
+import AsyncStorage from '@react-native-async-storage/async-storage';
 import { PermissionsAndroid, Platform } from 'react-native';
-import DeviceInfo from "react-native-device-info";
-import * as RNLocalize from "react-native-localize";
+const STORAGE_KEY_TOKEN = '@notifysphere_fcm_token';
+const STORAGE_KEY_SUB_ID = '@notifysphere_subscription_id';
+const STORAGE_KEY_USER_HASH = '@notifysphere_user_hash';
+
+// ─── Type definitions ──────────────────────────────────────────────────────────
+
+/** Shape of a Firebase Cloud Messaging remote message */
+
+/** Shape of a Notifee notification object (returned from press events) */
+
+/** Normalised notification data delivered to the consumer callback */
+
+// ─── Internal logger ──────────────────────────────────────────────────────────
+
+let _debug = false;
+const log = (...args) => {
+  if (_debug) console.log('[NotifySphere]', ...args);
+};
+const warn = (...args) => {
+  if (_debug) console.warn('[NotifySphere]', ...args);
+};
+// Errors are always surfaced regardless of the debug flag
+const logError = (...args) => console.error('[NotifySphere]', ...args);
+
+// ─── Default endpoints ────────────────────────────────────────────────────────
+
+const DEFAULT_BASE_URL = 'https://api.notifysphere.in/client/';
+// const DEFAULT_BASE_URL = 'https://apinotify.dothejob.in';
+
+// ─── NotifySphere class ───────────────────────────────────────────────────────
+
 class NotifySphere {
   static callback = null;
+  static fcmToken = null;
+  static appId = null;
+  static subscriptionId = null;
+  static baseUrl = DEFAULT_BASE_URL;
+  static trackingUrl = '';
+  static deliveryUrl = '';
+  static apiKey = null;
+  static unsubscribers = [];
+  static initialized = false;
+  static createdChannels = new Set();
 
-  // ✅ Permission check remains fully here
+  // ─── Press tracking ──────────────────────────────────────────────────────
 
-  static async callbackOnpress(remoteMessage, status) {
-    console.log('remoteMessage413123', remoteMessage);
+  /**
+   * Tracks a notification press event and fires the consumer callback.
+   * Accepts both Firebase remote messages and Notifee notification objects.
+   */
+  static async callbackOnpress(notification, status) {
     try {
-      const data = JSON.stringify({
-        notifiction_id: remoteMessage?.data?.notification_id,
-        // 🔑 keep same spelling as backend expects
+      const notificationId = notification.data?.notification_id ?? notification.data?.notification_id;
+      const headers = {
+        'Content-Type': 'application/json'
+      };
+      if (NotifySphere.apiKey) {
+        headers['Authorization'] = `Bearer ${NotifySphere.apiKey}`;
+      }
+      const response = await axios.post(NotifySphere.trackingUrl, {
+        notification_id: notificationId,
+        subscription_id: NotifySphere.subscriptionId,
         onPressStatus: 1
+      }, {
+        headers,
+        maxBodyLength: 1024 * 50,
+        timeout: 10000
       });
-      const config = {
-        method: 'post',
-        maxBodyLength: Infinity,
-        url: 'https://notifysphere.dothejob.in:3008/onpress/handle',
-        headers: {
-          'Content-Type': 'application/json',
-          'Cookie': 'token=sYPT8POivlxfFSR54MWd3reaArvODMiIcM4KM39cqkXBLVu%2B8b1zV2csabU9byzo'
-        },
-        data
+      log('onPress tracking response:', response.data);
+      NotifySphere.sendCallback(notification, status);
+    } catch (err) {
+      logError('Error in callbackOnpress:', err);
+    }
+  }
+
+  // ─── Delivery confirmation ───────────────────────────────────────────────
+
+  /**
+   * Sends a delivery receipt to the server as soon as a notification arrives.
+   *
+   * This fires in three scenarios:
+   *  - Foreground  : app is open when the message arrives
+   *  - Background  : app is alive in the background (data-only FCM message)
+   *  - Terminated  : app is completely killed (data-only FCM message only —
+   *                  notification messages are shown by the OS without waking
+   *                  the app, so this cannot fire in that case)
+   */
+  static async callbackOnDelivery(remoteMessage) {
+    try {
+      const notificationId = remoteMessage.data?.notification_id;
+      const headers = {
+        'Content-Type': 'application/json'
       };
-      const response = await axios.request(config);
-      console.log('onPress API response:', response);
-      NotifySphere.sendCallback(remoteMessage, status);
-    } catch (error) {
-      console.error('Error in callbackOnpress:', error);
+      if (NotifySphere.apiKey) {
+        headers['Authorization'] = `Bearer ${NotifySphere.apiKey}`;
+      }
+      log('Sending delivery confirmation to:', NotifySphere.deliveryUrl);
+      const response = await axios.post(NotifySphere.deliveryUrl, {
+        notification_id: notificationId,
+        subscription_id: NotifySphere.subscriptionId,
+        onDeliveredStatus: 1
+      }, {
+        headers,
+        maxBodyLength: 1024 * 50,
+        timeout: 10000
+      });
+      log('Delivery confirmation response:', response.data);
+    } catch (err) {
+      logError('Error sending delivery confirmation:', err);
     }
   }
+
+  // ─── Permissions ─────────────────────────────────────────────────────────
+
   static async checkApplicationPermission() {
     try {
       if (Platform.OS === 'android' && Platform.Version >= 33) {
@@ -47,36 +129,112 @@ class NotifySphere {
         return authStatus === messaging.AuthorizationStatus.AUTHORIZED || authStatus === messaging.AuthorizationStatus.PROVISIONAL;
       }
       return true;
-    } catch (error) {
-      console.error('Error requesting notification permission:', error);
+    } catch (err) {
+      logError('Error requesting notification permission:', err);
       return false;
     }
   }
-  static async getDeviceInfo() {
-    return {
-      sdk: DeviceInfo.getApiLevel()?.toString(),
-      // e.g. "34"
-      device_model: DeviceInfo.getModel(),
-      // e.g. "iPhone 14" or "TECNO CK6"
-      device_os: DeviceInfo.getSystemName(),
-      // e.g. "Android" or "iOS"
-      device_version: DeviceInfo.getSystemVersion(),
-      // e.g. "15"
-      carrier: await DeviceInfo.getCarrier(),
-      // e.g. "airtel"
-      app_version: DeviceInfo.getVersion(),
-      // e.g. "1.0.2"
-      timezone_id: RNLocalize.getTimeZone() // e.g. "Asia/Kolkata"
+
+  // ─── User details fingerprint ─────────────────────────────────────────────
+
+  /**
+   * Builds a stable string fingerprint of all user-profile fields.
+   * Used to detect whether any detail has changed since the last registration,
+   * so the API is only called when something actually differs.
+   */
+  static buildUserHash(config) {
+    const fields = {
+      applicationUserId: config.applicationUserId,
+      type: config.type,
+      name: config.name ?? '',
+      lat: config.lat ?? '',
+      long: config.long ?? '',
+      city: config.city ?? '',
+      state: config.state ?? '',
+      email: config.email ?? '',
+      phone: config.phone ?? '',
+      // Stringify tags with sorted keys so order doesn't affect the hash
+      tags: config.tags ? JSON.stringify(Object.keys(config.tags).sort().reduce((acc, k) => {
+        acc[k] = config.tags[k];
+        return acc;
+      }, {})) : ''
     };
+    return JSON.stringify(fields);
   }
+
+  // ─── Initialize ──────────────────────────────────────────────────────────
+
+  /**
+   * Initialises the SDK and sets up notification listeners.
+   *
+   * Safe to call every time the app opens — it only hits the registration API
+   * when the FCM token OR any user detail (email, phone, location, tags, etc.)
+   * has changed since the last successful registration.
+   * Listeners are registered only once per process lifetime.
+   *
+   * Token changes are also handled automatically via `onTokenRefresh`.
+   */
   static async initialize(config) {
+    _debug = config.debug ?? false;
+    NotifySphere.appId = config.appId;
+    NotifySphere.baseUrl = NotifySphere.enforceHttps(config.baseUrl ?? DEFAULT_BASE_URL);
+    NotifySphere.trackingUrl = NotifySphere.enforceHttps(config.trackingUrl ?? `${NotifySphere.baseUrl}${config.appId}/onpress/handle`);
+    NotifySphere.deliveryUrl = NotifySphere.enforceHttps(config.deliveryUrl ?? `${NotifySphere.baseUrl}${config.appId}/delivery/confirm`);
+    NotifySphere.apiKey = config.apiKey ?? null;
     const hasPermission = await NotifySphere.checkApplicationPermission();
-    const devInfo = await NotifySphere.getDeviceInfo();
-    if (!hasPermission) return;
-    const fcmToken = await messaging().getToken();
-    console.log('fcmToken31232', fcmToken, config);
-    if (!config.appId) return;
-    let subscription_id = await axios.post(`https://notifysphere.dothejob.in:3008/apps/${config.appId}/users`, {
+    if (!hasPermission) {
+      warn('Notification permission not granted — aborting initialization');
+      return undefined;
+    }
+    try {
+      const fcmToken = await messaging().getToken();
+      NotifySphere.fcmToken = fcmToken;
+
+      // ── Restore cached subscription_id immediately so tracking calls
+      //    have it available even before the registration API responds.
+      const cachedSubId = await AsyncStorage.getItem(STORAGE_KEY_SUB_ID);
+      if (cachedSubId) {
+        NotifySphere.subscriptionId = cachedSubId;
+      }
+
+      // ── Only call the registration API when the FCM token OR any user
+      //    detail has changed. This avoids a redundant network call on every
+      //    app open while still syncing updates (email, phone, location, etc.)
+      const [cachedToken, cachedUserHash] = await Promise.all([AsyncStorage.getItem(STORAGE_KEY_TOKEN), AsyncStorage.getItem(STORAGE_KEY_USER_HASH)]);
+      const currentUserHash = NotifySphere.buildUserHash(config);
+      let subscriptionId = cachedSubId ?? undefined;
+      const tokenChanged = fcmToken !== cachedToken;
+      const userChanged = currentUserHash !== cachedUserHash;
+      if (tokenChanged || userChanged) {
+        if (tokenChanged) log('FCM token changed — re-registering device');
+        if (userChanged) log('User details changed — re-registering device');
+        subscriptionId = await NotifySphere.registerDevice(config, fcmToken, currentUserHash);
+      } else {
+        log('Token and user details unchanged — skipping registration API call');
+      }
+
+      // ── Channel and listeners are always set up (idempotent)
+      await NotifySphere.ensureChannel('channel_default', 'Default Channel', 'default');
+      if (!NotifySphere.initialized) {
+        NotifySphere.setupListeners();
+        // Watch for token refreshes (Firebase can rotate the token silently)
+        NotifySphere.watchTokenRefresh(config);
+        NotifySphere.initialized = true;
+      }
+      return subscriptionId;
+    } catch (err) {
+      logError('Error during initialization:', err);
+      return undefined;
+    }
+  }
+
+  /**
+   * Calls the registration API and persists the token, subscription_id, and
+   * user hash so future launches can detect what has changed.
+   * Extracted so it can also be called from the token-refresh watcher.
+   */
+  static async registerDevice(config, fcmToken, userHash) {
+    const res = await axios.post(`${NotifySphere.baseUrl}${config.appId}/users`, {
       applicationUserId: config.applicationUserId,
       token: fcmToken,
       type: config.type,
@@ -88,85 +246,252 @@ class NotifySphere {
         state: config.state,
         email: config.email,
         phone: config.phone,
-        tags: config.tags,
-        sdk: devInfo.sdk,
-        device_model: devInfo.device_model,
-        device_os: devInfo.device_os,
-        device_version: devInfo.device_version,
-        carrier: devInfo.carrier,
-        app_version: devInfo.app_version,
-        timezone_id: devInfo.timezone_id
+        tags: config.tags
       }
     }, {
       headers: {
-        'Content-Type': 'application/json'
+        'Content-Type': 'application/json',
+        ...(NotifySphere.apiKey ? {
+          Authorization: `Bearer ${NotifySphere.apiKey}`
+        } : {})
       },
-      maxBodyLength: Infinity
-    }).then(async res => {
-      console.log('res313132', res);
-      return res.data.subscription_id;
-    }).catch(err => {
-      console.log('err31232', err);
+      maxBodyLength: 1024 * 50,
+      timeout: 10000
     });
-    NotifySphere.setupListeners();
-    return subscription_id;
+    log('Device registration response:', res.data);
+    const subscriptionId = res.data?.subscription_id;
+    NotifySphere.subscriptionId = subscriptionId ?? null;
+
+    // Persist token, subscription_id, and user hash for future launch comparisons
+    const hash = userHash ?? NotifySphere.buildUserHash(config);
+    await Promise.all([AsyncStorage.setItem(STORAGE_KEY_TOKEN, fcmToken), AsyncStorage.setItem(STORAGE_KEY_USER_HASH, hash), subscriptionId ? AsyncStorage.setItem(STORAGE_KEY_SUB_ID, subscriptionId) : Promise.resolve()]);
+    return subscriptionId;
+  }
+
+  /**
+   * Listens for Firebase token refreshes and automatically re-registers
+   * the device when the token rotates, without requiring the consumer to
+   * call initialize() again.
+   */
+  static watchTokenRefresh(config) {
+    const unsubRefresh = messaging().onTokenRefresh(async newToken => {
+      log('FCM token refreshed — re-registering device');
+      NotifySphere.fcmToken = newToken;
+      try {
+        // User details haven't changed here, reuse the existing hash
+        const existingHash = (await AsyncStorage.getItem(STORAGE_KEY_USER_HASH)) ?? NotifySphere.buildUserHash(config);
+        await NotifySphere.registerDevice(config, newToken, existingHash);
+      } catch (err) {
+        logError('Error re-registering after token refresh:', err);
+      }
+    });
+    NotifySphere.unsubscribers.push(unsubRefresh);
+  }
+
+  // ─── Update tags ─────────────────────────────────────────────────────────
+
+  /**
+   * Updates user tags without re-registering the device.
+   * `appId` is optional here — it falls back to the value passed in `initialize`.
+   */
+  static async updateTags(params) {
+    const appId = params.appId ?? NotifySphere.appId;
+    if (!NotifySphere.fcmToken) {
+      warn('FCM token missing — cannot update tags');
+      return null;
+    }
+    if (!appId) {
+      warn('appId missing — cannot update tags');
+      return null;
+    }
+    try {
+      const res = await axios.post(`${NotifySphere.baseUrl}${appId}/users`, {
+        applicationUserId: params.applicationUserId,
+        token: NotifySphere.fcmToken,
+        type: params.type,
+        user: {
+          tags: params.tags
+        }
+      }, {
+        headers: {
+          'Content-Type': 'application/json'
+        },
+        maxBodyLength: 1024 * 50,
+        timeout: 10000
+      });
+      log('Tags update response:', res.data);
+      return res.data;
+    } catch (err) {
+      logError('Error updating tags:', err);
+      return null;
+    }
   }
+
+  // ─── Public callback setter ───────────────────────────────────────────────
+
+  /** Register a callback to receive notification events (received / opened / initial). */
   static onNotification(callback) {
     NotifySphere.callback = callback;
   }
+
+  // ─── Background handler ───────────────────────────────────────────────────
+
+  /**
+   * Registers Firebase and Notifee background handlers.
+   *
+   * **IMPORTANT:** Call this in your root `index.js` file, before
+   * `AppRegistry.registerComponent()`, so it is available when the app wakes
+   * in the background — or starts from a terminated state — to handle a
+   * notification.
+   *
+   * When the app is **terminated**, React Native only runs `index.js` (a
+   * headless JS task). Your app components and `initialize()` never execute,
+   * so any custom `deliveryUrl` / `apiKey` you passed to `initialize()` are
+   * not available. Pass them here instead so they are set before the handler
+   * fires.
+   *
+   * @example
+   * // index.js
+   * import { AppRegistry } from 'react-native';
+   * import NotifySphere from 'react-native-notify-sphere';
+   * import App from './App';
+   *
+   * NotifySphere.setBackgroundHandler({
+   *   deliveryUrl: 'https://your-server.com/ondelivery/handle', // optional
+   *   apiKey: 'your-api-key',                                   // optional
+   * });
+   * AppRegistry.registerComponent('MyApp', () => App);
+   */
+  static setBackgroundHandler(config) {
+    // Apply any config overrides immediately — before the handler fires —
+    // so they are in place even when the app starts from a terminated state.
+    if (config?.deliveryUrl) {
+      NotifySphere.deliveryUrl = NotifySphere.enforceHttps(config.deliveryUrl);
+    }
+    if (config?.apiKey) {
+      NotifySphere.apiKey = config.apiKey;
+    }
+    if (config?.subscriptionId) {
+      NotifySphere.subscriptionId = config.subscriptionId;
+    }
+    messaging().setBackgroundMessageHandler(async remoteMessage => {
+      const msg = remoteMessage;
+      // Run both in parallel — display and delivery receipt
+      await Promise.all([NotifySphere.displayLocalNotification(msg), NotifySphere.callbackOnDelivery(msg)]);
+    });
+    notifee.onBackgroundEvent(async ({
+      type,
+      detail
+    }) => {
+      log('Background notifee event, type:', type);
+      if (type === EventType.PRESS && detail.notification) {
+        await NotifySphere.callbackOnpress(detail.notification, 'press');
+      }
+    });
+  }
+
+  // ─── Cleanup ──────────────────────────────────────────────────────────────
+
+  /**
+   * Unsubscribes all active listeners and resets internal state.
+   * Call this when you want to stop receiving notifications (e.g. on logout).
+   */
+  static destroy() {
+    for (const unsub of NotifySphere.unsubscribers) {
+      unsub();
+    }
+    NotifySphere.unsubscribers = [];
+    NotifySphere.initialized = false;
+    log('NotifySphere destroyed — all listeners removed');
+  }
+
+  // ─── Private: listeners ───────────────────────────────────────────────────
+
   static setupListeners() {
-    messaging().onMessage(async remoteMessage => {
-      await NotifySphere.displayLocalNotification(remoteMessage);
+    // Foreground messages — display, send delivery receipt, and fire callback
+    const unsubMessage = messaging().onMessage(async remoteMessage => {
+      const msg = remoteMessage;
+      log('Foreground message received:', msg);
+      // Display and delivery receipt run in parallel for speed
+
+      await Promise.all([NotifySphere.displayLocalNotification(msg), NotifySphere.callbackOnDelivery(msg)]);
+      NotifySphere.sendCallback(msg, 'received');
     });
-    messaging().onNotificationOpenedApp(async remoteMessage => {
-      console.log('data34234', remoteMessage);
-      NotifySphere.callbackOnpress(remoteMessage, 'opened');
+
+    // App brought from background via notification tap
+    const unsubOpened = messaging().onNotificationOpenedApp(async remoteMessage => {
+      log('App opened from background via notification:', remoteMessage.messageId);
+      await NotifySphere.callbackOnpress(remoteMessage, 'opened');
     });
+
+    // App launched from a quit state via notification tap
     messaging().getInitialNotification().then(remoteMessage => {
       if (remoteMessage) {
         NotifySphere.callbackOnpress(remoteMessage, 'initial');
       }
-    });
-    notifee.onForegroundEvent(({
+    }).catch(err => logError('getInitialNotification error:', err));
+
+    // Notifee foreground press events (covers in-app notification taps)
+    const unsubForeground = notifee.onForegroundEvent(({
       type,
       detail
     }) => {
-      if (type === EventType.PRESS) {
-        console.log('detail323213', detail);
+      if (type === EventType.PRESS && detail.notification) {
         NotifySphere.callbackOnpress(detail.notification, 'opened');
       }
     });
-    notifee.onBackgroundEvent(async ({
-      type,
-      detail
-    }) => {
-      console.log('detail323213111111', type, detail);
-      if (type === EventType.PRESS) {
-        console.log('detail323213', detail);
-        NotifySphere.callbackOnpress(detail.notification, 'press');
-      }
-    });
+    NotifySphere.unsubscribers.push(unsubMessage, unsubOpened, unsubForeground);
   }
+
+  // ─── Private: channel management ─────────────────────────────────────────
+
+  /**
+   * Creates a notification channel if it hasn't been created yet this session.
+   * Notifee handles idempotency across app restarts; this in-memory guard
+   * prevents redundant async calls within the same session.
+   */
+  static async ensureChannel(id, name, sound) {
+    if (NotifySphere.createdChannels.has(id)) return;
+    const soundName = sound.replace(/\..+$/, '');
+    const channelDef = {
+      id,
+      name,
+      importance: AndroidImportance.HIGH,
+      sound: soundName !== 'default' ? soundName : undefined,
+      lights: true,
+      lightColor: '#0000FF',
+      vibration: true
+    };
+    await notifee.createChannel(channelDef);
+    NotifySphere.createdChannels.add(id);
+    log('Android channel created/verified:', id);
+  }
+
+  // ─── Private: display notification ───────────────────────────────────────
+
   static async displayLocalNotification(remoteMessage) {
+    // Use || so empty strings fall back just like null/undefined
     const soundRaw = remoteMessage.data?.sound || 'default';
-    const androidChannelId = `channel_${soundRaw}`;
-    const androidSoundName = soundRaw.replace(/\..+$/, '');
-    console.log('remoteMessage1312', remoteMessage);
-    await notifee.createChannel({
-      id: androidChannelId,
-      name: `Channel ${androidSoundName}`,
-      importance: AndroidImportance.HIGH,
-      sound: androidSoundName !== 'default' ? androidSoundName : undefined
-    });
-    const image = remoteMessage?.data?.fcm_options?.image || remoteMessage.notification?.android?.imageUrl || remoteMessage.notification?.imageUrl || remoteMessage.notification?.ios?.attachments?.[0]?.url;
+    const soundName = soundRaw.replace(/\..+$/, '');
+    const channelId = `channel_${soundName}`;
+    await NotifySphere.ensureChannel(channelId, `Channel ${soundName}`, soundRaw);
+
+    // Resolve image — empty string treated same as missing
+    const image = remoteMessage.data?.imageUrl || remoteMessage.notification?.android?.imageUrl || remoteMessage.notification?.imageUrl || remoteMessage.notification?.ios?.attachments?.[0]?.url || undefined;
+
+    // Resolve title/body — empty string treated as missing
+    const title = remoteMessage.data?.title || remoteMessage.notification?.title || undefined;
+    const body = remoteMessage.data?.body || remoteMessage.notification?.body || undefined;
+
+    // smallIcon falls back to 'ic_stat_onesignal_default' if empty/missing
+    // largeIcon is removed entirely
+    const smallIcon = NotifySphere.resolveIcon(remoteMessage.data?.smallIcon) ?? 'ic_stat_onesignal_default';
     await notifee.displayNotification({
-      title: remoteMessage.notification?.title,
-      body: remoteMessage.notification?.body,
+      title,
+      body,
       android: {
-        channelId: androidChannelId,
-        importance: AndroidImportance.HIGH,
-        sound: androidSoundName !== 'default' ? androidSoundName : undefined,
-        largeIcon: image,
+        channelId,
+        smallIcon,
         style: image ? {
           type: AndroidStyle.BIGPICTURE,
           picture: image
@@ -174,11 +499,9 @@ class NotifySphere {
       },
       ios: {
         sound: soundRaw,
-        // must be a bundled sound file or "default"
         attachments: image ? [{
           url: image
         }] : undefined,
-        // ✅ this is correct
         foregroundPresentationOptions: {
           alert: true,
           badge: true,
@@ -188,15 +511,66 @@ class NotifySphere {
       data: remoteMessage.data
     });
   }
-  static sendCallback(remoteMessage, type) {
+
+  /**
+   * Returns the icon string if it is a real, usable value.
+   * Treats empty string (""), "ic_stat_onesignal_default", and
+   * any other placeholder-like value as absent (returns undefined).
+   */
+  static resolveIcon(value) {
+    if (!value) return undefined; // catches "" / null / undefined
+    return value;
+  }
+
+  /**
+   * Rejects plain HTTP URLs to prevent user data (FCM token, email, phone,
+   * location) being sent over an unencrypted connection.
+   */
+  static enforceHttps(url) {
+    if (url.startsWith('http://')) {
+      logError(`Insecure URL rejected: "${url}". NotifySphere only allows HTTPS endpoints.`);
+      throw new Error(`NotifySphere: insecure HTTP URL is not allowed — use HTTPS instead.`);
+    }
+    return url;
+  }
+
+  // ─── Private: fire consumer callback ─────────────────────────────────────
+
+  /**
+   * Normalises both Firebase remote messages and Notifee notification objects
+   * into the common NotificationData shape and fires the consumer callback.
+   */
+  static sendCallback(notification, type) {
     if (!NotifySphere.callback) return;
-    const image = remoteMessage.notification?.android?.imageUrl || remoteMessage.notification?.imageUrl || remoteMessage.notification?.ios?.attachments?.[0]?.url;
+
+    // Detect shape: Firebase messages have a `notification` or `messageId` field
+    const isFirebase = 'notification' in notification || 'messageId' in notification;
+    let title;
+    let body;
+    let data;
+    let image;
+    let sound;
+    if (isFirebase) {
+      const msg = notification;
+      title = msg.notification?.title ?? msg.data?.title;
+      body = msg.notification?.body ?? msg.data?.body;
+      data = msg.data;
+      image = msg.notification?.android?.imageUrl || msg.notification?.imageUrl || msg.notification?.ios?.attachments?.[0]?.url || msg.data?.imageUrl;
+      sound = msg.data?.sound;
+    } else {
+      const notif = notification;
+      title = notif.title;
+      body = notif.body;
+      data = notif.data;
+      image = notif.data?.imageUrl;
+      sound = notif.data?.sound;
+    }
     NotifySphere.callback({
-      title: remoteMessage.notification?.title,
-      body: remoteMessage.notification?.body,
-      data: remoteMessage.data,
+      title,
+      body,
+      data,
       image,
-      sound: remoteMessage.data?.sound
+      sound
     }, type);
   }
 }