@inngageregistry/inngage-react 3.0.5 → 3.0.7

package/README.md

@@ -0,0 +1,40 @@
+<h1 align="center">
+   <b>
+        <a href="https://inngage.com.br/"><img src="https://inngage.com.br/wp-content/uploads/2022/03/inngage-small.png" /></a><br>
+    </b>
+</h1>
+
+<p align="center">Pacote Inngage para aplicativos React Native para otimização de campanhas de marketing usando notificações push.</p>
+
+<p align="center">
+    <a href="https://inngage.com.br/"><b>Website</b></a> •
+    <a href="https://inngage.readme.io/docs/react-native-sdk-20"><b>Documentation</b></a>
+</p>
+
+<div align="center">
+
+[![npm version](https://img.shields.io/npm/v/@inngageregistry/inngage-react.svg?style=flat-square)](https://www.npmjs.org/package/@inngageregistry/inngage-react)
+
+</div>
+
+## Instalação
+### Instalando as dependências
+```bash
+"dependencies": {
+  "@react-native-async-storage/async-storage": "^1.18.1",
+  "@react-native-firebase/app": "^17.4.2",
+  "@react-native-firebase/messaging": "^17.4.2",
+  "react-native-device-info": "^10.6.0",
+  "react-native-inappbrowser-reborn": "^3.7.0",
+  "react-native-localize": "^2.2.6",
+  "react-native-snap-carousel": "^3.9.1"
+}
+```
+Ao adicioná-las no seu ```package.json```, utilize o comando ```npm install```.
+### Importar FCM Token (API Key)
+Para aproveitar nossos SDKs, será necessário importar o FCM Token (API Key) do seu projeto Firebase em nossa plataforma.
+### Instalando a SDK
+Utilize o NPM:
+```bash
+$ npm i @inngageregistry/inngage-react
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inngageregistry/inngage-react",
-  "version": "3.0.5",
+  "version": "3.0.7",
   "description": "Inngage Plugin for React Native applications for marketing campaign optimization using Push Notification.",
   "main": "src/index.ts",
   "types": "src/index.d.ts",
@@ -19,15 +19,15 @@
   },
   "homepage": "https://github.com/inngage/inngage-react#readme",
   "dependencies": {
+    "@react-native-async-storage/async-storage": "^1.18.1",
+    "@react-native-community/push-notification-ios": "^1.11.0",
     "@react-native-firebase/app": "^17.4.2",
     "@react-native-firebase/messaging": "^17.4.2",
-    "react-native-localize": "^2.2.6",
-    "react-native-snap-carousel": "^3.9.1",
-    "@react-native-async-storage/async-storage": "^1.18.1",
+    "react-native-device-info": "^10.6.0",
     "react-native-inappbrowser-reborn": "^3.7.0",
-    "@react-native-community/push-notification-ios": "^1.11.0",
+    "react-native-localize": "^2.2.6",
     "react-native-push-notification": "^8.1.1",
-    "react-native-device-info": "^10.6.0"
+    "react-native-snap-carousel": "^3.9.1"
   },
   "devDependencies": {
     "@types/jest": "^29.5.1",

package/src/Inngage.ts

@@ -1,5 +1,6 @@
 import {
   Platform,
+  PermissionsAndroid,
   LogBox,
   AppRegistry,
 } from "react-native";
@@ -13,56 +14,50 @@ import { formatDate, subscriptionRequestAdapter } from "./utils";
 import notificationsListener, { notificationsListenerProps } from "./notificationsListener";
 import { subscriptionApi, eventsApi } from "./services/inngage";
 
-// --- handle background message ------/
-const backgroundNotificationHandler = async remoteMessage => {
-  var messageArray: any = [];
-  console.log("Remote message:", JSON.stringify(remoteMessage));
+// --- Get Firebase Access ------/
+const getFirebaseAccess = async (): Promise<string | null> => {
+  try {
+    const apiLevel = await DeviceInfo.getApiLevel();
+
+    if (apiLevel >= 33) {
+      await PermissionsAndroid.request(
+        PermissionsAndroid.PERMISSIONS.POST_NOTIFICATIONS
+      );
+    }
 
-  console.log('Called backgroundNotificationHandler');
+    const authStatus = await firebase.messaging().requestPermission();
 
-  const currentMessages = await AsyncStorage.getItem('messages');
-  if (currentMessages !== null) {
-    messageArray = JSON.parse(currentMessages);
-  }
-  messageArray.push(remoteMessage);
+    const enabled =
+      authStatus === firebase.messaging.AuthorizationStatus.AUTHORIZED ||
+      authStatus === firebase.messaging.AuthorizationStatus.PROVISIONAL;
 
-  await AsyncStorage.setItem('messages', JSON.stringify(messageArray));
-};
+    if (enabled) {
+      let fcmToken = await AsyncStorage.getItem('fcmToken');
+      console.log('Old token: ', fcmToken);
 
-// --- Get Firebase Access ------/
-const getFirebaseAccess = () => {
-  let firebaseToken = 'W7SAl94Jk6l3w95W9wCgmv3zZ99V5FReNUytdgJUFUvpvZoqXf72'
-  return new Promise(async (resolve) => {
-    DeviceInfo.isEmulator().then(isEmulator => {
-      if (isEmulator && Platform.OS === "ios") {
-        return resolve(firebaseToken)
-      }
-    })
-    try {
-      if (!firebase.messaging().isDeviceRegisteredForRemoteMessages)
-        await firebase.messaging().registerDeviceForRemoteMessages();
-
-      const permission = await firebase.messaging().hasPermission();
-      if (permission === firebase.messaging.AuthorizationStatus.NOT_DETERMINED) {
-        try {
-          await firebase.messaging().requestPermission();
-        } catch (e) {
-          console.error(e)
-          return resolve(firebaseToken);
+      if (!fcmToken) {
+        if (!firebase.messaging().isDeviceRegisteredForRemoteMessages) {
+          await firebase.messaging().registerDeviceForRemoteMessages();
+        }
+
+        const newFcmToken = await firebase.messaging().getToken();
+
+        if (newFcmToken) {
+          await AsyncStorage.setItem('fcmToken', newFcmToken);
+          console.log('New token: ', newFcmToken);
+          return newFcmToken;
         }
       }
-      try {
-        firebaseToken = await firebase.messaging().getToken();
-      } catch (error) {
-        console.error(error)
-        return resolve(firebaseToken)
-      }
-      return resolve(firebaseToken)
-    } catch (err) {
-      console.error(err)
-      return resolve(firebaseToken)
+
+      console.log('Authorization status:', authStatus);
+      return fcmToken;
     }
-  });
+
+    return null;
+  } catch (error) {
+    console.log('Erro no getFirebaseAccess: ', error);
+    throw error;
+  }
 };
 
 interface SubscriptionProps {
@@ -95,16 +90,8 @@ interface SendEventProps {
 const Inngage = {
   // ------------  Register Notification Listener ------------//
   RegisterNotificationListener: async (props: notificationsListenerProps) => {
-
-    try {
-      LogBox.ignoreLogs(['registerHeadlessTask'])
-    } catch (e) { }
-    try {
-      console.ignoredYellowBox = ['registerHeadlessTask'];
-    } catch (e) { }
     try {
-      AppRegistry.registerHeadlessTask('ReactNativeFirebaseMessagingHeadlessTask', () => backgroundNotificationHandler)
-      notificationsListener({ ...props });
+      await notificationsListener({ ...props });
     } catch (e) {
       console.error(e);
       return { subscribed: false };

package/src/components/Inapp.tsx

@@ -64,7 +64,7 @@ export const Inapp = (props: InappProps) => {
       }
     }
 
-    const itemStyles = styleItem({msg, checkBG})
+    const itemStyles = styleItem({ msg, checkBG })
 
     const chooseRef = () => {
       if (index == 0) {
@@ -225,9 +225,9 @@ export const Inapp = (props: InappProps) => {
   const onLoad = async () => {
     let temp: any = []
     const messages = JSON.parse(await AsyncStorage.getItem('inngage') ?? '[]')
-    
+
     console.log("Messages saved on AsyncStorage: ", JSON.stringify(messages))
-    
+
     if (messages !== null) {
       messages.forEach((el) => {
         if (!isEmpty(el)) {
@@ -294,7 +294,13 @@ export const Inapp = (props: InappProps) => {
                   layoutCardOffset={10}
                   data={data}
                   inactiveSlideOpacity={0}
-                  containerCustomStyle={styles.carouselContainer}
+                  containerCustomStyle={{
+                    backgroundColor: 'white',
+                    elevation: 10,
+                    borderRadius: 10,
+                    width: SLIDER_WIDTH * 0.8,
+                    height: 480,
+                  }}
                   contentContainerCustomStyle={{ justifyContent: 'center' }}
                   inactiveSlideShift={0}
                   onSnapToItem={(index) => {
@@ -315,4 +321,4 @@ export const Inapp = (props: InappProps) => {
   }
 };
 
-const styles = styleInapp({SLIDER_WIDTH})
+const styles = styleInapp({ SLIDER_WIDTH })

package/src/index.d.ts

@@ -1 +1,42 @@
-// not implemented
+interface notificationsListenerProps {
+    appToken: string,
+    dev?: boolean,
+    enableAlert: boolean,
+    onNotificationOpenedApp?: any,
+}
+
+interface SubscriptionProps {
+    appToken: string;
+    enableAlert: boolean;
+    dev?: boolean;
+    friendlyIdentifier?: string;
+    customFields?: any;
+    customData?: any;
+    phoneNumber?: string;
+    email?: string;
+}
+
+interface SendEventProps {
+    newEventRequest: {
+        app_token: string;
+        identifier: string;
+        event_name: string;
+        conversion_event: boolean;
+        conversion_value: number;
+        conversion_notid: string;
+        event_values: {
+            nome_promo: string;
+            categoria: string;
+            foto_promo: string;
+            redirect_link: string;
+        };
+    };
+}
+
+declare const Inngage: {
+    RegisterNotificationListener: (props: notificationsListenerProps) => Promise<any>;
+    Subscribe: (props: SubscriptionProps) => Promise<any>;
+    SendEvent: (props: SendEventProps) => Promise<any>;
+};
+
+export default Inngage;

package/src/notificationsListener.ts

@@ -1,6 +1,6 @@
 import { Linking } from 'react-native'
 import InAppBrowser from 'react-native-inappbrowser-reborn'
-import messaging, { firebase } from '@react-native-firebase/messaging';
+import messaging from '@react-native-firebase/messaging';
 import { showAlert } from './utils'
 import { notificationApi } from './services/inngage'
 import AsyncStorage from '@react-native-async-storage/async-storage';
@@ -27,40 +27,46 @@ export const linkInApp = (link: string) => {
   })
 }
 
-const openLinkByType = (type: string, url: string) => (type === 'deep' ? Linking.openURL(url) : linkInApp(url))
+const openLinkByType = (type: string, url: string) => {
+  const linkTypeHandlers: Record<string, () => void> = {
+    deep: () => Linking.openURL(url),
+    inapp: () => linkInApp(url),
+  };
 
-export const openCommonNotification = (notificationData) => {
-  const { appToken, dev, remoteMessage, enableAlert, state } = notificationData
-  if (!remoteMessage) {
-    return
+  const handler = linkTypeHandlers[type];
+  if (handler) {
+    handler();
   }
+};
+
+const openCommonNotification = ({ appToken, dev, remoteMessage, enableAlert, state }) => {
+  console.log("Notification Opened from", state)
+
+  if (!remoteMessage)
+    return
+
   const { data } = remoteMessage
-  if (!data || (data && !Object.keys(data).length)) {
+  console.log("Data:", data)
+  if (!data || (data && !Object.keys(data).length))
     return
-  }
+
   const { notId, title, body, type, url } = data
   const request = {
     notificationRequest: {
       id: notId,
       app_token: appToken,
-    },
+    }
   }
-  if (!url) {
-
-    return notificationApi(request, dev).then(() => {
 
+  if (url) {
+    Linking.canOpenURL(url).then((supported) => {
+      if (supported) {
+        supported && openLinkByType(type, url)
+      }
     }).catch(console.error)
-
   }
-  return Linking.canOpenURL(url).then((supported) => {
-    if (supported) {
-
-      supported && openLinkByType(type, url)
 
-    }
-  }).catch(console.error)
-}
-export const openRichNotification = (notificationData) => {
+  return notificationApi(request, dev)
 }
 
 export interface notificationsListenerProps {
@@ -72,71 +78,31 @@ export interface notificationsListenerProps {
 export default async ({ appToken, dev, enableAlert, onNotificationOpenedApp }: notificationsListenerProps) => {
   var messageArray: any = [];
 
-  firebase.messaging().setBackgroundMessageHandler(async (remoteMessage) => {
-    console.log('Push received: Background')
-
-    const request = {
-      notificationRequest: {
-        id: remoteMessage.data!.notId,
-        app_token: appToken,
-      },
-    }
-    if (remoteMessage != null && remoteMessage.data!.additional_data) {
-      let msg = JSON.parse(remoteMessage.data!.additional_data)
-      console.log('first step')
-      if (msg.inapp_message == true) {
-        console.log('second step')
-        const currentMessages = await AsyncStorage.getItem('inngage');
-        if (currentMessages !== null) {
-          messageArray = JSON.parse(currentMessages);
-        }
-        messageArray.push(remoteMessage);
-        await AsyncStorage.setItem('inngage', JSON.stringify(messageArray));
-        setTimeout(() => {
-          messaging().getInitialNotification().then(notification => {
-            notificationApi(request, dev)
-          })
-        }, 3000)
-      }
-    } else if (remoteMessage != null && !remoteMessage.data!.additional_data) {
-      setTimeout(() => {
-        messaging().getInitialNotification().then(notification => {
-          if (!remoteMessage.data!.url) {
-            notificationApi(request, dev) // TODO, responsible for triggering the notification api multiple times
-          } else {
-            notificationApi(request, dev)
-            Linking.canOpenURL(remoteMessage.data!.url).then((supported) => {
-              if (supported) {
-
-                supported && openLinkByType(remoteMessage.data!.type, remoteMessage.data!.url)
-
-              }
-            }).catch(error => console.error(error))
-          }
-        })
-      }, 3000)
-    }
-  })
+  if (typeof onNotificationOpenedApp == 'function') {
+    messaging().getInitialNotification().then((value) => {
+      onNotificationOpenedApp(value?.data);
+    });
+  }
 
-  firebase.messaging().onNotificationOpenedApp(async (remoteMessage) => {
-    console.log("Notification Oppened")
-    openCommonNotification({ appToken, dev, remoteMessage, enableAlert, state: 'Background' })
-  });
+  const handleBackgroundMessage = async (remoteMessage: any) => {
+    console.log('Message handled in the background!', remoteMessage);
+  }
 
-  if (typeof onNotificationOpenedApp == 'function') {
-    const remoteMessage = await messaging().getInitialNotification();
-    onNotificationOpenedApp(remoteMessage);
+  const handleNotificationOpenedApp = async (remoteMessage: any) => {
+    await openCommonNotification({ appToken, dev, remoteMessage, enableAlert, state: 'Background' })
   }
 
-  firebase.messaging().onMessage(async (remoteMessage) => {
-    console.log('Push received: Foreground')
+  const handleInitialNotification = async (remoteMessage: any) => {
+    await openCommonNotification({ appToken, dev, remoteMessage, enableAlert, state: 'Closed' })
+  }
 
+  const handleForegroundMessage = async (remoteMessage: any) => {
     try {
       PushNotification.configure({
         onNotification: function (notification) {
           console.log('LOCAL NOTIFICATION ==>', notification)
 
-          openCommonNotification({ appToken, dev, remoteMessage, enableAlert, state: 'foreground' })
+          openCommonNotification({ appToken, dev, remoteMessage, enableAlert, state: 'Foreground' })
         },
         popInitialNotification: true,
         requestPermissions: true
@@ -186,5 +152,26 @@ export default async ({ appToken, dev, enableAlert, onNotificationOpenedApp }: n
         showAlert(remoteMessage.data!.title, remoteMessage.data!.body)
       }
     }
-  });
+  }
+
+  messaging().setBackgroundMessageHandler(handleBackgroundMessage)
+  messaging().onNotificationOpenedApp(handleNotificationOpenedApp)
+  messaging().getInitialNotification().then(async (remoteMessage) => {
+    console.log("Remote message ID:", remoteMessage?.messageId)
+    try {
+      const lastRemoteMessageId = await AsyncStorage.getItem('LAST_REMOTE_MESSAGE_ID');
+      const newRemoteMessageId = remoteMessage?.messageId;
+
+      console.log("Last RM Id:", lastRemoteMessageId);
+      console.log("New RM Id:", newRemoteMessageId);
+
+      if (newRemoteMessageId && lastRemoteMessageId !== newRemoteMessageId) {
+        await AsyncStorage.setItem('LAST_REMOTE_MESSAGE_ID', newRemoteMessageId);
+        return handleInitialNotification(remoteMessage);
+      }
+    } catch (e) {
+      console.log(e);
+    }
+  })
+  messaging().onMessage(handleForegroundMessage)
 }