@inngageregistry/inngage-react 4.0.0 → 4.0.2

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?: any): void;
+    static notificationListener(firebaseListenCallback?: (data: Record<string, string>) => void, imageNotification?: string, colorNotification?: string): 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

@@ -18,12 +18,16 @@ const getFirebaseAccess = async () => {
 };
 const handleNotificationsPermission = async () => {
     const options = ['alert', 'badge', 'sound'];
+    const isAndroid = Platform.OS === 'android';
     const apiLevel = Platform.OS === 'android' ? await DeviceInfo.getApiLevel() : 0;
     let permissionGranted = false;
-    if (Platform.OS === 'android') {
+    if (isAndroid) {
         if (apiLevel >= API_LEVEL_33) {
             const result = await RNPermissions.requestNotifications(options);
             permissionGranted = result.status === RESULTS.GRANTED;
+            if (!permissionGranted) {
+                console.log('[INNGAGE] Notification permission denied by user on Android (API >= 33)');
+            }
         }
         else {
             permissionGranted = true;
@@ -34,32 +38,40 @@ const handleNotificationsPermission = async () => {
         permissionGranted =
             status === AuthorizationStatus.AUTHORIZED ||
                 status === AuthorizationStatus.PROVISIONAL;
+        if (!permissionGranted) {
+            console.log('[INNGAGE] Notification permission denied by user on iOS');
+        }
         if (notifee) {
             try {
                 await notifee.requestPermission();
             }
-            catch { }
+            catch {
+                // silenciosamente ignora erro do notifee
+            }
         }
     }
-    if (permissionGranted) {
-        return getFirebaseToken();
+    if (!permissionGranted) {
+        return null;
     }
-    throw new Error('Notification permission not granted');
+    return getFirebaseToken();
 };
 const getFirebaseToken = async () => {
     let fcmToken = await AsyncStorage.getItem('fcmToken');
-    if (!fcmToken) {
-        const isRegistered = (isDeviceRegisteredForRemoteMessages(messagingInstance) ?? false);
-        if (!isRegistered && typeof registerDeviceForRemoteMessages === 'function') {
-            await registerDeviceForRemoteMessages(messagingInstance);
-        }
-        const newFcmToken = typeof getFcmTokenFromMessaging(messagingInstance) === 'function' ? await getFcmTokenFromMessaging(messagingInstance) : null;
-        if (newFcmToken) {
-            await AsyncStorage.setItem('fcmToken', newFcmToken);
-            return newFcmToken;
-        }
+    if (fcmToken) {
+        return fcmToken;
     }
-    return fcmToken || null;
+    const isRegistered = isDeviceRegisteredForRemoteMessages(messagingInstance) ?? false;
+    if (!isRegistered) {
+        await registerDeviceForRemoteMessages(messagingInstance);
+    }
+    const newFcmToken = (await getFcmTokenFromMessaging(messagingInstance)) ?? null;
+    if (!newFcmToken) {
+        console.log('[INNGAGE] Failed to obtain FCM token');
+        return null;
+    }
+    await AsyncStorage.setItem('fcmToken', newFcmToken);
+    console.log('[INNGAGE] FCM token obtained:', newFcmToken);
+    return newFcmToken;
 };
 class Inngage {
     constructor() {
@@ -71,9 +83,9 @@ class Inngage {
         }
         return Inngage.instance;
     }
-    static notificationListener(firebaseListenCallback) {
+    static notificationListener(firebaseListenCallback, imageNotification, colorNotification) {
         try {
-            InngageNotificationMessage(firebaseListenCallback);
+            InngageNotificationMessage(firebaseListenCallback, imageNotification, colorNotification);
         }
         catch (e) {
             console.log(e);
@@ -94,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);
@@ -131,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

@@ -0,0 +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 ensureAndroidChannel: () => Promise<void>;

package/dist/firebase/notifications_config.js

@@ -0,0 +1,30 @@
+import { Platform } from 'react-native';
+import { getApp } from '@react-native-firebase/app';
+import { getMessaging } from '@react-native-firebase/messaging';
+import notifee, { AndroidImportance } from '@notifee/react-native';
+export const ANDROID_CHANNEL_ID = 'inngage_default_channel';
+const app = getApp();
+export const messagingInstance = getMessaging(app);
+let androidChannelCreated = false;
+export const ensureAndroidChannel = async () => {
+    if (Platform.OS !== 'android') {
+        return;
+    }
+    if (androidChannelCreated) {
+        return;
+    }
+    try {
+        await notifee.createChannel({
+            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;
+    }
+    catch (error) {
+        console.error('[Inngage SDK] Erro ao criar canal do Notifee:', error);
+    }
+};

package/dist/firebase/notifications_listener.d.ts

@@ -3,4 +3,6 @@ export declare const useInAppHandler: () => {
     showInApp: boolean;
     setShowInApp: import("react").Dispatch<import("react").SetStateAction<boolean>>;
 };
-export declare const InngageNotificationMessage: (firebaseListenCallback?: (data: Record<string, string>) => void) => void;
+export declare const InngageNotificationMessage: (firebaseListenCallback?: (data: Record<string, string>) => void, imageNotification?: string, colorNotification?: string) => {
+    unsubscribe: () => void;
+};

package/dist/firebase/notifications_listener.js

@@ -1,21 +1,13 @@
 import { useEffect, useState } from 'react';
 import { AppState, Linking, Platform } from 'react-native';
 import AsyncStorage from '@react-native-async-storage/async-storage';
-import { getApp } from '@react-native-firebase/app';
-import { getMessaging, setBackgroundMessageHandler, onMessage, onNotificationOpenedApp, getInitialNotification, } from '@react-native-firebase/messaging';
+import { setBackgroundMessageHandler, onMessage, onNotificationOpenedApp, getInitialNotification, } from '@react-native-firebase/messaging';
 import InAppBrowser from 'react-native-inappbrowser-reborn';
 import { InngageProperties } from '../models/inngage_properties';
 import * as ApiService from '../services/api_services';
 import notifee, { EventType } from '@notifee/react-native';
-const ANDROID_CHANNEL_ID = 'inngage_default';
-async function ensureAndroidChannel() {
-    if (!notifee || Platform.OS !== 'android')
-        return;
-    await notifee.createChannel({ id: ANDROID_CHANNEL_ID, name: 'Inngage' });
-}
-const toStringValue = (v) => typeof v === 'string' ? v : JSON.stringify(v ?? '');
-const app = getApp();
-const messagingInstance = getMessaging(app);
+import { toStringValue } from '../utils';
+import { ANDROID_CHANNEL_ID, messagingInstance, ensureAndroidChannel, } from './notifications_config';
 export const messagingHeadlessTask = () => {
     return setBackgroundMessageHandler(messagingInstance, async (remoteMessage) => {
         if (InngageProperties.getDebugMode()) {
@@ -45,23 +37,112 @@ export const useInAppHandler = () => {
     }, []);
     return { showInApp, setShowInApp };
 };
-export const InngageNotificationMessage = (firebaseListenCallback) => {
-    const [notificationMessage, setNotificationMessage] = useState(null);
-    useEffect(() => {
+let currentFirebaseListenCallback;
+let currentImageNotification;
+let currentColorNotification;
+let foregroundUnsubscribe = null;
+let openedAppUnsubscribe = null;
+let initialNotificationHandled = false;
+const normalizeAndroidImageResource = (res) => {
+    if (!res)
+        return undefined;
+    if (res.startsWith('@drawable/')) {
+        return res.replace('@drawable/', '');
+    }
+    if (res.startsWith('@mipmap/')) {
+        return res.replace('@mipmap/', '');
+    }
+    return res;
+};
+const handleNotification = async (remoteMessage) => {
+    const data = remoteMessage?.data ?? {};
+    const notId = data?.notId;
+    const request = {
+        notificationRequest: {
+            app_token: InngageProperties.appToken,
+            id: notId,
+            notId: notId,
+        },
+    };
+    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,
+                    });
+                }
+                else {
+                    Linking.openURL(url);
+                }
+            }
+            catch (error) {
+                console.error(error);
+            }
+        }
+        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);
+            await handleNotification(remoteMessage);
+        }
+    }
+    catch (e) {
+        console.error(e);
+    }
+};
+export const InngageNotificationMessage = (firebaseListenCallback, imageNotification, colorNotification) => {
+    currentFirebaseListenCallback = firebaseListenCallback;
+    currentImageNotification = imageNotification;
+    currentColorNotification = colorNotification;
+    ensureAndroidChannel().catch(() => { });
+    if (!foregroundUnsubscribe) {
         const handleMessage = async (remoteMessage) => {
             const notificationData = remoteMessage.data ?? {};
             if (notificationData.additional_data != null) {
                 await AsyncStorage.setItem('inapp', toStringValue(notificationData.additional_data));
             }
             if (notifee) {
-                const title = remoteMessage.notification?.title ?? notificationData.title ?? '';
-                const body = remoteMessage.notification?.body ?? notificationData.body ?? '';
+                const title = remoteMessage.notification?.title ??
+                    notificationData.title ??
+                    '';
+                const body = remoteMessage.notification?.body ??
+                    notificationData.body ??
+                    '';
+                const normalizedImage = normalizeAndroidImageResource(currentImageNotification);
+                const resolvedColor = currentColorNotification;
                 await notifee.displayNotification({
                     title,
                     body,
-                    android: Platform.OS === 'android' ? { channelId: ANDROID_CHANNEL_ID } : undefined,
+                    android: Platform.OS === 'android'
+                        ? {
+                            channelId: ANDROID_CHANNEL_ID,
+                            ...(normalizedImage ? { smallIcon: normalizedImage } : {}),
+                            ...(resolvedColor ? { color: resolvedColor } : {}),
+                        }
+                        : undefined,
                     ios: Platform.OS === 'ios'
-                        ? { foregroundPresentationOptions: { banner: true, list: true, sound: true } }
+                        ? {
+                            foregroundPresentationOptions: {
+                                banner: true,
+                                list: true,
+                                sound: true,
+                            },
+                        }
                         : undefined,
                 });
                 return notifee.onForegroundEvent(({ type, detail }) => {
@@ -85,86 +166,37 @@ export const InngageNotificationMessage = (firebaseListenCallback) => {
             if (InngageProperties.getDebugMode()) {
                 console.log('Remote message received in foreground: ', remoteMessage);
             }
-            if (firebaseListenCallback && remoteMessage) {
-                firebaseListenCallback(notificationData);
+            if (currentFirebaseListenCallback && remoteMessage) {
+                currentFirebaseListenCallback(notificationData);
             }
-            setNotificationMessage(remoteMessage);
         };
-        ensureAndroidChannel().catch(() => { });
-        const unsubscribe = onMessage(messagingInstance, handleMessage);
-        return unsubscribe;
-    }, [firebaseListenCallback]);
-    useEffect(() => {
-        const unsubscribe = onNotificationOpenedApp(messagingInstance, (remoteMessage) => {
+        foregroundUnsubscribe = onMessage(messagingInstance, handleMessage);
+    }
+    if (!openedAppUnsubscribe) {
+        openedAppUnsubscribe = onNotificationOpenedApp(messagingInstance, (remoteMessage) => {
             if (!remoteMessage)
                 return;
-            firebaseListenCallback?.(remoteMessage.data ?? {});
+            currentFirebaseListenCallback?.(remoteMessage.data ?? {});
             handleNotification(remoteMessage);
         });
-        return unsubscribe;
-    }, [firebaseListenCallback]);
-    useEffect(() => {
-        let mounted = true;
+    }
+    if (!initialNotificationHandled) {
+        initialNotificationHandled = true;
         getInitialNotification(messagingInstance)
             .then(async (value) => {
-            if (!mounted || !value)
+            if (!value)
                 return;
             await handleUniqueRemoteMessage(value);
         })
             .catch((e) => console.error(e));
-        return () => {
-            mounted = false;
-        };
-    }, []);
-    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);
-                handleNotification(remoteMessage);
-            }
-        }
-        catch (e) {
-            console.error(e);
-        }
-    };
-    async function handleNotification(remoteMessage) {
-        const data = remoteMessage?.data ?? {};
-        const notId = data?.notId;
-        const request = {
-            notificationRequest: {
-                app_token: InngageProperties.appToken,
-                id: notId,
-                notId: notId
-            },
-        };
-        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,
-                        });
-                    }
-                    else {
-                        Linking.openURL(url);
-                    }
-                }
-                catch (error) {
-                    console.error(error);
-                }
-            }
-            else if (type === 'deep') {
-                Linking.openURL(url).catch((err) => console.error('Erro ao abrir o link:', err));
-            }
-        }
-        await ApiService.sendNotification(request);
     }
+    return {
+        unsubscribe: () => {
+            foregroundUnsubscribe?.();
+            openedAppUnsubscribe?.();
+            foregroundUnsubscribe = null;
+            openedAppUnsubscribe = null;
+            initialNotificationHandled = false;
+        },
+    };
 };

package/dist/utils.d.ts

@@ -2,3 +2,4 @@ export declare const formatDate: (timestamp: any) => string | null;
 export declare const showAlert: (title: string, body: string) => void;
 export declare const showAlertLink: (title: string, body: string, appName: string, link: string) => Promise<unknown>;
 export declare const isEmpty: (obj: any) => boolean;
+export declare const toStringValue: (v: unknown) => string;

package/dist/utils.js

@@ -23,3 +23,4 @@ export const isEmpty = (obj) => {
     }
     return JSON.stringify(obj) === JSON.stringify({});
 };
+export const toStringValue = (v) => typeof v === 'string' ? v : JSON.stringify(v ?? '');

package/package.json

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