airbridge-react-native-sdk-restricted 2.8.9 → 4.1.2

package/source/module/Deeplink.ts

@@ -0,0 +1,59 @@
+import { NativeModules, NativeEventEmitter } from 'react-native'
+
+import { createInteractor } from '../architecture/Interactor'
+import { check } from '../utility/check'
+import { log } from '../utility/log'
+
+export const createDependency = () => {}
+
+type DeeplinkInteractor = {
+    listen(): void
+}
+
+export type DeeplinkModuleDependency = ReturnType<typeof createDependency.DeeplinkModule>
+
+createDependency.DeeplinkModule = () => ({
+    emitter: new NativeEventEmitter(NativeModules.DeeplinkInteractor),
+    interactor: createInteractor<DeeplinkInteractor>(NativeModules.DeeplinkInteractor),
+})
+
+export type DeeplinkModule = ReturnType<typeof createDeeplinkModule>
+
+export const createDeeplinkModule = () => {
+    // create dependency
+    const { emitter, interactor } = createDependency.DeeplinkModule()
+
+    // define member
+    let cache: string | undefined
+    let listener: (deeplink: string) => void = (deeplink) => {
+        cache = deeplink
+    }
+
+    // initialize
+    emitter.addListener('airbridge.deeplink', (deeplink) => {
+        listener(deeplink)
+    })
+    interactor.listen()
+
+    // define method
+    const setOnDeeplinkReceived = (
+        onReceived: (deeplink: string) => void,
+    ): void => {
+        if (!check.function(onReceived)) {
+            log.unmatchedType('onReceived', 'function')
+            return
+        }
+
+        if (cache !== undefined) {
+            onReceived(cache)
+            cache = undefined
+        }
+
+        listener = onReceived
+    }
+
+    // create object
+    return {
+        setOnDeeplinkReceived,
+    }
+}

package/source/module/Event.ts

@@ -0,0 +1,71 @@
+import { NativeModules } from 'react-native'
+
+import { createInteractor } from '../architecture/Interactor'
+import { check } from '../utility/check'
+import { log } from '../utility/log'
+import { checkJSONObject, createJSONObject } from '../utility/json'
+
+export const createDependency = () => {}
+
+type EventInteractor = {
+    trackEvent(
+        category: string,
+        semanticAttributes?: Record<string, any>,
+        customAttributes?: Record<string, any>,
+    ): void
+}
+
+createDependency.EventModule = () => ({
+    interactor: createInteractor<EventInteractor>(NativeModules.EventInteractor),
+})
+
+export type EventModule = ReturnType<typeof createEventModule>
+
+export const createEventModule = () => {
+    // create dependency
+    const { interactor } = createDependency.EventModule()
+
+    // define method
+    const trackEvent = (
+        category: string,
+        semanticAttributes?: Record<string, any>,
+        customAttributes?: Record<string, any>,
+    ): void => {
+        if (!check.string(category)) {
+            log.unmatchedType('category', 'string')
+            return
+        }
+        if (!(check.null(semanticAttributes) ||
+            check.undefined(semanticAttributes) || 
+            check.object(semanticAttributes))) {
+            log.unmatchedType('semanticAttributes', 'object?')
+            return
+        }
+        if (!(check.null(customAttributes) ||
+            check.undefined(customAttributes) || 
+            check.object(customAttributes))) {
+            log.unmatchedType('customAttributes', 'object?')
+            return
+        }
+
+        if (!check.null(customAttributes) &&
+            check.defined(semanticAttributes) &&
+            !checkJSONObject(semanticAttributes)) {
+            log.nonJSONValue('semanticAttributes')
+            semanticAttributes = createJSONObject(semanticAttributes)
+        }
+        if (!check.null(customAttributes) &&
+            check.defined(customAttributes) &&
+            !checkJSONObject(customAttributes)) {
+            log.nonJSONValue('customAttributes')
+            customAttributes = createJSONObject(customAttributes)
+        }
+
+        interactor.trackEvent(category, semanticAttributes, customAttributes)
+    }
+
+    // create object
+    return {
+        trackEvent,
+    }
+}

package/source/module/Fetch.ts

@@ -0,0 +1,137 @@
+import { NativeEventEmitter, NativeModules } from 'react-native'
+
+import { createInteractor } from '../architecture/Interactor'
+import { check } from '../utility/check'
+import { log } from '../utility/log'
+
+export const createDependency = () => {}
+
+type FetchInteractor = {
+    fetchDeviceUUID(
+        promiseID: string,
+        onSuccess: (deviceUUID: string) => void,
+        onFailure: (message: string) => void,
+    ): Promise<boolean>
+    fetchAirbridgeGeneratedUUID(
+        promiseID: string,
+        onSuccess: (airbridgeGeneratedUUID: string) => void,
+        onFailure: (message: string) => void,
+    ): Promise<boolean>
+}
+
+createDependency.FetchModule = () => ({
+    emitter: new NativeEventEmitter(NativeModules.FetchInteractor),
+    interactor: createInteractor<FetchInteractor>(NativeModules.FetchInteractor),
+})
+
+export type FetchModule = ReturnType<typeof createFetchModule>
+
+export const createFetchModule= () => {
+    // create dependency
+    const { emitter, interactor } = createDependency.FetchModule()
+
+    // define member
+    let id = 0
+
+    // define method
+    const fetchDeviceUUID = async (
+        onSuccess: (deviceUUID: string) => void,
+        onFailure?: (error: Error) => void
+    ): Promise<boolean> => {
+        if (!check.function(onSuccess)) {
+            log.unmatchedType('onSuccess', 'function?')
+            return false
+        }
+        if (!(check.function(onFailure) || check.undefined(onFailure))) {
+            log.unmatchedType('onFailure', 'function?')
+            return false
+        }
+
+        const promiseID = `${id++}`
+
+        return new Promise((onResolve, onReject) => {
+            const subscription = emitter.addListener('airbridge.fetch', (message) => {
+                if (message.id !== promiseID) {
+                    return
+                }
+                switch (message.type) {
+                    case 'onResolve':
+                        onResolve(message.value)
+                        break
+                    case 'onReject':
+                        onReject(Error(message.value))
+                        break
+                }
+                subscription.remove()
+            })
+
+            interactor.fetchDeviceUUID(
+                promiseID,
+                (deviceUUID) => { onSuccess(deviceUUID) },
+                (message) => { onFailure?.(Error(message)) },
+            )
+        })
+    }
+
+    /**
+     * Fetch airbridgeGeneratedUUID of SDK.
+     * @param onSuccess Callback to be invoked when airbridgeGeneratedUUID is successfully handled.
+     * @param onFailure Callback to be invoked when any error occurs.
+     */
+    const fetchAirbridgeGeneratedUUID = async (
+        onSuccess: (airbridgeGeneratedUUID: string) => void,
+        onFailure?: (error: Error) => void
+    ): Promise<boolean> => {
+        if (!check.function(onSuccess)) {
+            log.unmatchedType('onSuccess', 'function?')
+            return false
+        }
+        if (!(check.function(onFailure) || check.undefined(onFailure))) {
+            log.unmatchedType('onFailure', 'function?')
+            return false
+        }
+
+        const promiseID = `${id++}`
+
+        return new Promise((onResolve, onReject) => {
+            const subscription = emitter.addListener('airbridge.fetch', (message) => {
+                if (message.id !== promiseID) {
+                    return
+                }
+                switch (message.type) {
+                    case 'onResolve':
+                        onResolve(message.value)
+                        break
+                    case 'onReject':
+                        onReject(Error(message.value))
+                        break
+                }
+                subscription.remove()
+            })
+
+            interactor.fetchAirbridgeGeneratedUUID(
+                promiseID,
+                (airbridgeGeneratedUUID) => { onSuccess(airbridgeGeneratedUUID) },
+                (message) => { onFailure?.(Error(message)) },
+            )
+        })
+    }
+
+    const isUninstallTrackingNotification = (
+        notification: Record<string, any>,
+    ): boolean => {
+        if (!check.object(notification)) {
+            log.unmatchedType('notification', 'object')
+            return false
+        }
+
+        return check.defined(notification['airbridge-uninstall-tracking'])
+    }
+
+    // create object
+    return {
+        fetchDeviceUUID,
+        fetchAirbridgeGeneratedUUID,
+        isUninstallTrackingNotification,
+    }
+}

package/source/module/Placement.ts

@@ -0,0 +1,134 @@
+import { NativeEventEmitter, NativeModules } from 'react-native'
+
+import { createInteractor } from '../architecture/Interactor'
+import { check } from '../utility/check'
+import { log } from '../utility/log'
+
+export const createDependency = () => {}
+
+type PlacementInteractor = {
+    click(
+        promiseID: string,
+        trackingLink: string,
+        onSuccess: () => void,
+        onFailure: (message: string) => void,
+    ): Promise<boolean>
+    impression(
+        promiseID: string,
+        trackingLink: string,
+        onSuccess: () => void,
+        onFailure: (message: string) => void,
+    ): Promise<boolean>
+}
+
+createDependency.PlacementModule = () => ({
+    emitter: new NativeEventEmitter(NativeModules.PlacementInteractor),
+    interactor: createInteractor<PlacementInteractor>(NativeModules.PlacementInteractor),
+})
+
+export type PlacementModule = ReturnType<typeof createPlacementModule>
+
+export const createPlacementModule= () => {
+    // create dependency
+    const { emitter, interactor } = createDependency.PlacementModule()
+
+    // define member
+    let id = 0
+
+    // define method
+    const click = async (
+        trackingLink: string,
+        onSuccess?: () => void,
+        onFailure?: (error: Error) => void
+    ): Promise<boolean> => {
+        if (!check.string(trackingLink)) {
+            log.unmatchedType('trackingLink', 'string')
+            return false
+        }
+        if (!(check.function(onSuccess) || check.undefined(onSuccess))) {
+            log.unmatchedType('onSuccess', 'function?')
+            return false
+        }
+        if (!(check.function(onFailure) || check.undefined(onFailure))) {
+            log.unmatchedType('onFailure', 'function?')
+            return false
+        }
+
+        const promiseID = `${id++}`
+
+        return new Promise((onResolve, onReject) => {
+            const subscription = emitter.addListener('airbridge.placement', (message) => {
+                if (message.id !== promiseID) {
+                    return
+                }
+                switch (message.type) {
+                    case 'onResolve':
+                        onResolve(message.value)
+                        break
+                    case 'onReject':
+                        onReject(Error(message.value))
+                        break
+                }
+                subscription.remove()
+            })
+
+            interactor.click(
+                promiseID,
+                trackingLink,
+                () => { onSuccess?.() },
+                (message: string) => { onFailure?.(Error(message)) }
+            )
+        })
+    }
+
+    const impression = async (
+        trackingLink: string,
+        onSuccess?: () => void,
+        onFailure?: (error: Error) => void
+    ): Promise<boolean> => {
+        if (!check.string(trackingLink)) {
+            log.unmatchedType('trackingLink', 'string')
+            return false
+        }
+        if (!(check.function(onSuccess) || check.undefined(onSuccess))) {
+            log.unmatchedType('onSuccess', 'function?')
+            return false
+        }
+        if (!(check.function(onFailure) || check.undefined(onFailure))) {
+            log.unmatchedType('onFailure', 'function?')
+            return false
+        }
+
+        const promiseID = `${id++}`
+
+        return new Promise((onResolve, onReject) => {
+            const subscription = emitter.addListener('airbridge.placement', (message) => {
+                if (message.id !== promiseID) {
+                    return
+                }
+                switch (message.type) {
+                    case 'onResolve':
+                        onResolve(message.value)
+                        break
+                    case 'onReject':
+                        onReject(Error(message.value))
+                        break
+                }
+                subscription.remove()
+            })
+
+            interactor.impression(
+                promiseID,
+                trackingLink,
+                () => { onSuccess?.() },
+                (message: string) => { onFailure?.(Error(message)) }
+            )
+        })
+    }
+
+    // create object
+    return {
+        click,
+        impression,
+    }
+}

package/source/module/Register.ts

@@ -0,0 +1,203 @@
+import { NativeModules } from 'react-native'
+
+import { createInteractor } from '../architecture/Interactor'
+import { check } from '../utility/check'
+import { log } from '../utility/log'
+import { checkJSONElement, createJSONElement } from '../utility/json'
+
+export const createDependency = () => {}
+
+type RegisterInteractor = {
+    setUserID(id: string): void
+    clearUserID(): void
+    setUserEmail(email: string): void
+    clearUserEmail(): void
+    setUserPhone(phone: string): void
+    clearUserPhone(): void
+
+    setUserAttribute(option: { key: string, value: any }): void
+    removeUserAttribute(key: string): void
+    clearUserAttributes(): void
+
+    setUserAlias(key: string, value: string): void
+    removeUserAlias(key: string): void
+    clearUserAlias(): void
+
+    clearUser(): void
+
+    setDeviceAlias(key: string, value: string): void
+    removeDeviceAlias(key: string): void
+    clearDeviceAlias(): void
+
+    registerPushToken(token: string): void
+}
+
+createDependency.RegisterModule = () => ({
+    interactor: createInteractor<RegisterInteractor>(NativeModules.RegisterInteractor),
+})
+
+export type RegisterModule = ReturnType<typeof createRegisterModule>
+
+export const createRegisterModule= () => {
+    // create dependency
+    const { interactor } = createDependency.RegisterModule()
+
+    // define method
+    const setUserID = (id: string) => {
+        if (!check.string(id)) {
+            log.unmatchedType('id', 'string')
+            return
+        }
+
+        interactor.setUserID(id)
+    }
+
+    const clearUserID = () => {
+        interactor.clearUserID()
+    }
+
+    const setUserEmail = (email: string) => {
+        if (!check.string(email)) {
+            log.unmatchedType('email', 'string')
+            return
+        }
+        
+        interactor.setUserEmail(email)
+    }
+
+    const clearUserEmail = () => {
+        interactor.clearUserEmail()
+    }
+
+    const setUserPhone = (phone: string) => {
+        if (!check.string(phone)) {
+            log.unmatchedType('phone', 'string')
+            return
+        }
+
+        interactor.setUserPhone(phone)
+    }
+
+    const clearUserPhone = () => {
+        interactor.clearUserPhone()
+    }
+
+    const setUserAttribute = (key: string, value: any) => {
+        if (!check.string(key)) {
+            log.unmatchedType('key', 'string')
+            return
+        }
+
+        if (check.defined(value) && !checkJSONElement(value)) {
+            log.nonJSONValue('value')
+            value = createJSONElement(value)
+        }
+
+        interactor.setUserAttribute({ key, value })
+    }
+
+    const removeUserAttribute = (key: string) => {
+        if (!check.string(key)) {
+            log.unmatchedType('key', 'string')
+            return
+        }
+
+        interactor.removeUserAttribute(key)
+    }
+
+    const clearUserAttributes = () => {
+        interactor.clearUserAttributes()
+    }
+
+    const setUserAlias = (key: string, value: string) => {
+        if (!check.string(key)) {
+            log.unmatchedType('key', 'string')
+            return
+        }
+        if (!check.string(value)) {
+            log.unmatchedType('value', 'string')
+            return
+        }
+
+        interactor.setUserAlias(key, value)
+    }
+
+    const removeUserAlias = (key: string) => {
+        if (!check.string(key)) {
+            log.unmatchedType('key', 'string')
+            return
+        }
+
+        interactor.removeUserAlias(key)
+    }
+
+    const clearUserAlias = () => {
+        interactor.clearUserAlias()
+    }
+
+    const clearUser = () => {
+        interactor.clearUser()
+    }
+
+    const setDeviceAlias = (key: string, value: string) => {
+        if (!check.string(key)) {
+            log.unmatchedType('key', 'string')
+            return
+        }
+        if (!check.string(value)) {
+            log.unmatchedType('value', 'string')
+            return
+        }
+
+        interactor.setDeviceAlias(key, value)
+    }
+
+
+    const removeDeviceAlias = (key: string) => {
+        if (!check.string(key)) {
+            log.unmatchedType('key', 'string')
+            return
+        }
+
+        interactor.removeDeviceAlias(key)
+    }
+    
+    const clearDeviceAlias = () => {
+        interactor.clearDeviceAlias()
+    }
+
+    const registerPushToken = (token: string) => {
+        if (!check.string(token)) {
+            log.unmatchedType('token', 'string')
+            return
+        }
+
+        interactor.registerPushToken(token)
+    }
+
+    // create object
+    return {
+        setUserID,
+        clearUserID,
+        setUserEmail,
+        clearUserEmail,
+        setUserPhone,
+        clearUserPhone,
+
+        setUserAttribute,
+        removeUserAttribute,
+        clearUserAttributes,
+
+        setUserAlias,
+        removeUserAlias,
+        clearUserAlias,
+
+        clearUser,
+
+        setDeviceAlias,
+        removeDeviceAlias,
+        clearDeviceAlias,
+
+        registerPushToken,
+    }
+}

package/source/module/Switch.ts

@@ -0,0 +1,61 @@
+import { NativeModules } from 'react-native'
+
+import { createInteractor } from '../architecture/Interactor'
+
+export const createDependency = () => {}
+
+type SwitchInteractor = {
+    enableSDK(): void
+    disableSDK(): void
+    isSDKEnabled(): Promise<boolean>
+
+    startTracking(): void
+    stopTracking(): void
+    isTrackingEnabled(): Promise<boolean>
+}
+
+createDependency.SwitchModule = () => ({
+    interactor: createInteractor<SwitchInteractor>(NativeModules.SwitchInteractor),
+})
+
+export type SwitchModule = ReturnType<typeof createSwitchModule>
+
+export const createSwitchModule= () => {
+    // create dependency
+    const { interactor } = createDependency.SwitchModule()
+
+    // define method
+    const enableSDK = () => {
+        interactor.enableSDK()
+    }
+
+    const disableSDK = () => {
+        interactor.disableSDK()
+    }
+
+    const isSDKEnabled = () => {
+        return interactor.isSDKEnabled()
+    }
+
+    const startTracking = () => {
+        interactor.startTracking()
+    }
+
+    const stopTracking = () => {
+        interactor.stopTracking()
+    }
+
+    const isTrackingEnabled = () => {
+        return interactor.isSDKEnabled()
+    }
+
+    // create object
+    return {
+        enableSDK,
+        disableSDK,
+        isSDKEnabled,
+        startTracking,
+        stopTracking,
+        isTrackingEnabled,
+    }
+}