@dashx/react-native 1.1.4 → 1.2.0

package/__tests__/index.test.js

@@ -16,6 +16,8 @@ const mockNativeModule = {
   fetchAsset: jest.fn(),
   enableLifecycleTracking: jest.fn(),
   enableAdTracking: jest.fn(),
+  processURL: jest.fn(),
+  trackNotificationNavigation: jest.fn(),
   requestNotificationPermission: jest.fn(),
   getNotificationPermissionStatus: jest.fn(),
   addListener: jest.fn(),
@@ -32,8 +34,18 @@ jest.mock('react-native', () => ({
     addListener: mockAddListener,
   })),
   Platform: {
+    OS: 'ios',
     select: jest.fn((obj) => obj.default || ''),
   },
+  TurboModuleRegistry: {
+    get: jest.fn(() => mockNativeModule),
+    getEnforcing: jest.fn(() => mockNativeModule),
+  },
+}));
+
+jest.mock('../src/NativeDashXReactNative', () => ({
+  __esModule: true,
+  default: mockNativeModule,
 }));
 
 const DashX = require('../index').default;
@@ -98,10 +110,14 @@ describe('setIdentity', () => {
     expect(() => DashX.setIdentity(null, 'token')).toThrow('uid is required');
   });
 
-  it('throws if token is missing', () => {
-    expect(() => DashX.setIdentity('uid', null)).toThrow(
-      'token is required'
-    );
+  it('passes null token through to native', () => {
+    DashX.setIdentity('uid', null);
+    expect(mockNativeModule.setIdentity).toHaveBeenCalledWith('uid', null);
+  });
+
+  it('passes undefined token as null to native', () => {
+    DashX.setIdentity('uid');
+    expect(mockNativeModule.setIdentity).toHaveBeenCalledWith('uid', null);
   });
 });
 
@@ -325,6 +341,133 @@ describe('fetchAsset', () => {
   });
 });
 
+// --- processURL ---
+
+describe('processURL', () => {
+  it('calls native processURL with defaults', () => {
+    DashX.processURL('https://example.com/path');
+    expect(mockNativeModule.processURL).toHaveBeenCalledWith(
+      'https://example.com/path',
+      null,
+      true
+    );
+  });
+
+  it('passes source option', () => {
+    DashX.processURL('https://example.com', { source: 'universal_link' });
+    expect(mockNativeModule.processURL).toHaveBeenCalledWith(
+      'https://example.com',
+      'universal_link',
+      true
+    );
+  });
+
+  it('passes forwardToLinkHandler as false', () => {
+    DashX.processURL('https://example.com', { forwardToLinkHandler: false });
+    expect(mockNativeModule.processURL).toHaveBeenCalledWith(
+      'https://example.com',
+      null,
+      false
+    );
+  });
+
+  it('throws if url is missing', () => {
+    expect(() => DashX.processURL(null)).toThrow('url is required');
+  });
+
+  it('throws if url is not a string', () => {
+    expect(() => DashX.processURL(123)).toThrow(
+      'url is required and must be a string'
+    );
+  });
+
+  it('no-ops on Android', () => {
+    const { Platform } = require('react-native');
+    Platform.OS = 'android';
+    DashX.processURL('https://example.com');
+    expect(mockNativeModule.processURL).not.toHaveBeenCalled();
+    Platform.OS = 'ios';
+  });
+});
+
+// --- trackNotificationNavigation ---
+
+describe('trackNotificationNavigation', () => {
+  it('calls native with deepLink action', () => {
+    DashX.trackNotificationNavigation(
+      { type: 'deepLink', url: 'https://example.com' },
+      'notif-1'
+    );
+    expect(mockNativeModule.trackNotificationNavigation).toHaveBeenCalledWith(
+      { type: 'deepLink', url: 'https://example.com' },
+      'notif-1'
+    );
+  });
+
+  it('calls native with screen action', () => {
+    DashX.trackNotificationNavigation(
+      { type: 'screen', name: 'Home', data: { ref: 'banner' } },
+      'notif-2'
+    );
+    expect(mockNativeModule.trackNotificationNavigation).toHaveBeenCalledWith(
+      { type: 'screen', name: 'Home', data: { ref: 'banner' } },
+      'notif-2'
+    );
+  });
+
+  it('calls native with richLanding action', () => {
+    DashX.trackNotificationNavigation(
+      { type: 'richLanding', url: 'https://promo.example.com' },
+      'notif-3'
+    );
+    expect(mockNativeModule.trackNotificationNavigation).toHaveBeenCalledWith(
+      { type: 'richLanding', url: 'https://promo.example.com' },
+      'notif-3'
+    );
+  });
+
+  it('calls native with clickAction action', () => {
+    DashX.trackNotificationNavigation(
+      { type: 'clickAction', action: 'OPEN_SETTINGS' },
+      'notif-4'
+    );
+    expect(mockNativeModule.trackNotificationNavigation).toHaveBeenCalledWith(
+      { type: 'clickAction', action: 'OPEN_SETTINGS' },
+      'notif-4'
+    );
+  });
+
+  it('calls native with null action when omitted', () => {
+    DashX.trackNotificationNavigation(null, 'notif-5');
+    expect(mockNativeModule.trackNotificationNavigation).toHaveBeenCalledWith(
+      null,
+      'notif-5'
+    );
+  });
+
+  it('calls native with null for both when both omitted', () => {
+    DashX.trackNotificationNavigation();
+    expect(mockNativeModule.trackNotificationNavigation).toHaveBeenCalledWith(
+      null,
+      null
+    );
+  });
+
+  it('throws if action is not an object', () => {
+    expect(() => DashX.trackNotificationNavigation('bad')).toThrow(
+      'action must be an object or null'
+    );
+  });
+
+  it('no-ops on Android', () => {
+    const { Platform } = require('react-native');
+    Platform.OS = 'android';
+    DashX.trackNotificationNavigation({ type: 'deepLink', url: 'https://example.com' });
+    expect(mockNativeModule.trackNotificationNavigation).not.toHaveBeenCalled();
+    Platform.OS = 'ios';
+  });
+});
+
 // --- requestNotificationPermission / getNotificationPermissionStatus ---
 
 describe('requestNotificationPermission', () => {

package/android/build.gradle

@@ -3,6 +3,14 @@ import groovy.json.JsonSlurper
 apply plugin: 'com.android.library'
 apply plugin: 'kotlin-android'
 
+def isNewArchitectureEnabled() {
+    return project.hasProperty("newArchEnabled") && project.newArchEnabled == "true"
+}
+
+if (isNewArchitectureEnabled()) {
+    apply plugin: 'com.facebook.react'
+}
+
 def getVersionFromNpm() {
     def inputFile = new File("../package.json")
     def packageJson = new JsonSlurper().parseText(inputFile.text)
@@ -30,6 +38,16 @@ android {
         abortOnError false
     }
 
+    sourceSets {
+        main {
+            if (isNewArchitectureEnabled()) {
+                java.srcDirs += ['src/newarch/java']
+            } else {
+                java.srcDirs += ['src/oldarch/java']
+            }
+        }
+    }
+
     packaging {
         pickFirst 'lib/arm64-v8a/libc++_shared.so'
         pickFirst 'lib/arm64-v8a/libfbjni.so'
@@ -42,6 +60,14 @@ android {
    }
 }
 
+if (isNewArchitectureEnabled()) {
+    react {
+        jsRootDir = file("../src/")
+        libraryName = "RNDashXReactNativeSpec"
+        codegenJavaPackageName = "com.dashx.rn.sdk"
+    }
+}
+
 repositories {
     mavenCentral()
     google()
@@ -55,5 +81,5 @@ dependencies {
     // Ensure Firebase Messaging types are available for FCM service subclass
     implementation 'com.google.firebase:firebase-messaging-ktx:23.1.2'
 
-    implementation "com.dashx:dashx-android:1.1.7"
+    implementation "com.dashx:dashx-android:1.2.5"
 }

package/android/src/main/AndroidManifest.xml

@@ -1,5 +1,8 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:tools="http://schemas.android.com/tools">
+
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+
     <application>
         <!-- Replace dashx-android's FCM service with our subclass that also emits to JS. -->
         <service

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

@@ -0,0 +1,384 @@
+package com.dashx.rn.sdk
+
+import android.Manifest
+import android.app.Activity
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.content.Context
+import android.content.pm.PackageManager
+import android.os.Build
+import androidx.core.app.ActivityCompat
+import androidx.core.content.ContextCompat
+import com.dashx.rn.sdk.util.*
+import com.dashx.android.DashX
+import com.dashx.android.DashXLog
+import com.dashx.android.DashXLog.LogLevel
+import com.dashx.android.data.Asset
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.PermissionAwareActivity
+import com.facebook.react.modules.core.PermissionListener
+import kotlinx.serialization.decodeFromString
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonObject
+
+class DashXReactNativeModuleImpl(private val reactContext: ReactApplicationContext) {
+    private val tag = DashXReactNativeModuleImpl::class.java.simpleName
+
+    fun initialize() {
+        MessageReceivedEventHolder.reactContext = reactContext
+    }
+
+    fun invalidate() {
+        MessageReceivedEventHolder.reactContext = null
+    }
+
+    fun setLogLevel(level: Double) {
+        // JS contract: 0 = off, 1 = errors, 2 = debug
+        // Native SDK:  OFF = -1, ERROR = 0, INFO = 1, DEBUG = 2
+        val logLevel = when (level.toInt()) {
+            0 -> LogLevel.OFF
+            1 -> LogLevel.ERROR
+            2 -> LogLevel.DEBUG
+            else -> LogLevel.OFF
+        }
+        DashXLog.setLogLevel(logLevel)
+    }
+
+    fun configure(options: ReadableMap) {
+        createDefaultNotificationChannel()
+        DashX.configure(
+            reactContext,
+            options.getString("publicKey")!!,
+            options.getStringIfPresent("baseURI"),
+            options.getStringIfPresent("targetEnvironment")
+        )
+    }
+
+    private fun createDefaultNotificationChannel() {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return
+        val notificationManager = reactContext.getSystemService(Context.NOTIFICATION_SERVICE) as? NotificationManager ?: return
+
+        val existing = notificationManager.getNotificationChannel(DEFAULT_CHANNEL_ID)
+        if (existing != null) return
+
+        val channel = NotificationChannel(
+            DEFAULT_CHANNEL_ID,
+            DEFAULT_CHANNEL_NAME,
+            NotificationManager.IMPORTANCE_HIGH
+        ).apply {
+            enableVibration(true)
+            setShowBadge(true)
+            lockscreenVisibility = android.app.Notification.VISIBILITY_PUBLIC
+        }
+        notificationManager.createNotificationChannel(channel)
+    }
+
+    fun identify(options: ReadableMap?) {
+        val optionsHashMap = options?.toHashMap()
+            ?.filterValues { it != null }
+            ?.mapValues { it.value.toString() }
+        DashX.identify(optionsHashMap?.let { HashMap(it) })
+    }
+
+    fun setIdentity(uid: String?, token: String?) {
+        DashX.setIdentity(uid, token)
+    }
+
+    fun reset() {
+        DashX.reset()
+    }
+
+    fun track(event: String, data: ReadableMap?) {
+        val jsonData = try {
+            data?.toHashMap()
+                ?.filterValues { it != null }
+                ?.mapValues { it.value.toString() }
+                ?.let { HashMap(it) }
+        } catch (e: Exception) {
+            DashXLog.d(tag, "Failed to convert track data, sending event without data: ${e.message}")
+            null
+        }
+
+        DashX.track(event, jsonData)
+    }
+
+    fun screen(screenName: String, data: ReadableMap?) {
+        val screenData = data?.toHashMap()
+            ?.filterValues { it != null }
+            ?.mapValues { it.value.toString() }
+            ?.let { HashMap(it) }
+            ?: HashMap()
+        DashX.screen(screenName, screenData)
+    }
+
+    fun fetchRecord(urn: String, options: ReadableMap?, promise: Promise) {
+        val preview = options?.getBooleanIfPresent("preview")
+        val language = options?.getStringIfPresent("language")
+        val fields = try {
+            convertReadableArrayToKJsonList(options?.getArray("fields"))
+        } catch (e: Exception) {
+            DashXLog.d(tag, e.message)
+            promise.reject(E_UNSPECIFIED, "Error parsing fields: ${e.message}")
+            return
+        }
+        val include = try {
+            convertReadableArrayToKJsonList(options?.getArray("include"))
+        } catch (e: Exception) {
+            DashXLog.d(tag, e.message)
+            promise.reject(E_UNSPECIFIED, "Error parsing include: ${e.message}")
+            return
+        }
+        val exclude = try {
+            convertReadableArrayToKJsonList(options?.getArray("exclude"))
+        } catch (e: Exception) {
+            DashXLog.d(tag, e.message)
+            promise.reject(E_UNSPECIFIED, "Error parsing exclude: ${e.message}")
+            return
+        }
+
+        DashX.fetchRecord(
+            urn = urn,
+            preview = preview,
+            language = language,
+            fields = fields,
+            include = include,
+            exclude = exclude,
+            onError = {
+                promise.reject(E_UNSPECIFIED, it.message)
+            },
+            onSuccess = {
+                promise.resolve(convertJsonToMap(convertKJsonToJson(it)))
+            }
+        )
+    }
+
+    fun searchRecords(resource: String, options: ReadableMap?, promise: Promise) {
+        val jsonFilter = try {
+            convertMapToJson(options?.getMap("filter"))?.let { convertJsonToKJson(it) }
+        } catch (e: Exception) {
+            DashXLog.d(tag, e.message)
+            promise.reject(E_UNSPECIFIED, "Error parsing filter: ${e.message}")
+            return
+        }
+        val order = try {
+            convertReadableArrayToKJsonList(options?.getArray("order"))
+        } catch (e: Exception) {
+            DashXLog.d(tag, e.message)
+            promise.reject(E_UNSPECIFIED, "Error parsing order: ${e.message}")
+            return
+        }
+        val limit = options?.getIntIfPresent("limit")
+        val preview = options?.getBooleanIfPresent("preview")
+        val language = options?.getStringIfPresent("language")
+        val fields = try {
+            convertReadableArrayToKJsonList(options?.getArray("fields"))
+        } catch (e: Exception) {
+            DashXLog.d(tag, e.message)
+            promise.reject(E_UNSPECIFIED, "Error parsing fields: ${e.message}")
+            return
+        }
+        val include = try {
+            convertReadableArrayToKJsonList(options?.getArray("include"))
+        } catch (e: Exception) {
+            DashXLog.d(tag, e.message)
+            promise.reject(E_UNSPECIFIED, "Error parsing include: ${e.message}")
+            return
+        }
+        val exclude = try {
+            convertReadableArrayToKJsonList(options?.getArray("exclude"))
+        } catch (e: Exception) {
+            DashXLog.d(tag, e.message)
+            promise.reject(E_UNSPECIFIED, "Error parsing exclude: ${e.message}")
+            return
+        }
+
+        DashX.searchRecords(
+            resource = resource,
+            filter = jsonFilter,
+            order = order,
+            limit = limit,
+            preview = preview,
+            language = language,
+            fields = fields,
+            include = include,
+            exclude = exclude,
+            onError = {
+                promise.reject(E_UNSPECIFIED, it.message)
+            },
+            onSuccess = { records ->
+                val readableArray = Arguments.createArray()
+                records.forEach {
+                    readableArray.pushMap(convertJsonToMap(convertKJsonToJson(it)))
+                }
+                promise.resolve(readableArray)
+            }
+        )
+    }
+
+    fun fetchStoredPreferences(promise: Promise) {
+        DashX.fetchStoredPreferences(
+            onError = {
+                promise.reject(E_UNSPECIFIED, it.message)
+            },
+            onSuccess = { content ->
+                promise.resolve(convertJsonToMap(convertKJsonToJson(Json.decodeFromString<JsonObject>(Json.encodeToString(content)))))
+            }
+        )
+    }
+
+    fun saveStoredPreferences(preferenceData: ReadableMap?, promise: Promise) {
+        val preferencesString = MapUtil.toJSONElement(preferenceData).toString()
+
+        DashX.saveStoredPreferences(
+            Json.decodeFromString<JsonObject>(preferencesString),
+            onError = {
+                promise.reject(E_UNSPECIFIED, it.message)
+            },
+            onSuccess = { content ->
+                promise.resolve(convertJsonToMap(convertKJsonToJson(Json.decodeFromString<JsonObject>(Json.encodeToString(content)))))
+            }
+        )
+    }
+
+    fun subscribe() {
+        DashX.subscribe()
+    }
+
+    fun unsubscribe() {
+        DashX.unsubscribe()
+    }
+
+    // --- iOS-only methods: no-op stubs on Android (JS guards prevent these from being called) ---
+
+    fun enableLifecycleTracking() {
+        // iOS-only; no-op on Android
+    }
+
+    fun enableAdTracking() {
+        // iOS-only; no-op on Android
+    }
+
+    fun processURL(url: String, source: String?, forwardToLinkHandler: Boolean) {
+        // iOS-only; no-op on Android
+    }
+
+    fun trackNotificationNavigation(action: ReadableMap?, notificationId: String?) {
+        // iOS-only; no-op on Android
+    }
+
+    fun uploadAsset(filePath: String, resource: String, attribute: String, promise: Promise) {
+        val file = java.io.File(filePath)
+        DashX.uploadAsset(
+            file = file,
+            resource = resource,
+            attribute = attribute,
+            onSuccess = { asset ->
+                try {
+                    val jsonString = Json.encodeToString(asset)
+                    val jsonObject = org.json.JSONObject(jsonString)
+                    promise.resolve(convertJsonToMap(jsonObject))
+                } catch (e: Exception) {
+                    promise.resolve(null)
+                }
+            },
+            onError = {
+                promise.reject(E_UNSPECIFIED, it.message)
+            }
+        )
+    }
+
+    fun fetchAsset(assetId: String, promise: Promise) {
+        DashX.fetchAsset(
+            assetId = assetId,
+            onSuccess = { asset ->
+                try {
+                    val jsonString = Json.encodeToString(asset)
+                    val jsonObject = org.json.JSONObject(jsonString)
+                    promise.resolve(convertJsonToMap(jsonObject))
+                } catch (e: Exception) {
+                    promise.resolve(null)
+                }
+            },
+            onError = {
+                promise.reject(E_UNSPECIFIED, it.message)
+            }
+        )
+    }
+
+    fun requestNotificationPermission(promise: Promise) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
+            promise.resolve(PERMISSION_AUTHORIZED)
+            return
+        }
+
+        val alreadyGranted = ContextCompat.checkSelfPermission(
+            reactContext,
+            Manifest.permission.POST_NOTIFICATIONS
+        ) == PackageManager.PERMISSION_GRANTED
+        if (alreadyGranted) {
+            promise.resolve(PERMISSION_AUTHORIZED)
+            return
+        }
+
+        val activity = reactContext.currentActivity as? PermissionAwareActivity
+        if (activity == null) {
+            promise.reject(E_UNSPECIFIED, "No current activity to request permission from")
+            return
+        }
+
+        reactContext.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+            .edit()
+            .putBoolean(KEY_PERMISSION_REQUESTED, true)
+            .apply()
+
+        val listener = PermissionListener { requestCode, _, grantResults ->
+            if (requestCode != NOTIFICATION_PERMISSION_REQUEST_CODE) return@PermissionListener false
+            val granted = grantResults.isNotEmpty() && grantResults[0] == PackageManager.PERMISSION_GRANTED
+            promise.resolve(if (granted) PERMISSION_AUTHORIZED else PERMISSION_DENIED)
+            true
+        }
+
+        activity.requestPermissions(
+            arrayOf(Manifest.permission.POST_NOTIFICATIONS),
+            NOTIFICATION_PERMISSION_REQUEST_CODE,
+            listener
+        )
+    }
+
+    fun getNotificationPermissionStatus(promise: Promise) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
+            promise.resolve(PERMISSION_AUTHORIZED)
+            return
+        }
+        val granted = ContextCompat.checkSelfPermission(
+            reactContext,
+            Manifest.permission.POST_NOTIFICATIONS
+        ) == PackageManager.PERMISSION_GRANTED
+        if (granted) {
+            promise.resolve(PERMISSION_AUTHORIZED)
+        } else {
+            val wasRequested = reactContext
+                .getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+                .getBoolean(KEY_PERMISSION_REQUESTED, false)
+            promise.resolve(if (wasRequested) PERMISSION_DENIED else PERMISSION_NOT_DETERMINED)
+        }
+    }
+
+    companion object {
+        const val NAME = "DashXReactNative"
+        private const val E_UNSPECIFIED = "EUNSPECIFIED"
+        private const val DEFAULT_CHANNEL_ID = "default_dashx_notification_channel"
+        private const val DEFAULT_CHANNEL_NAME = "Notifications"
+
+        private const val NOTIFICATION_PERMISSION_REQUEST_CODE = 3571
+
+        private const val PREFS_NAME = "dashx_rn_prefs"
+        private const val KEY_PERMISSION_REQUESTED = "notification_permission_requested"
+
+        // Mirrors iOS UNAuthorizationStatus values used by the JS layer.
+        private const val PERMISSION_NOT_DETERMINED = 0
+        private const val PERMISSION_DENIED = 1
+        private const val PERMISSION_AUTHORIZED = 2
+    }
+}