@inngageregistry/inngage-react 3.3.1 → 4.0.0-alpha.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inngageregistry/inngage-react",
-  "version": "3.3.1",
+  "version": "4.0.0-alpha.01",
   "description": "Inngage Plugin for React Native applications for marketing campaign optimization using Push Notification.",
   "main": "src/index.ts",
   "types": "src/index.d.ts",

package/src/Inngage.ts

@@ -3,62 +3,62 @@ import DeviceInfo from "react-native-device-info";
 import * as RNLocalize from "react-native-localize";
 import AsyncStorage from '@react-native-async-storage/async-storage';
 
-import { addUserDataRequest, eventRequest, formatDate, subscriptionRequestAdapter } from "./utils";
-import notificationsListener, { notificationsListenerProps } from "./notificationsListener";
-import { subscriptionApi, eventsApi, addUserDataApi } from "./services/inngage";
+import { addUserDataRequest, eventRequest, formatDate } from "./utils";
+import { InngageNotificationMessage } from "./firebase/notifications_listener";
 import { InngageProperties } from './models/inngage_properties';
 
 import RNPermissions, { NotificationOption, RESULTS } from 'react-native-permissions';
 
+import ApiService from './services/api_service';
+
+import {
+  SUBSCRIBE_REQUEST,
+  EVENT_REQUEST,
+  USER_DATA_REQUEST,
+} from './models/requests';
+
+const API_LEVEL_33 = 33;
+
 // --- Get Firebase Access ------/
-const getFirebaseAccess = async (): Promise<string | null> => {
-  try {
-    return await handleNotificationsPermission();
-  } catch (error) {
-    console.error('Erro no getFirebaseAccess: ', error);
-    throw error;
-  }
+const getFirebaseAccess = async () => {
+  return await handleNotificationsPermission();
 };
 
 const handleNotificationsPermission = async () => {
-  try {
-    const options: NotificationOption[] = ['alert', 'badge', 'sound'];
-    const apiLevel = await DeviceInfo.getApiLevel();
-    const isPermissionGranted =
-      apiLevel >= 33
-        ? ((await RNPermissions.requestNotifications(options)).status) === RESULTS.GRANTED
-        : (await firebase.messaging().requestPermission()) ===
-        firebase.messaging.AuthorizationStatus.AUTHORIZED ||
-        firebase.messaging.AuthorizationStatus.PROVISIONAL;
-
-    return isPermissionGranted ? await getFirebaseToken() : null;
-  } catch (error) {
-    console.error(error);
-    throw error;
+  const options: NotificationOption[] = ['alert', 'badge', 'sound'];
+  const apiLevel = await DeviceInfo.getApiLevel();
+
+  const permissionGranted =
+    apiLevel >= API_LEVEL_33
+      ? (await RNPermissions.requestNotifications(options)).status === RESULTS.GRANTED
+      : (await firebase.messaging().requestPermission()) ===
+      firebase.messaging.AuthorizationStatus.AUTHORIZED ||
+      firebase.messaging.AuthorizationStatus.PROVISIONAL;
+
+  if (permissionGranted) {
+    return await getFirebaseToken();
   }
+
+  throw new Error('Notification permission not granted');
 };
 
-const getFirebaseToken = async (): Promise<string | null> => {
-  try {
-    let fcmToken = await AsyncStorage.getItem('fcmToken');
+const getFirebaseToken = async () => {
+  let fcmToken = await AsyncStorage.getItem('fcmToken');
 
-    if (!fcmToken) {
-      if (!firebase.messaging().isDeviceRegisteredForRemoteMessages) {
-        await firebase.messaging().registerDeviceForRemoteMessages?.();
-      }
+  if (!fcmToken) {
+    if (!firebase.messaging().isDeviceRegisteredForRemoteMessages) {
+      await firebase.messaging().registerDeviceForRemoteMessages?.();
+    }
 
-      const newFcmToken = await firebase.messaging().getToken?.();
+    const newFcmToken = await firebase.messaging().getToken?.();
 
-      if (newFcmToken) {
-        await AsyncStorage.setItem('fcmToken', newFcmToken);
-        return newFcmToken;
-      }
+    if (newFcmToken) {
+      await AsyncStorage.setItem('fcmToken', newFcmToken);
+      return newFcmToken;
     }
-    return fcmToken || null;
-  } catch (error) {
-    console.error(error);
-    throw error;
   }
+
+  return fcmToken || null;
 };
 
 interface SubscriptionProps {
@@ -83,126 +83,124 @@ interface SendEventProps {
   eventValues?: any
 }
 
-const Inngage = {
-  // ------------  Register Notification Listener ------------//
-  RegisterNotificationListener: async (props: notificationsListenerProps) => {
+class Inngage {
+  private static instance: Inngage;
+  private apiService: ApiService;
+
+  constructor() {
+    this.apiService = new ApiService();
+  }
+
+  static getInstance(): Inngage {
+    if (!Inngage.instance) {
+      Inngage.instance = new Inngage();
+    }
+
+    return Inngage.instance;
+  }
+
+  static async notificationListener(firebaseListenCallback?: any) {
     try {
-      await notificationsListener({ ...props });
+      InngageNotificationMessage(firebaseListenCallback)
     } catch (e) {
-      console.error(e);
-      return { subscribed: false };
+      console.log(e)
     }
-  },
+  }
 
-  Subscribe: async ({
+  static async subscribe({
     appToken,
-    dev,
     friendlyIdentifier,
     customFields,
-    customData,
     phoneNumber,
     email,
-  }: SubscriptionProps) => {
+  }: SubscriptionProps) {
+    const inngage = Inngage.getInstance();
+
     InngageProperties.appToken = appToken;
     InngageProperties.identifier = friendlyIdentifier!;
 
-    try {
-      const respToken = await getFirebaseAccess()
-
-      const locales = RNLocalize.getLocales();
-
-      const os_locale = locales ? locales[0].countryCode : ''
-      const os_language = locales && locales.length ? locales[0].languageCode : ''
-      const device_manufacturer = await DeviceInfo.getManufacturer();
-      const installTime = await DeviceInfo.getFirstInstallTime();
-      const lastUpdateTime = await DeviceInfo.getLastUpdateTime();
-      const uuid = await DeviceInfo.getUniqueId();
-      const app_installed_in = formatDate(installTime);
-      const app_updated_in = formatDate(lastUpdateTime);
-
-      const rawRequest = {
-        registerSubscriberRequest: {
-          app_token: appToken,
-          identifier: friendlyIdentifier,
-          registration: respToken,
-          platform: DeviceInfo.getSystemName(),
-          sdk: DeviceInfo.getBuildNumber(),
-          device_model: DeviceInfo.getModel(),
-          device_manufacturer,
-          os_locale,
-          os_language,
-          os_version: DeviceInfo.getReadableVersion(),
-          app_version: DeviceInfo.getBuildNumber(),
-          app_installed_in,
-          app_updated_in,
-          uuid,
-          phone_Number: phoneNumber,
-          email: email,
-        }
-      };
-
-      const request = subscriptionRequestAdapter(rawRequest, customData, customFields)
-      const subscribe = await subscriptionApi(request, dev);
-      return subscribe;
-    } catch (e) {
-      console.error(e);
-      return { subscribed: false };
+    const respToken = await getFirebaseAccess();
+
+    const { countryCode: osLocale, languageCode: osLanguage } = RNLocalize.getLocales()[0] || {};
+    const deviceManufacturer = await DeviceInfo.getManufacturer();
+    const installTime = await DeviceInfo.getFirstInstallTime();
+    const lastUpdateTime = await DeviceInfo.getLastUpdateTime();
+    const uuid = await DeviceInfo.getUniqueId();
+    const appInstalledIn = formatDate(installTime);
+    const appUpdatedIn = formatDate(lastUpdateTime);
+
+    const subscription = {
+      ...SUBSCRIBE_REQUEST,
+      registerSubscriberRequest: {
+        app_token: appToken,
+        identifier: friendlyIdentifier,
+        registration: respToken,
+        platform: DeviceInfo.getSystemName(),
+        sdk: DeviceInfo.getBuildNumber(),
+        deviceModel: DeviceInfo.getModel(),
+        deviceManufacturer,
+        osLocale,
+        osLanguage,
+        os_version: DeviceInfo.getReadableVersion(),
+        app_version: DeviceInfo.getBuildNumber(),
+        appInstalledIn,
+        appUpdatedIn,
+        uuid,
+        phone_Number: phoneNumber,
+        email: email,
+        customFields: customFields,
+      }
     }
-  },
 
-  SendEvent: async ({
-    appToken,
+    return inngage.apiService.subscribe(subscription);
+  }
+
+  static async sendEvent({
     eventName,
-    identifier,
-    registration,
     conversionEvent,
     conversionValue,
     conversionNotId,
     eventValues,
-  }: SendEventProps) => {
+  }: SendEventProps) {
+    const inngage = Inngage.getInstance();
+
+    const registration = await getFirebaseAccess();
 
-    const rawRequest = {
+    const request = eventRequest({
+      ...EVENT_REQUEST,
       newEventRequest: {
-        app_token: appToken,
-        identifier: identifier,
-        registration: registration,
-        event_name: eventName,
-        conversion_event: conversionEvent ?? false,
-        conversion_value: conversionValue ?? 0,
-        conversion_notid: conversionNotId ?? '',
-        event_values: eventValues ?? {}
-      }
-    };
+        appToken: InngageProperties.appToken,
+        identifier: InngageProperties.identifier,
+        registration,
+        eventName,
+        conversionEvent: !!conversionEvent,
+        conversionValue,
+        conversionNotId,
+        eventValues,
+      },
+    });
+
+    return inngage.apiService.sendEvent(request);
+  }
 
-    const request = eventRequest(rawRequest)
-    try {
-      return await eventsApi(request);
-    } catch (e) {
-      console.error(e)
-      return { subscribed: false };
-    }
-  },
+  static async addUserData(customFields: any): Promise<any> {
+    const inngage = Inngage.getInstance();
 
-  async addUserData(customFields: any): Promise<any> {
-    const rawRequest = {
+    const request = addUserDataRequest({
+      ...USER_DATA_REQUEST,
       fieldsRequest: {
-        app_token: InngageProperties.appToken,
+        appToken: InngageProperties.appToken,
         identifier: InngageProperties.identifier,
-        custom_field: customFields ?? {}
-      }
-    };
+        customField: customFields,
+      },
+    });
 
-    const request = addUserDataRequest(rawRequest);
-    try {
-      return await addUserDataApi(request);
-    } catch (e) {
-      console.error(e);
-    }
-  },
+    return inngage.apiService.addUserData(request);
+  }
 
-  setDebugMode(value: boolean) {
-    InngageProperties.debugMode = value
+  static setDebugMode(value: boolean) {
+    InngageProperties.debugMode = value;
   }
 }
 
-export default Inngage;
+export default Inngage;

package/src/api/api.ts

@@ -0,0 +1,28 @@
+import { fetchClient } from './handler'
+
+const apiEndpoints = {
+    subscription: '/subscription/',
+    notification: '/notification/',
+    events: '/events/newEvent/',
+    addUserData: '/subscription/addCustomField',
+};
+
+const makeApiCall = (method: string, request: any, endpoint: string) => {
+    return fetchClient(method, request, endpoint);
+};
+
+export const subscriptionApi = (request: any) => {
+    return makeApiCall('POST', request, apiEndpoints.subscription);
+};
+
+export const notificationApi = (request: any) => {
+    return makeApiCall('POST', request, apiEndpoints.notification);
+};
+
+export const eventsApi = (request: any) => {
+    return makeApiCall('POST', request, apiEndpoints.events);
+};
+
+export const addUserDataApi = (request: any) => {
+    return makeApiCall('POST', request, apiEndpoints.addUserData);
+};

package/src/{services → api}/handler.ts

@@ -30,12 +30,24 @@ const requestConfigFactory = (method, request) => {
   return objToSend
 }
 
-export const fetchClient = (method, requestBody, path, isDev = false): Promise<Response> => {
-  return new Promise((resolve) => {
-    const url = String(baseUrlHook[isDev as any]).concat(path)
-    const request = requestConfigFactory(method, requestBody)
-    fetch(url, request)
-      .then(resolve)
-      .catch(err => console.error('Fetch Error', err))
-  })
-}
+export const fetchClient = async (
+  method: string,
+  requestBody: any,
+  path: string,
+  isDev = false
+): Promise<Response> => {
+  try {
+    const url: URL = new URL(`${baseUrlHook[isDev as any]}${path}`);
+    const request: RequestInit = requestConfigFactory(method, requestBody);
+    const response: Response = await fetch(url, request);
+
+    if (!response.ok) {
+      throw new Error(`Network response was not ok (${response.status})`);
+    }
+
+    return response;
+  } catch (error: any) {
+    console.error('Fetch Error:', error.message);
+    throw error;
+  }
+};

package/src/components/in_app.tsx

@@ -0,0 +1,117 @@
+import React from 'react';
+import {
+  Modal,
+  View,
+  StyleSheet,
+  Text,
+  TouchableOpacity,
+  ImageBackground,
+  Platform,
+  PlatformColor,
+} from "react-native";
+
+export function InAppContainer(data: any): JSX.Element {
+  const styles = buildStyles(data)
+  return (
+    <Modal
+      renderToHardwareTextureAndroid={true}
+      transparent={true}
+      visible={true}>
+      <ImageBackground style={styles.content} source={{ uri: "" }}>
+        <View style={styles.messageData}>
+          <Text style={styles.title}>data.title</Text>
+          <Text style={styles.body}>Corpo</Text>
+        </View>
+        <View style={styles.footer}>
+          <TouchableOpacity
+            style={styles.button}>
+            <Text style={styles.textButton}>Teste</Text>
+          </TouchableOpacity>
+          <TouchableOpacity
+            style={styles.button}>
+            <Text style={styles.textButton}>Teste</Text>
+          </TouchableOpacity>
+        </View>
+      </ImageBackground>
+    </Modal>
+  )
+}
+
+const buildStyles = ({ data }) => StyleSheet.create({
+  content: Platform.select({
+    android: {
+      backgroundColor: PlatformColor("?attr/colorBackgroundFloating"),
+      flexDirection: "column",
+      borderRadius: 3,
+      padding: 16,
+      margin: 16,
+      overflow: "hidden",
+      elevation: 10,
+      minWidth: 300,
+      alignItems: "center"
+    },
+    default: {}
+  }),
+  messageData: Platform.select({
+    android: {
+      marginTop: 12
+    },
+    default: {}
+  }),
+  footer: {
+    flexDirection: "row",
+    ...Platform.select({
+      android: {
+        alignItems: "center",
+        justifyContent: "flex-end",
+        marginTop: 4,
+      },
+      default: {},
+    }),
+  },
+  title: Platform.select({
+    android: {
+      color: PlatformColor(
+        `@android:color/${"primary_text_light"}`
+      ),
+      fontWeight: "500",
+      fontSize: 18,
+    },
+
+    default: {},
+  }),
+  body: Platform.select({
+    android: {
+      color: PlatformColor(
+        `@android:color/${"secondary_text_light"}`
+      ),
+      fontSize: 16,
+      marginTop: 10,
+      marginBottom: 10,
+    },
+    default: {},
+  }),
+  button: Platform.select({
+    android: {
+      margin: 2,
+      flex: 1,
+      backgroundColor: "red",
+      justifyContent: "center",
+      alignItems: "center",
+    },
+    default: {},
+  }),
+  textButton: Platform.select({
+    android: {
+      color: PlatformColor(
+        `@android:color/${"secondary_text_light"}`
+      ),
+      textAlign: "center",
+      backgroundColor: "transparent",
+      padding: 8,
+      fontSize: 14,
+      textTransform: "uppercase",
+    },
+    default: {},
+  }),
+})

package/src/firebase/notifications_listener.ts

@@ -0,0 +1,105 @@
+import { useEffect } from 'react';
+
+import AsyncStorage from '@react-native-async-storage/async-storage';
+
+import messaging from '@react-native-firebase/messaging';
+import PushNotification, { Importance } from 'react-native-push-notification'
+
+import { InngageProperties } from '../models/inngage_properties';
+import * as ApiService from '../services/api_service'
+
+export const InngageNotificationMessage = (firebaseListenCallback?: any) => {
+  useEffect(() => {
+    PushNotification.configure({
+      onNotification: function (data: any) {
+        if (data.foreground) {
+          handleNotification(data)
+        }
+      },
+      popInitialNotification: true,
+      requestPermissions: true
+    })
+    PushNotification.createChannel({
+      channelId: 'channel_id',
+      channelName: 'default',
+      importance: Importance.HIGH,
+      playSound: true,
+      soundName: 'default',
+      vibrate: true
+    }, (created: any) => {
+      if (created) {
+        console.log('Channel created');
+      }
+    });
+  })
+  useEffect(() => {
+    const handleMessage = async (remoteMessage: any) => {
+      if (InngageProperties.getDebugMode())
+        console.log('Remote message received in foreground: ', remoteMessage);
+
+      if (firebaseListenCallback != null && remoteMessage != null)
+        firebaseListenCallback(remoteMessage.data)
+
+      PushNotification.localNotification({
+        autoCancel: true,
+        bigPictureUrl: remoteMessage.notification?.android?.imageUrl,
+        largeIconUrl: remoteMessage.notification?.android?.imageUrl,
+        title: remoteMessage.data?.title,
+        message: remoteMessage.data?.body,
+        vibration: 300,
+        channelId: "channel_id",
+      });
+    };
+
+    return messaging().onMessage(handleMessage);
+  }, []);
+
+  useEffect(() => {
+    const backgroundHandler = async (remoteMessage: any) => {
+      if (InngageProperties.getDebugMode())
+        console.log('Remote message received in background: ', remoteMessage);
+
+      if (remoteMessage != null)
+        firebaseListenCallback(remoteMessage.data)
+
+      messaging().onNotificationOpenedApp(remoteMessage => {
+        handleNotification(remoteMessage)
+      })
+    };
+
+    return messaging().setBackgroundMessageHandler(backgroundHandler);
+  }, []);
+
+  useEffect(() => {
+    messaging().getInitialNotification().then(async (value) => {
+      if (value !== null)
+        handleUniqueRemoteMessage(value);
+    });
+  }, [])
+
+  const handleUniqueRemoteMessage = async (
+    remoteMessage: { messageId?: string }) => {
+    try {
+      const lastRemoteMessageId = await AsyncStorage.getItem('LAST_REMOTE_MESSAGE_ID');
+      const newRemoteMessageId = remoteMessage?.messageId;
+
+      if (newRemoteMessageId && lastRemoteMessageId !== newRemoteMessageId) {
+        await AsyncStorage.setItem('LAST_REMOTE_MESSAGE_ID', newRemoteMessageId);
+        handleNotification(remoteMessage)
+      }
+    } catch (e) {
+      console.log(e);
+    }
+  };
+
+  async function handleNotification(remoteMessage) {
+    const notId = remoteMessage.data?.notId;
+    const request = {
+      notificationRequest: {
+        id: notId,
+        app_token: InngageProperties.appToken,
+      }
+    };
+    await ApiService.sendNotification(request);
+  }
+}

package/src/index.ts

@@ -1,8 +1,8 @@
-import { Inapp } from './components/Inapp';
+import { InAppContainer } from './components/in_app';
 import Inngage from './Inngage';
 
 //-------------- In-APP Component -------------//
-export { Inapp };
+export { InAppContainer };
 
 //-------------- Inngage Wrapper --------------//
 export default Inngage;

package/src/models/requests.ts

@@ -0,0 +1,42 @@
+export const SUBSCRIBE_REQUEST = {
+    registerSubscriberRequest: {
+        appToken: '',
+        identifier: '',
+        registration: '',
+        platform: '',
+        sdk: '',
+        deviceModel: '',
+        deviceManufacturer: '',
+        osLocale: '',
+        osLanguage: '',
+        osVersion: '',
+        appVersion: '',
+        appInstalledIn: '',
+        appUpdatedIn: '',
+        uuid: '',
+        phoneNumber: '',
+        email: '',
+        customFields: {},
+    },
+};
+
+export const EVENT_REQUEST = {
+    newEventRequest: {
+        appToken: '',
+        identifier: '',
+        registration: '',
+        eventName: '',
+        conversionEvent: false,
+        conversionValue: 0,
+        conversionNotId: '',
+        eventValues: {},
+    },
+};
+
+export const USER_DATA_REQUEST = {
+    fieldsRequest: {
+        appToken: '',
+        identifier: '',
+        customField: {},
+    },
+};

package/src/services/api_service.ts

@@ -0,0 +1,30 @@
+import { InngageProperties } from '../models/inngage_properties';
+import { subscriptionApi, notificationApi, eventsApi, addUserDataApi } from '../api/api';
+
+class ApiService {
+    async subscribe(request: any) {
+        if (InngageProperties.getDebugMode())
+            console.log('INNGAGE PAYLOAD SUBSCRIPTION: ', request)
+        return subscriptionApi(request);
+    }
+
+    async sendEvent(request: any, dev = false) {
+        if (InngageProperties.getDebugMode())
+            console.log('INNGAGE PAYLOAD EVENT: ', request)
+        return eventsApi(request);
+    }
+
+    async addUserData(request: any, dev = false) {
+        if (InngageProperties.getDebugMode())
+            console.log('INNGAGE PAYLOAD ADDUSERDATA: ', request)
+        return addUserDataApi(request);
+    }
+}
+
+export async function sendNotification(request: any, dev = false) {
+    if (InngageProperties.getDebugMode())
+        console.log('INNGAGE PAYLOAD NOTIFICATION: ', request)
+    return notificationApi(request);
+}
+
+export default ApiService;

package/src/components/Inapp.tsx

@@ -1,321 +0,0 @@
-import React, { useState, useEffect, useRef } from 'react';
-import {
-  Modal,
-  View,
-  Text,
-  TouchableHighlight,
-  TouchableOpacity,
-  Image,
-  ScrollView,
-  ImageBackground,
-  Linking,
-  Dimensions,
-} from "react-native";
-import DeviceInfo from "react-native-device-info";
-import AsyncStorage from '@react-native-async-storage/async-storage';
-import Carousel, { Pagination } from 'react-native-snap-carousel';
-
-import { showAlertLink, isEmpty } from "../utils";
-import { linkInApp } from "../notificationsListener";
-import { styleInapp, styleItem } from './styles';
-
-const SLIDER_WIDTH = Dimensions.get('window').width;
-const SLIDER_HEIGHT = Dimensions.get('window').height;
-const ITEM_WIDTH = Math.round(SLIDER_WIDTH * 0.8);
-const ITEM_HEIGHT = Math.round(SLIDER_HEIGHT * 0.8);
-
-export interface InappProps {
-  mediaStyle?: any;
-  titleStyle?: any;
-  bodyStyle?: any;
-  buttonLeftStyle?: any;
-  buttonRightStyle?: any;
-  buttonTitleLeftStyle?: any;
-  buttonTitleRightStyle?: any;
-  styleContainer?: any;
-  onClose?: 'clear';
-}
-export const Inapp = (props: InappProps) => {
-  const [data, setData] = useState<any>([])
-  const [indIm, setIndImg] = useState(0)
-  const [visible, setVisible] = useState(true)
-  const [bgImage, setbgImage] = useState<any>(undefined) // TODO, need a placeholder
-
-  const CarouselRef = useRef<Carousel<any>>(null);
-  const ScrollRef1 = useRef<ScrollView>(null);
-  const ScrollRef2 = useRef<ScrollView>(null);
-  const ScrollRef3 = useRef<ScrollView>(null);
-
-
-  interface _renderItemProps {
-    item: any;
-    index: number;
-  }
-  const _renderItem = ({ item, index }: _renderItemProps) => {
-    let msg = JSON.parse(item.data.additional_data)
-    let arrayImgs: any = []
-    let indImg = 0
-
-    const checkBG = () => {
-      if (msg.background_img != '') {
-        return null
-      } else {
-        return msg.background_color
-      }
-    }
-
-    const itemStyles = styleItem({ msg, checkBG })
-
-    const chooseRef = () => {
-      if (index == 0) {
-        return ScrollRef1
-      }
-      if (index == 1) {
-        return ScrollRef2
-      }
-      if (index == 2) {
-        return ScrollRef3
-      }
-    }
-
-
-    const pagination = ref => {
-      return (
-        <Pagination
-          dotsLength={arrayImgs.length}
-          activeDotIndex={indIm}
-          containerStyle={{ height: 2, padding: 0, margin: 0 }}
-          renderDots={(activeIndex, total, context) => {
-            let dots: any = []
-            var size = 0
-            for (let i = 0; i < total; i++) {
-              if (activeIndex == i) {
-                size = 13
-              } else {
-                size = 8
-              }
-              dots.push(
-                <TouchableOpacity
-                  onPress={() => {
-                    ref.current.scrollTo({ x: i * 220, y: 0, animated: true })
-                    if (i * 220 === 0) {
-                      setIndImg(0)
-                    } else if (i * 220 === 220) {
-                      setIndImg(1)
-                    } else if (i * 220 === 440) {
-                      setIndImg(2)
-                    }
-                  }}
-                  key={i.toString()}
-                  style={[itemStyles.dot, { width: size, height: size }]}
-                />
-              )
-            }
-            return (
-              dots
-            )
-          }
-          }
-        />
-      );
-    }
-
-    const handleButton = (title: string, body: string, url: string, type: string) => {
-      if (type === '' || url === '') {
-        return
-      }
-      const openLinkByType = (type, url) => (type === 'deep' ? Linking.openURL(url) : linkInApp(url))
-
-      return Linking.canOpenURL(url).then((supported) => {
-        if (supported) {
-          showAlertLink(
-            title,
-            body,
-            `${DeviceInfo.getApplicationName()}`,
-            `Acessar ${url} ?`,
-          ).then(() => { supported && openLinkByType(type, url) })
-        }
-      }).catch(console.error)
-    }
-
-    const imgCarosel = () => {
-      if (msg.rich_content.carousel == true) {
-        if (msg.rich_content.img1 != '') {
-          arrayImgs.push({ url: msg.rich_content.img1 })
-        }
-        if (msg.rich_content.img2 != '') {
-          arrayImgs.push({ url: msg.rich_content.img2 })
-        }
-        if (msg.rich_content.img3 != '') {
-          arrayImgs.push({ url: msg.rich_content.img3 })
-        }
-        let arrayElements = arrayImgs.map((item, index) => (
-          <Image key={index.toString()} style={[props.mediaStyle, { width: 200, height: 200, marginRight: 10 }]} source={{ uri: item.url }} />
-        ));
-        return arrayElements
-      } else if (arrayImgs.length <= 0) {
-        return (
-          <Image style={[props.mediaStyle, { width: 200, height: 200 }]} source={{ uri: item.data.picture }} />
-        )
-      }
-      else {
-        return (
-          <Image style={[props.mediaStyle, { width: 200, height: 200 }]} source={{ uri: item.data.picture }} />
-        )
-      }
-    }
-    return (
-      <View style={[itemStyles.body]}>
-        <Text style={[itemStyles.title, props.titleStyle]}>{msg.title}</Text>
-        <ScrollView
-          ref={chooseRef()}
-          horizontal
-          snapToInterval={220}
-          decelerationRate="fast"
-          showsHorizontalScrollIndicator={false}
-          style={{ width: 200, height: 240 }}
-          contentContainerStyle={{ alignItems: 'center', justifyContent: 'center' }}
-          onMomentumScrollEnd={(e) => {
-            if (Math.round(e.nativeEvent.contentOffset.x) === 0
-            ) {
-              indImg = 0
-              setIndImg(indImg)
-            }
-            if (Math.round(e.nativeEvent.contentOffset.x) === 220
-            ) {
-              indImg = 1
-              setIndImg(indImg)
-            }
-            if (Math.round(e.nativeEvent.contentOffset.x) === 430
-            ) {
-              indImg = 2
-              setIndImg(indImg)
-            }
-          }}
-        >
-          {imgCarosel()}
-        </ScrollView>
-        {
-          msg.rich_content.carousel == true ?
-            pagination(chooseRef()) : null
-
-        }
-        <Text style={[itemStyles.bodyText, props.bodyStyle]}>{msg.body}</Text>
-        <View style={{ flexDirection: "row", marginBottom: 0, justifyContent: 'center' }}>
-          <TouchableOpacity onPress={() => handleButton(msg.title, msg.body, msg.btn_left_action_link, msg.btn_left_action_type)} style={[itemStyles.btn_left, props.buttonLeftStyle]}>
-            <View>
-              <Text style={[itemStyles.btn_left_title, props.buttonTitleLeftStyle]}>{msg.btn_left_txt}</Text>
-            </View>
-          </TouchableOpacity>
-          <TouchableOpacity onPress={() => handleButton(msg.title, msg.body, msg.btn_right_action_link, msg.btn_right_action_type)} style={[itemStyles.btn_right, props.buttonRightStyle]}>
-            <View>
-              <Text style={[itemStyles.btn_right_title, props.buttonTitleRightStyle]}>{msg.btn_right_txt}</Text>
-            </View>
-          </TouchableOpacity>
-        </View>
-      </View>
-    );
-  }
-
-  useEffect(() => {
-    onLoad();
-  }, [])
-
-  const onLoad = async () => {
-    let temp: any = []
-    const messages = JSON.parse(await AsyncStorage.getItem('inngage') ?? '[]')
-
-    if (messages !== null) {
-      messages.forEach((el) => {
-        if (!isEmpty(el)) {
-          temp.push(el)
-        }
-      })
-
-      let msg: any = {}
-      if (temp.length > 0 && temp[0]?.data?.additional_data) {
-        msg = JSON.parse(temp[0].data.additional_data)
-      }
-
-      if (msg.background_img != '') {
-        setbgImage({ uri: msg.background_img })
-      } else {
-        setbgImage(undefined)
-      }
-      setData(temp)
-    }
-  }
-
-  const handleClose = async () => {
-    if (props.onClose) {
-      if (props.onClose.toLowerCase() === 'clear') {
-        await AsyncStorage.removeItem('inngage');
-      }
-    }
-    setVisible(false)
-  }
-
-  const handleBg = index => {
-    let msg = JSON.parse(data[index].data.additional_data)
-    if (msg.background_img != '') {
-      setbgImage({ uri: msg.background_img })
-    } else {
-      setbgImage(undefined)
-    }
-  }
-
-  if (data.length > 0) {
-    return (
-      <View style={{ flex: 1, alignItems: 'center', justifyContent: 'center' }}>
-        <Modal
-          animationType='slide'
-          visible={visible}
-          transparent={true}
-          style={{ justifyContent: 'center', alignItems: 'center', backgroundColor: 'blue' }}
-        ><View style={{ flex: 1, alignItems: 'center', justifyContent: 'center' }}>
-            <View style={[styles.styleContainer, props.styleContainer]}>
-              <ImageBackground style={{ width: '100%', alignItems: 'center', justifyContent: 'center' }} resizeMode='cover' imageStyle={{ borderRadius: 10, alignSelf: 'stretch', height: 480 }} source={bgImage}>
-                <TouchableHighlight
-                  onPress={() => handleClose()}
-                  underlayColor='#cccccc'
-                  style={styles.closeButton}
-                >
-                  <Text style={{ fontWeight: 'bold', color: '#ffffff' }}>
-                    X
-                  </Text>
-                </TouchableHighlight>
-                <Carousel
-                  vertical
-                  ref={CarouselRef}
-                  layout={'default'}
-                  layoutCardOffset={10}
-                  data={data}
-                  inactiveSlideOpacity={0}
-                  containerCustomStyle={{
-                    backgroundColor: 'white',
-                    elevation: 10,
-                    borderRadius: 10,
-                    width: SLIDER_WIDTH * 0.8,
-                    height: 480,
-                  }}
-                  contentContainerCustomStyle={{ justifyContent: 'center' }}
-                  inactiveSlideShift={0}
-                  onSnapToItem={(index) => {
-                    handleBg(index)
-                  }}
-                  renderItem={({ item, index }) => _renderItem({ item, index })}
-                  sliderHeight={500}
-                  itemHeight={500}
-                />
-              </ImageBackground>
-            </View>
-          </View>
-        </Modal>
-      </View>
-    );
-  } else {
-    return null
-  }
-};
-
-const styles = styleInapp({ SLIDER_WIDTH })

package/src/notificationsListener.ts

@@ -1,178 +0,0 @@
-import { Linking } from 'react-native'
-import InAppBrowser from 'react-native-inappbrowser-reborn'
-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';
-import PushNotification, { Importance } from 'react-native-push-notification'
-
-export const linkInApp = (link: string) => {
-  InAppBrowser.open(link, {
-    dismissButtonStyle: 'cancel',
-    preferredBarTintColor: 'gray',
-    preferredControlTintColor: 'white',
-    readerMode: false,
-    showTitle: true,
-    toolbarColor: '#6200EE',
-    secondaryToolbarColor: 'black',
-    enableUrlBarHiding: true,
-    enableDefaultShare: true,
-    forceCloseOnRedirection: false,
-    animations: {
-      startEnter: 'slide_in_right',
-      startExit: 'slide_out_left',
-      endEnter: 'slide_in_right',
-      endExit: 'slide_out_left',
-    },
-  })
-}
-
-const openLinkByType = (type: string, url: string) => {
-  const linkTypeHandlers: Record<string, () => void> = {
-    deep: () => Linking.openURL(url),
-    // inapp: () => linkInApp(url),
-  };
-
-  const handler = linkTypeHandlers[type];
-  if (handler) {
-    handler();
-  }
-};
-
-const openCommonNotification = ({ appToken, dev, remoteMessage, enableAlert, state }) => {
-  if (!remoteMessage)
-    return
-
-  const { data } = remoteMessage
-  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) {
-    Linking.canOpenURL(url).then((supported) => {
-      if (supported) {
-        supported && openLinkByType(type, url)
-      }
-    }).catch(console.error)
-  }
-
-  return notificationApi(request, dev)
-}
-
-const handleUniqueRemoteMessage = async (
-  remoteMessage: { messageId?: string },
-  handleInitialNotification: (value: { messageId?: string }) => void
-) => {
-  try {
-    const lastRemoteMessageId = await AsyncStorage.getItem('LAST_REMOTE_MESSAGE_ID');
-    const newRemoteMessageId = remoteMessage?.messageId;
-
-    if (newRemoteMessageId && lastRemoteMessageId !== newRemoteMessageId) {
-      await AsyncStorage.setItem('LAST_REMOTE_MESSAGE_ID', newRemoteMessageId);
-      handleInitialNotification(remoteMessage);
-    }
-  } catch (e) {
-    console.error(e);
-  }
-};
-
-export interface notificationsListenerProps {
-  appToken: string,
-  dev?: boolean,
-  enableAlert: boolean,
-  onNotificationOpenedApp?: any,
-}
-export default async ({ appToken, dev, enableAlert, onNotificationOpenedApp }: notificationsListenerProps) => {
-  var messageArray: any = [];
-
-  if (typeof onNotificationOpenedApp == 'function') {
-    messaging().getInitialNotification().then(async (value) => {
-      onNotificationOpenedApp(value?.data);
-      if (value !== null)
-        handleUniqueRemoteMessage(value, async (value) => {
-          await handleInitialNotification(value);
-        });
-    });
-  }
-
-  const handleBackgroundMessage = async (remoteMessage: any) => {
-  }
-
-  const handleNotificationOpenedApp = async (remoteMessage: any) => {
-    await openCommonNotification({ appToken, dev, remoteMessage, enableAlert, state: 'Background' })
-  }
-
-  const handleInitialNotification = async (remoteMessage: any) => {
-    await openCommonNotification({ appToken, dev, remoteMessage, enableAlert, state: 'Closed' })
-  }
-
-  const handleForegroundMessage = async (remoteMessage: any) => {
-    try {
-      PushNotification.configure({
-        onNotification: function (notification) {
-          openCommonNotification({ appToken, dev, remoteMessage, enableAlert, state: 'Foreground' })
-        },
-        popInitialNotification: true,
-        requestPermissions: true
-      })
-
-      PushNotification.createChannel({
-        channelId: 'high_importance_channel',
-        channelName: 'default',
-        importance: Importance.HIGH,
-        playSound: true,
-        soundName: 'default',
-        vibrate: true
-      }, (created) => {
-
-      });
-
-    } catch (e) {
-      console.error(e)
-    }
-    try {
-      PushNotification.localNotification({
-        autoCancel: true,
-        title: remoteMessage.data!.title,
-        message: remoteMessage.data!.body,
-        vibration: 300,
-        channelId: "high_importance_channel"
-      });
-    } catch (e) {
-      console.error(e)
-    }
-
-    if (remoteMessage != null && remoteMessage.data!.additional_data) {
-      let msg = JSON.parse(remoteMessage.data!.additional_data)
-      if (msg.inapp_message == true) {
-        const currentMessages = await AsyncStorage.getItem('inngage');
-        if (currentMessages !== null) {
-          messageArray = JSON.parse(currentMessages);
-        }
-        messageArray.push(remoteMessage);
-        await AsyncStorage.setItem('inngage', JSON.stringify(messageArray));
-      }
-    } else if (remoteMessage != null && !remoteMessage.data!.additional_data) {
-      if (enableAlert) {
-        showAlert(remoteMessage.data!.title, remoteMessage.data!.body)
-      }
-    }
-  }
-
-  messaging().setBackgroundMessageHandler(handleBackgroundMessage)
-  messaging().onNotificationOpenedApp(handleNotificationOpenedApp)
-  messaging().getInitialNotification().then(async (remoteMessage) => {
-    if (remoteMessage !== null)
-      handleUniqueRemoteMessage(remoteMessage, async (value) => {
-        await handleInitialNotification(value);
-      });
-  })
-  messaging().onMessage(handleForegroundMessage)
-}

package/src/services/inngage.ts

@@ -1,23 +0,0 @@
-import { InngageProperties } from '../models/inngage_properties'
-import { fetchClient } from './handler'
-
-export const subscriptionApi = (request, dev = false) => {
-  if (InngageProperties.getDebugMode())
-    console.log('subscriptionApi', request)
-  return fetchClient('POST', request, '/subscription/', !!dev)
-}
-export const notificationApi = (request, dev = false) => {
-  if (InngageProperties.getDebugMode())
-    console.log('notificationApi', request)
-  return fetchClient('POST', request, '/notification/', !!dev)
-}
-export const eventsApi = (request, dev = false) => {
-  if (InngageProperties.getDebugMode())
-    console.log('eventsApi', request)
-  return fetchClient('POST', request, '/events/newEvent/', !!dev)
-}
-export const addUserDataApi = (request, dev = false) => {
-  if (InngageProperties.getDebugMode())
-    console.log('addUserData', request)
-  return fetchClient('POST', request, '/subscription/addCustomField', !!dev)
-}