@dashx/react-native 0.1.25 → 1.0.2

package/android/src/main/java/com/dashx/rn/sdk/DashXActivityLifecycleCallbacks.kt

@@ -1,93 +0,0 @@
-package com.dashx.rn.sdk
-
-import android.app.Activity
-import android.app.Application
-import android.content.Context
-import android.content.pm.PackageManager
-import android.os.Bundle
-import com.facebook.react.bridge.Arguments
-
-class DashXActivityLifecycleCallbacks : Application.ActivityLifecycleCallbacks {
-    private val dashXClient = DashXClientInterceptor.instance.getDashXClient()
-    private var startSession = System.currentTimeMillis().toDouble()
-
-    init {
-        dashXClient?.trackAppStarted()
-    }
-
-    override fun onActivityPaused(activity: Activity) {
-        if (!lifecycleTrackingEnabled) {
-            return
-        }
-
-        dashXClient?.trackAppSession(System.currentTimeMillis().toDouble() - startSession)
-    }
-
-    override fun onActivityResumed(activity: Activity) {
-        if (!lifecycleTrackingEnabled) {
-            return
-        }
-
-        startSession = System.currentTimeMillis().toDouble()
-        dashXClient?.trackAppStarted(fromBackground = true)
-    }
-
-    override fun onActivityStarted(activity: Activity) {
-        if (!screenTrackingEnabled) {
-            return
-        }
-
-        val packageManager = activity.packageManager
-        val info = packageManager?.getActivityInfo(activity.componentName, PackageManager.GET_META_DATA)
-        val activityLabel = info?.loadLabel(packageManager)
-        activityLabel?.let { it -> dashXClient?.screen(it.toString(), hashMapOf()) }
-    }
-
-    override fun onActivityDestroyed(activity: Activity) {
-
-    }
-
-    override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) {
-
-    }
-
-    override fun onActivityStopped(activity: Activity) {
-
-    }
-
-    override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {
-
-    }
-
-    companion object {
-        private var dashXActivityLifecycleCallbacks: DashXActivityLifecycleCallbacks? = null
-        private var screenTrackingEnabled = false
-        private var lifecycleTrackingEnabled = false
-
-        private fun registerCallbacks(context: Context) {
-            dashXActivityLifecycleCallbacks = DashXActivityLifecycleCallbacks()
-            val application = context as Application
-            application.registerActivityLifecycleCallbacks(dashXActivityLifecycleCallbacks)
-        }
-
-        fun enableActivityLifecycleTracking(context: Context) {
-            lifecycleTrackingEnabled = true
-
-            if (dashXActivityLifecycleCallbacks != null) {
-                return
-            }
-
-            registerCallbacks(context)
-        }
-
-        fun enableScreenTracking(context: Context) {
-            screenTrackingEnabled = true
-
-            if (dashXActivityLifecycleCallbacks != null) {
-                return
-            }
-
-            registerCallbacks(context)
-        }
-    }
-}

package/android/src/main/java/com/dashx/rn/sdk/DashXClientInterceptor.kt

@@ -1,66 +0,0 @@
-package com.dashx.rn.sdk
-
-import android.content.Context
-import com.dashx.sdk.DashXClient as DashX
-import com.dashx.sdk.DashXLog
-import com.facebook.react.bridge.*
-import com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter
-import com.google.firebase.messaging.RemoteMessage
-
-class DashXClientInterceptor private constructor() {
-    private val tag = DashXClientInterceptor::class.java.simpleName
-
-    private var client: com.dashx.sdk.DashXClient? = null
-    var reactApplicationContext: ReactApplicationContext? = null
-    private val dashXNotificationFilter = "DASHX_PN_TYPE"
-
-    fun createDashXClient(reactApplicationContext: ReactApplicationContext, publicKey: String, baseURI: String?, targetEnvironment: String?, targetInstallation: String?) {
-        this.reactApplicationContext = reactApplicationContext
-        client = DashX(reactApplicationContext.applicationContext, publicKey, baseURI, targetEnvironment, targetInstallation)
-    }
-
-    fun getDashXClient(): com.dashx.sdk.DashXClient? {
-        return client
-    }
-
-    fun handleMessage(remoteMessage: RemoteMessage) {
-        val notificationData = remoteMessage.getData()
-
-        DashXLog.d(tag, "Notification Data: " + notificationData)
-
-        val eventProperties: WritableMap = Arguments.createMap()
-
-        try {
-            eventProperties.putMap("data", convertToWritableMap(notificationData, listOf(dashXNotificationFilter)))
-        } catch (e: Exception) {
-            e.printStackTrace()
-            DashXLog.d(tag, "Encountered an error while parsing notification data.")
-        }
-
-        val notification = remoteMessage.getNotification()
-
-        if (notification != null) {
-            val notificationProperties: WritableMap = Arguments.createMap()
-            notificationProperties.putString("title", notification.getTitle())
-            notificationProperties.putString("body", notification.getBody())
-
-            eventProperties.putMap("notification", notificationProperties)
-
-            DashXLog.d(tag, "onMessageReceived with Title: " + notification.getTitle() + " and Body: " + notification.getBody())
-        }
-
-        sendJsEvent("messageReceived", eventProperties)
-    }
-
-    private fun sendJsEvent(eventName: String, params: WritableMap) {
-        reactApplicationContext
-            ?.getJSModule(RCTDeviceEventEmitter::class.java)
-            ?.emit(eventName, params)
-    }
-
-    companion object {
-        val instance: DashXClientInterceptor by lazy {
-            DashXClientInterceptor()
-        }
-    }
-}

package/android/src/main/java/com/dashx/rn/sdk/DashXExceptionHandler.kt

@@ -1,28 +0,0 @@
-package com.dashx.rn.sdk
-
-class DashXExceptionHandler(private val mainExceptionHandler: Thread.UncaughtExceptionHandler)
-    : Thread.UncaughtExceptionHandler {
-    private val dashXClient = DashXClientInterceptor.instance.getDashXClient()
-
-    companion object {
-        fun enable() {
-            val defaultExceptionHandler = Thread.getDefaultUncaughtExceptionHandler()
-            if (defaultExceptionHandler is DashXExceptionHandler) {
-                return
-            }
-
-            if (defaultExceptionHandler != null) {
-                val dashXExceptionHandler = DashXExceptionHandler(defaultExceptionHandler)
-                Thread.setDefaultUncaughtExceptionHandler(dashXExceptionHandler)
-            }
-        }
-    }
-
-    override fun uncaughtException(thread: Thread, exception: Throwable) {
-        if (dashXClient != null) {
-            dashXClient.trackAppCrashed(exception)
-        }
-
-        mainExceptionHandler.uncaughtException(thread, exception)
-    }
-}

package/android/src/main/java/com/dashx/rn/sdk/DashXMessagingService.kt

@@ -1,176 +0,0 @@
-package com.dashx.rn.sdk
-
-import android.app.Activity
-import android.app.ActivityManager
-import android.app.Notification
-import android.app.NotificationChannel
-import android.app.NotificationManager
-import android.app.PendingIntent
-import android.content.Context
-import android.content.Intent
-import android.content.pm.PackageManager
-import android.media.RingtoneManager
-import android.os.Build
-import android.widget.RemoteViews
-import androidx.core.app.NotificationCompat
-import androidx.core.app.NotificationManagerCompat
-import com.dashx.sdk.DashXLog
-import com.google.firebase.messaging.FirebaseMessagingService
-import com.google.firebase.messaging.RemoteMessage
-import com.google.gson.annotations.SerializedName
-import com.google.gson.Gson
-
-data class DashXPayload(
-    @SerializedName("id") val id: String,
-    @SerializedName("title") val title: String?,
-    @SerializedName("body") val body: String?,
-)
-
-class DashXMessagingService : FirebaseMessagingService() {
-    private val tag = DashXMessagingService::class.java.simpleName
-    private val dashXClient = DashXClientInterceptor.instance.getDashXClient()
-    private val notificationReceiverClass: Class<*> = NotificationReceiver::class.java
-
-    override fun onNewToken(token: String) {
-        super.onNewToken(token)
-        DashXLog.d(tag, "onNewToken: $token")
-
-        if (dashXClient != null) {
-            dashXClient.setDeviceToken(token)
-        }
-    }
-
-    override fun onMessageReceived(remoteMessage: RemoteMessage) {
-        super.onMessageReceived(remoteMessage)
-
-        if (appInForeground()) {
-            return
-        }
-
-        val dashxDataMap = remoteMessage.getData()["dashx"]
-
-        if (dashxDataMap != null) {
-            val gson = Gson()
-            var dashxData = gson.fromJson(dashxDataMap, DashXPayload::class.java)
-
-            val id = dashxData.id
-            val title = dashxData.title
-            val body = dashxData.body
-
-            if ((title != null) || (body != null)) {
-                createNotificationChannel()
-
-                NotificationManagerCompat.from(this)
-                    .notify(id, 1, createNotification(id, title, body))
-            }
-        }
-
-        DashXClientInterceptor.instance.handleMessage(remoteMessage)
-    }
-
-    private fun createNotificationChannel() {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            val channel = NotificationChannel(
-                CHANNEL_ID,
-                CHANNEL_NAME,
-                NotificationManager.IMPORTANCE_DEFAULT
-            )
-
-            channel.description = CHANNEL_DESCRIPTION
-
-            (getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager)
-                .createNotificationChannel(channel)
-        }
-    }
-
-    private fun createNotification(
-        id: String,
-        title: String?,
-        body: String?
-    ) : Notification {
-        val pendingIntent = getNewPendingIntent()
-
-        val notificationBuilder = NotificationCompat.Builder(this, CHANNEL_ID)
-            .setSmallIcon(getSmallIcon())
-            .setContentTitle(title)
-            .setContentText(body)
-            .setPriority(NotificationCompat.PRIORITY_DEFAULT)
-            .setContentIntent(pendingIntent)
-            .setAutoCancel(true)
-
-        return notificationBuilder.build()
-    }
-
-    private fun getNewPendingIntent(): PendingIntent {
-        val context = getApplicationContext()
-        val pendingIntentFlags = PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
-
-        val intent = getNewBaseIntent()
-
-        val launchIntent = context.packageManager.getLaunchIntentForPackage(context.packageName)
-
-        if (launchIntent == null) {
-            return PendingIntent.getActivity(context, 1, intent, pendingIntentFlags)
-        }
-
-        // Mimic launcher behaviour
-        launchIntent.setPackage(null)
-        launchIntent.flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED
-
-        return PendingIntent.getActivities(
-            context,
-            1,
-            arrayOf(launchIntent, intent),
-            pendingIntentFlags
-        )
-    }
-
-    private fun getNewBaseIntent(): Intent {
-        return Intent(
-            this,
-            notificationReceiverClass
-        ).addFlags(
-            Intent.FLAG_ACTIVITY_SINGLE_TOP or
-            Intent.FLAG_ACTIVITY_CLEAR_TOP
-        )
-    }
-
-    private fun getSmallIcon(): Int {
-        val context = getApplicationContext()
-        val ai = context.getPackageManager().getApplicationInfo(context.getPackageName(), PackageManager.GET_META_DATA)
-
-        var smallIconInt: Int
-
-        try {
-            val smallIcon = ai.metaData.get(DX_NOTIFICATION_ICON)
-
-            if (smallIcon == null) {
-                throw IllegalArgumentException()
-            }
-
-            smallIconInt = context.getResources().getIdentifier(smallIcon as String, "drawable", context.getPackageName())
-
-            if (smallIconInt == 0) {
-                throw IllegalArgumentException()
-            }
-        } catch (e: IllegalArgumentException) {
-            smallIconInt = ai.icon
-        }
-
-        return smallIconInt
-    }
-
-    fun appInForeground(): Boolean {
-        val context = getApplicationContext()
-        val activityManager = context.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
-        val runningAppProcesses = activityManager.runningAppProcesses ?: return false
-        return runningAppProcesses.any { it.processName == context.packageName && it.importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND }
-    }
-
-    companion object {
-        private const val CHANNEL_NAME = "DashX Notification"
-        private const val CHANNEL_DESCRIPTION = "DashX's default notification channel"
-        private const val CHANNEL_ID = "DASHX_NOTIFICATION_CHANNEL"
-        private const val DX_NOTIFICATION_ICON = "DX_NOTIFICATION_ICON"
-    }
-}

package/android/src/main/java/com/dashx/rn/sdk/DashXModule.kt

@@ -1,193 +0,0 @@
-package com.dashx.rn.sdk
-
-import com.facebook.react.bridge.*
-import com.dashx.sdk.DashXLog
-import com.google.android.gms.tasks.OnCompleteListener
-import com.google.firebase.messaging.FirebaseMessaging
-
-class DashXModule(private val reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
-    private val tag = DashXModule::class.java.simpleName
-    private var interceptor: DashXClientInterceptor = DashXClientInterceptor.instance
-
-
-    override fun getName(): String {
-        return "DashX"
-    }
-
-    @ReactMethod
-    fun setLogLevel(logLevel: Int) {
-        DashXLog.setLogLevel(logLevel)
-    }
-
-    @ReactMethod
-    fun setup(options: ReadableMap) {
-        interceptor.createDashXClient(
-            reactContext,
-            options.getString("publicKey")!!,
-            options.getStringIfPresent("baseUri"),
-            options.getStringIfPresent("targetEnvironment"),
-            options.getStringIfPresent("targetInstallation")
-        )
-        interceptor.getDashXClient()?.generateAnonymousUid()
-
-        if (options.hasKey("trackAppLifecycleEvents") && options.getBoolean("trackAppLifecycleEvents")) {
-            DashXExceptionHandler.enable()
-            DashXActivityLifecycleCallbacks.enableActivityLifecycleTracking(reactContext.applicationContext)
-        }
-
-        if (options.hasKey("trackScreenViews") && options.getBoolean("trackScreenViews")) {
-            DashXActivityLifecycleCallbacks.enableScreenTracking(reactContext.applicationContext)
-        }
-
-        FirebaseMessaging.getInstance().getToken()
-            .addOnCompleteListener(OnCompleteListener { task ->
-                if (!task.isSuccessful) {
-                    DashXLog.d(tag, "FirebaseMessaging.getInstance().getToken() failed: $task.exception")
-                    return@OnCompleteListener
-                }
-
-                val token = task.getResult()
-                token?.let { it -> interceptor.getDashXClient()?.setDeviceToken(it) }
-                DashXLog.d(tag, "Firebase Initialised with: $token")
-            });
-    }
-
-    @ReactMethod
-    fun identify(uid: String?, options: ReadableMap?) {
-        val optionsHashMap = options?.toHashMap()
-        interceptor.getDashXClient()?.identify(uid, optionsHashMap as HashMap<String, String>?)
-    }
-
-    @ReactMethod
-    fun reset() {
-        interceptor.getDashXClient()?.reset()
-    }
-
-    @ReactMethod
-    fun track(event: String, data: ReadableMap?) {
-        val jsonData = try {
-            data?.toHashMap() as HashMap<String, String>
-        } catch (e: Exception) {
-            DashXLog.d(tag, e.message)
-            return
-        }
-
-        interceptor.getDashXClient()?.track(event, jsonData)
-    }
-
-    @ReactMethod
-    fun screen(screenName: String, data: ReadableMap?) {
-        interceptor.getDashXClient()?.screen(screenName, data?.toHashMap() as HashMap<String, String>)
-    }
-
-    @ReactMethod
-    fun setIdentityToken(identityToken: String) {
-        interceptor.getDashXClient()?.setIdentityToken(identityToken)
-    }
-
-    @ReactMethod
-    fun fetchContent(urn: String, options: ReadableMap?, promise: Promise) {
-        interceptor.getDashXClient()?.fetchContent(
-            urn,
-            options?.getBooleanIfPresent("preview"),
-            options?.getStringIfPresent("language"),
-            options?.getArray("fields")?.toArrayList() as List<String>?,
-            options?.getArray("include")?.toArrayList() as List<String>?,
-            options?.getArray("exclude")?.toArrayList() as List<String>?,
-            onError = {
-                promise.reject("EUNSPECIFIED", it)
-            },
-            onSuccess = {
-                promise.resolve(convertJsonToMap(it))
-            }
-        )
-    }
-
-    @ReactMethod
-    fun searchContent(contentType: String, options: ReadableMap?, promise: Promise) {
-        val jsonFilter = try {
-            convertMapToJson(options?.getMap("filter"))
-        } catch (e: Exception) {
-            DashXLog.d(tag, e.message)
-            throw Exception("Encountered an error while parsing filter")
-        }
-
-        val jsonOrder = try {
-            convertMapToJson(options?.getMap("order"))
-        } catch (e: Exception) {
-            DashXLog.d(tag, e.message)
-            throw Exception("Encountered an error while parsing order")
-        }
-
-        interceptor.getDashXClient()?.searchContent(
-            contentType,
-            options?.getString("returnType") ?: "all",
-            jsonFilter,
-            jsonOrder,
-            options?.getIntIfPresent("limit"),
-            options?.getBooleanIfPresent("preview"),
-            options?.getStringIfPresent("language"),
-            options?.getArray("fields")?.toArrayList() as List<String>?,
-            options?.getArray("include")?.toArrayList() as List<String>?,
-            options?.getArray("exclude")?.toArrayList() as List<String>?,
-            onError = {
-                promise.reject("EUNSPECIFIED", it)
-            },
-            onSuccess = { content ->
-                val readableArray = Arguments.createArray()
-                content.forEach {
-                    readableArray.pushMap(convertJsonToMap(it))
-                }
-                promise.resolve(readableArray)
-            }
-        )
-    }
-
-    @ReactMethod
-    fun addItemToCart(
-        itemId: String,
-        pricingId: String,
-        quantity: String,
-        reset: Boolean? = false,
-        custom: ReadableMap? = null,
-        promise: Promise
-    ) {
-        val jsonCustom = try {
-            convertMapToJson(custom)
-        } catch (e: Exception) {
-            DashXLog.d(tag, e.message)
-            throw Exception("Encountered an error while parsing custom")
-        }
-
-        interceptor.getDashXClient()?.addItemToCart(
-            itemId,
-            pricingId,
-            quantity,
-            reset ?: false,
-            jsonCustom,
-            onError = {
-                promise.reject("EUNSPECIFIED", it)
-            },
-            onSuccess = { content ->
-                promise.resolve(convertJsonToMap(content))
-            }
-        )
-    }
-
-    @ReactMethod
-    fun fetchCart(promise: Promise) {
-        interceptor.getDashXClient()?.fetchCart(
-            onError = {
-                promise.reject("EUNSPECIFIED", it)
-            },
-            onSuccess = { content ->
-                promise.resolve(convertJsonToMap(content))
-            }
-        )
-    }
-
-    @ReactMethod
-    fun subscribe() {
-        interceptor.getDashXClient()?.subscribe()
-    }
-}

package/android/src/main/java/com/dashx/rn/sdk/NotificationReceiver.kt

@@ -1,17 +0,0 @@
-package com.dashx.rn.sdk
-
-import android.app.Activity
-import android.content.Intent
-import android.os.Bundle
-
-class NotificationReceiver : Activity() {
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        finish()
-    }
-
-    override fun onNewIntent(intent: Intent) {
-        super.onNewIntent(intent)
-        finish()
-    }
-}