@inngageregistry/inngage-react 4.0.1 → 4.1.0

package/dist/Inngage.d.ts

@@ -14,15 +14,21 @@ interface SendEventProps {
     conversionNotId?: string;
     eventValues?: any;
 }
+interface AddUserDataProps {
+    identifier?: string;
+    customFields?: Record<string, any>;
+    email?: string;
+    phoneNumber?: string;
+}
 declare class Inngage {
     private static instance;
     private apiService;
     constructor();
     static getInstance(): Inngage;
-    static notificationListener(firebaseListenCallback?: (data: Record<string, string>) => void, imageNotification?: string, colorNotification?: string): void;
+    static notificationListener(firebaseListenCallback?: (data: Record<string, string>) => void, imageNotification?: string, colorNotification?: string, blockDeepLink?: boolean): void;
     static subscribe({ appToken, friendlyIdentifier, customFields, phoneNumber, email, }: SubscriptionProps): Promise<Response>;
     static sendEvent({ eventName, conversionEvent, conversionValue, conversionNotId, eventValues, }: SendEventProps): Promise<Response>;
-    static addUserData(customFields: any): Promise<any>;
+    static addUserData({ identifier, customFields, email, phoneNumber }: AddUserDataProps): Promise<Response>;
     static setDebugMode(value: boolean): void;
 }
 export default Inngage;

package/dist/Inngage.js

@@ -83,9 +83,9 @@ class Inngage {
         }
         return Inngage.instance;
     }
-    static notificationListener(firebaseListenCallback, imageNotification, colorNotification) {
+    static notificationListener(firebaseListenCallback, imageNotification, colorNotification, blockDeepLink) {
         try {
-            InngageNotificationMessage(firebaseListenCallback, imageNotification, colorNotification);
+            InngageNotificationMessage(firebaseListenCallback, imageNotification, colorNotification, { blockDeepLink });
         }
         catch (e) {
             console.log(e);
@@ -106,22 +106,22 @@ class Inngage {
         const subscription = {
             registerSubscriberRequest: {
                 app_token: appToken,
-                identifier: friendlyIdentifier,
+                identifier: friendlyIdentifier ?? uuid,
                 registration: respToken,
                 platform: DeviceInfo.getSystemName(),
                 sdk: DeviceInfo.getBuildNumber(),
-                deviceModel: DeviceInfo.getModel(),
-                deviceManufacturer,
-                osLocale,
-                osLanguage,
+                device_model: DeviceInfo.getModel(),
+                device_manufacturer: deviceManufacturer,
+                os_locale: osLocale,
+                os_language: osLanguage,
                 os_version: DeviceInfo.getReadableVersion(),
                 app_version: DeviceInfo.getBuildNumber(),
-                appInstalledIn,
-                appUpdatedIn,
+                app_installed_in: appInstalledIn,
+                app_updated_in: appUpdatedIn,
                 uuid,
-                phone_Number: phoneNumber,
-                email: email,
-                customFields: customFields,
+                phone_Number: phoneNumber ?? '',
+                email: email ?? '',
+                custom_field: customFields ?? {},
             },
         };
         return inngage.apiService.subscribe(subscription);
@@ -143,13 +143,15 @@ class Inngage {
         };
         return inngage.apiService.sendEvent(request);
     }
-    static async addUserData(customFields) {
+    static async addUserData({ identifier, customFields, email, phoneNumber }) {
         const inngage = Inngage.getInstance();
         const request = {
             fieldsRequest: {
                 appToken: InngageProperties.appToken,
-                identifier: InngageProperties.identifier,
-                customField: customFields,
+                identifier: identifier,
+                custom_field: customFields,
+                email: email,
+                phone_number: phoneNumber
             },
         };
         return inngage.apiService.addUserData(request);

package/dist/firebase/notifications_config.d.ts

@@ -1,3 +1,3 @@
 export declare const ANDROID_CHANNEL_ID = "inngage_default_channel";
-export declare const messagingInstance: import("@react-native-firebase/messaging").FirebaseMessagingTypes.Module;
+export declare const messagingInstance: import("@react-native-firebase/messaging").Messaging;
 export declare const ensureAndroidChannel: () => Promise<void>;

package/dist/firebase/notifications_config.js

@@ -18,9 +18,6 @@ export const ensureAndroidChannel = async () => {
             id: ANDROID_CHANNEL_ID,
             name: 'Inngage Notifications',
             importance: AndroidImportance.HIGH,
-            // você pode ajustar sound, vibration, lights etc. se quiser:
-            // sound: 'default',
-            // vibration: true,
         });
         androidChannelCreated = true;
     }

package/dist/firebase/notifications_listener.d.ts

@@ -1,8 +1,12 @@
+type ListenCallback = (data: Record<string, string>) => void;
 export declare const messagingHeadlessTask: () => void;
 export declare const useInAppHandler: () => {
     showInApp: boolean;
     setShowInApp: import("react").Dispatch<import("react").SetStateAction<boolean>>;
 };
-export declare const InngageNotificationMessage: (firebaseListenCallback?: (data: Record<string, string>) => void, imageNotification?: string, colorNotification?: string) => {
+export declare const InngageNotificationMessage: (firebaseListenCallback?: ListenCallback, imageNotification?: string, colorNotification?: string, options?: {
+    blockDeepLink?: boolean;
+}) => {
     unsubscribe: () => void;
 };
+export {};

package/dist/firebase/notifications_listener.js

@@ -3,46 +3,48 @@ import { AppState, Linking, Platform } from 'react-native';
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import { setBackgroundMessageHandler, onMessage, onNotificationOpenedApp, getInitialNotification, } from '@react-native-firebase/messaging';
 import InAppBrowser from 'react-native-inappbrowser-reborn';
+import notifee, { EventType } from '@notifee/react-native';
 import { InngageProperties } from '../models/inngage_properties';
 import * as ApiService from '../services/api_services';
-import notifee, { EventType } from '@notifee/react-native';
 import { toStringValue } from '../utils';
 import { ANDROID_CHANNEL_ID, messagingInstance, ensureAndroidChannel, } from './notifications_config';
-export const messagingHeadlessTask = () => {
-    return setBackgroundMessageHandler(messagingInstance, async (remoteMessage) => {
-        if (InngageProperties.getDebugMode()) {
-            console.log('INNGAGE BACKGROUND AND CLOSED DATA: ', remoteMessage);
-        }
-        const additional = remoteMessage?.data?.additional_data;
-        if (additional != null) {
-            await AsyncStorage.setItem('inapp', toStringValue(additional));
-        }
-        return Promise.resolve();
-    });
-};
-export const useInAppHandler = () => {
-    const [showInApp, setShowInApp] = useState(false);
-    useEffect(() => {
-        const checkInAppData = async () => {
-            const inAppData = await AsyncStorage.getItem('inapp');
-            if (inAppData)
-                setShowInApp(true);
-        };
-        checkInAppData();
-        const subscription = AppState.addEventListener('change', (next) => {
-            if (next === 'active')
-                checkInAppData();
-        });
-        return () => subscription.remove();
-    }, []);
-    return { showInApp, setShowInApp };
-};
+const KEY_INAPP = 'inapp';
+const KEY_PENDING_REMOTE_MESSAGES = 'PENDING_REMOTE_MESSAGES_QUEUE';
+const KEY_LAST_DELIVERED_MESSAGE_ID = 'LAST_DELIVERED_MESSAGE_ID';
+const KEY_LAST_CLICK_HANDLED_MESSAGE_ID = 'LAST_CLICK_HANDLED_MESSAGE_ID';
+const KEY_LAST_INITIAL_HANDLED_ID = 'LAST_INITIAL_HANDLED_ID';
+const KEY_LAST_CALLBACK_DELIVERED_ID = 'LAST_CALLBACK_DELIVERED_ID';
+let currentBlockDeepLink = false;
 let currentFirebaseListenCallback;
 let currentImageNotification;
 let currentColorNotification;
 let foregroundUnsubscribe = null;
 let openedAppUnsubscribe = null;
 let initialNotificationHandled = false;
+let notifeeForegroundUnsubscribe = null;
+let appStateSubscription = null;
+const safeJsonParse = (raw) => {
+    if (!raw)
+        return null;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+};
+const deliverToCallbackOnce = async (msg) => {
+    if (!currentFirebaseListenCallback)
+        return;
+    const id = msg.messageId ?? msg.data?.notId ?? '';
+    if (id) {
+        const last = await AsyncStorage.getItem(KEY_LAST_CALLBACK_DELIVERED_ID);
+        if (last === id)
+            return;
+        await AsyncStorage.setItem(KEY_LAST_CALLBACK_DELIVERED_ID, id);
+    }
+    currentFirebaseListenCallback((msg.data ?? {}));
+};
 const normalizeAndroidImageResource = (res) => {
     if (!res)
         return undefined;
@@ -54,6 +56,53 @@ const normalizeAndroidImageResource = (res) => {
     }
     return res;
 };
+const enqueuePendingMessage = async (msg, maxItems = 20) => {
+    try {
+        const raw = await AsyncStorage.getItem(KEY_PENDING_REMOTE_MESSAGES);
+        const queue = safeJsonParse(raw) ?? [];
+        queue.push(msg);
+        const trimmed = queue.length > maxItems ? queue.slice(queue.length - maxItems) : queue;
+        await AsyncStorage.setItem(KEY_PENDING_REMOTE_MESSAGES, JSON.stringify(trimmed));
+    }
+    catch (e) {
+        console.error(e);
+    }
+};
+const dequeueAllPendingMessages = async () => {
+    try {
+        const raw = await AsyncStorage.getItem(KEY_PENDING_REMOTE_MESSAGES);
+        const queue = safeJsonParse(raw) ?? [];
+        if (queue.length > 0) {
+            await AsyncStorage.removeItem(KEY_PENDING_REMOTE_MESSAGES);
+        }
+        return queue;
+    }
+    catch (e) {
+        console.error(e);
+        return [];
+    }
+};
+const flushPendingQueue = async () => {
+    try {
+        if (!currentFirebaseListenCallback)
+            return;
+        const queue = await dequeueAllPendingMessages();
+        if (queue.length === 0)
+            return;
+        const lastDeliveredId = await AsyncStorage.getItem(KEY_LAST_DELIVERED_MESSAGE_ID);
+        for (const item of queue) {
+            if (item.messageId && item.messageId === lastDeliveredId)
+                continue;
+            if (item.messageId) {
+                await AsyncStorage.setItem(KEY_LAST_DELIVERED_MESSAGE_ID, item.messageId);
+            }
+            await deliverToCallbackOnce({ messageId: item.messageId, data: item.data });
+        }
+    }
+    catch (e) {
+        console.error(e);
+    }
+};
 const handleNotification = async (remoteMessage) => {
     const data = remoteMessage?.data ?? {};
     const notId = data?.notId;
@@ -67,55 +116,111 @@ const handleNotification = async (remoteMessage) => {
     const url = data?.url;
     const type = data?.type;
     if (url) {
-        if (type === 'inapp') {
-            try {
-                if (await InAppBrowser.isAvailable()) {
-                    await InAppBrowser.open(url, {
-                        dismissButtonStyle: 'close',
-                        preferredBarTintColor: '#453AA4',
-                        preferredControlTintColor: 'white',
-                        enableDefaultShare: true,
-                        enableBarCollapsing: true,
-                    });
+        if (currentBlockDeepLink) {
+            if (InngageProperties.getDebugMode()) {
+                console.log('[SDK] blockDeepLink ativo; ignorando abertura de url:', { url, type });
+            }
+        }
+        else {
+            if (type === 'inapp') {
+                try {
+                    if (await InAppBrowser.isAvailable()) {
+                        await InAppBrowser.open(url, {
+                            dismissButtonStyle: 'close',
+                            preferredBarTintColor: '#453AA4',
+                            preferredControlTintColor: 'white',
+                            enableDefaultShare: true,
+                            enableBarCollapsing: true,
+                        });
+                    }
+                    else {
+                        Linking.openURL(url);
+                    }
                 }
-                else {
-                    Linking.openURL(url);
+                catch (error) {
+                    console.error(error);
                 }
             }
-            catch (error) {
-                console.error(error);
+            else if (type === 'deep') {
+                Linking.openURL(url).catch((err) => console.error('Erro ao abrir o link:', err));
             }
         }
-        else if (type === 'deep') {
-            Linking.openURL(url).catch((err) => console.error('Erro ao abrir o link:', err));
-        }
     }
     await ApiService.sendNotification(request);
 };
 const handleUniqueRemoteMessage = async (remoteMessage) => {
     try {
-        const lastId = await AsyncStorage.getItem('LAST_REMOTE_MESSAGE_ID');
         const newId = remoteMessage?.messageId;
-        if (newId && lastId !== newId) {
-            await AsyncStorage.setItem('LAST_REMOTE_MESSAGE_ID', newId);
+        const lastClickId = await AsyncStorage.getItem(KEY_LAST_CLICK_HANDLED_MESSAGE_ID);
+        await deliverToCallbackOnce({ messageId: remoteMessage.messageId, data: remoteMessage.data });
+        if (!newId) {
             await handleNotification(remoteMessage);
+            return;
         }
+        if (lastClickId === newId)
+            return;
+        await AsyncStorage.setItem(KEY_LAST_CLICK_HANDLED_MESSAGE_ID, newId);
+        await handleNotification(remoteMessage);
     }
     catch (e) {
         console.error(e);
     }
 };
-export const InngageNotificationMessage = (firebaseListenCallback, imageNotification, colorNotification) => {
+export const messagingHeadlessTask = () => {
+    return setBackgroundMessageHandler(messagingInstance, async (remoteMessage) => {
+        if (InngageProperties.getDebugMode()) {
+            console.log('INNGAGE BACKGROUND AND CLOSED DATA: ', remoteMessage);
+        }
+        const additional = remoteMessage?.data?.additional_data;
+        if (additional != null) {
+            await AsyncStorage.setItem(KEY_INAPP, toStringValue(additional));
+        }
+        const data = (remoteMessage?.data ?? {});
+        await enqueuePendingMessage({
+            messageId: remoteMessage?.messageId,
+            data,
+            ts: Date.now(),
+        });
+        return Promise.resolve();
+    });
+};
+export const useInAppHandler = () => {
+    const [showInApp, setShowInApp] = useState(false);
+    useEffect(() => {
+        const checkInAppData = async () => {
+            const inAppData = await AsyncStorage.getItem(KEY_INAPP);
+            if (inAppData)
+                setShowInApp(true);
+        };
+        checkInAppData();
+        const subscription = AppState.addEventListener('change', (next) => {
+            if (next === 'active')
+                checkInAppData();
+        });
+        return () => subscription.remove();
+    }, []);
+    return { showInApp, setShowInApp };
+};
+export const InngageNotificationMessage = (firebaseListenCallback, imageNotification, colorNotification, options) => {
     currentFirebaseListenCallback = firebaseListenCallback;
     currentImageNotification = imageNotification;
     currentColorNotification = colorNotification;
+    currentBlockDeepLink = options?.blockDeepLink ?? false;
     ensureAndroidChannel().catch(() => { });
+    if (!appStateSubscription) {
+        appStateSubscription = AppState.addEventListener('change', (next) => {
+            if (next === 'active') {
+                flushPendingQueue().catch(() => { });
+            }
+        });
+    }
     if (!foregroundUnsubscribe) {
         const handleMessage = async (remoteMessage) => {
             const notificationData = remoteMessage.data ?? {};
             if (notificationData.additional_data != null) {
-                await AsyncStorage.setItem('inapp', toStringValue(notificationData.additional_data));
+                await AsyncStorage.setItem(KEY_INAPP, toStringValue(notificationData.additional_data));
             }
+            currentFirebaseListenCallback?.(notificationData);
             if (notifee) {
                 const title = remoteMessage.notification?.title ??
                     notificationData.title ??
@@ -145,39 +250,35 @@ export const InngageNotificationMessage = (firebaseListenCallback, imageNotifica
                         }
                         : undefined,
                 });
-                return notifee.onForegroundEvent(({ type, detail }) => {
-                    switch (type) {
-                        case EventType.DISMISSED:
-                            if (InngageProperties.getDebugMode()) {
-                                console.log('User dismissed notification', detail.notification);
-                            }
-                            break;
-                        case EventType.PRESS:
-                            handleNotification(remoteMessage);
-                            break;
-                    }
-                });
-            }
-            else {
-                if (InngageProperties.getDebugMode()) {
-                    console.log('[SDK] Notifee não instalado; mensagem em foreground: ', remoteMessage);
+                if (!notifeeForegroundUnsubscribe) {
+                    notifeeForegroundUnsubscribe = notifee.onForegroundEvent(({ type, detail }) => {
+                        switch (type) {
+                            case EventType.DISMISSED:
+                                if (InngageProperties.getDebugMode()) {
+                                    console.log('User dismissed notification', detail.notification);
+                                }
+                                break;
+                            case EventType.PRESS:
+                                handleNotification(remoteMessage);
+                                break;
+                        }
+                    });
                 }
             }
+            else if (InngageProperties.getDebugMode()) {
+                console.log('[SDK] Notifee não instalado; mensagem em foreground: ', remoteMessage);
+            }
             if (InngageProperties.getDebugMode()) {
                 console.log('Remote message received in foreground: ', remoteMessage);
             }
-            if (currentFirebaseListenCallback && remoteMessage) {
-                currentFirebaseListenCallback(notificationData);
-            }
         };
         foregroundUnsubscribe = onMessage(messagingInstance, handleMessage);
     }
     if (!openedAppUnsubscribe) {
-        openedAppUnsubscribe = onNotificationOpenedApp(messagingInstance, (remoteMessage) => {
+        openedAppUnsubscribe = onNotificationOpenedApp(messagingInstance, async (remoteMessage) => {
             if (!remoteMessage)
                 return;
-            currentFirebaseListenCallback?.(remoteMessage.data ?? {});
-            handleNotification(remoteMessage);
+            await handleUniqueRemoteMessage(remoteMessage);
         });
     }
     if (!initialNotificationHandled) {
@@ -186,6 +287,15 @@ export const InngageNotificationMessage = (firebaseListenCallback, imageNotifica
             .then(async (value) => {
             if (!value)
                 return;
+            const id = value.messageId ??
+                value.data?.notId ??
+                '';
+            if (id) {
+                const last = await AsyncStorage.getItem(KEY_LAST_INITIAL_HANDLED_ID);
+                if (last === id)
+                    return;
+                await AsyncStorage.setItem(KEY_LAST_INITIAL_HANDLED_ID, id);
+            }
             await handleUniqueRemoteMessage(value);
         })
             .catch((e) => console.error(e));
@@ -194,8 +304,12 @@ export const InngageNotificationMessage = (firebaseListenCallback, imageNotifica
         unsubscribe: () => {
             foregroundUnsubscribe?.();
             openedAppUnsubscribe?.();
+            notifeeForegroundUnsubscribe?.();
+            appStateSubscription?.remove();
             foregroundUnsubscribe = null;
             openedAppUnsubscribe = null;
+            notifeeForegroundUnsubscribe = null;
+            appStateSubscription = null;
             initialNotificationHandled = false;
         },
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inngageregistry/inngage-react",
-  "version": "4.0.1",
+  "version": "4.1.0",
   "description": "Inngage Plugin for React Native applications for marketing campaign optimization using Push Notification.",
   "author": "Inngage Developer",
   "license": "ISC",