zixflow-reactnative 1.1.2 → 1.1.4

package/android/build.gradle

@@ -10,11 +10,14 @@ buildscript {
   dependencies {
     // noinspection DifferentKotlinGradleVersion
     classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+    // Compose compiler plugin (Kotlin 2.x) for hosting the Visual Notification Inbox composables.
+    classpath "org.jetbrains.kotlin:compose-compiler-gradle-plugin:$kotlin_version"
   }
 }
 
 apply plugin: 'com.android.library'
 apply plugin: 'kotlin-android'
+apply plugin: 'org.jetbrains.kotlin.plugin.compose'
 apply plugin: "com.facebook.react"
 
 def getExtOrDefault(name) {
@@ -26,6 +29,7 @@ def getExtOrIntegerDefault(name) {
 }
 
 ext.zixflowLocationEnabled = rootProject.findProperty("zixflow_location_enabled")?.toBoolean() ?: false
+ext.zixflowGeofenceEnabled = rootProject.findProperty("zixflow_geofence_enabled")?.toBoolean() ?: false
 
 android {
   namespace = 'com.zixflow.reactnative.sdk'
@@ -33,12 +37,17 @@ android {
   defaultConfig {
     minSdkVersion getExtOrIntegerDefault('minSdkVersion')
     targetSdkVersion getExtOrIntegerDefault('targetSdkVersion')
-    buildConfigField "boolean", "ZIXFLOW_LOCATION_ENABLED", "${project.zixflowLocationEnabled}"
+    // Geofence implies Location, so the Location flag is on whenever geofence is enabled
+    // (mirrors the iOS geofence subspec, which also defines ZIXFLOW_LOCATION_ENABLED).
+    buildConfigField "boolean", "ZIXFLOW_LOCATION_ENABLED", "${project.zixflowLocationEnabled || project.zixflowGeofenceEnabled}"
+    buildConfigField "boolean", "ZIXFLOW_GEOFENCE_ENABLED", "${project.zixflowGeofenceEnabled}"
     consumerProguardFiles 'consumer-rules.pro'
   }
 
   buildFeatures {
     buildConfig true
+    // Required to host the Visual Notification Inbox Compose UI components.
+    compose true
   }
 
   buildTypes {
@@ -144,4 +153,12 @@ dependencies {
   // noinspection GradleDynamicVersion
   api 'com.facebook.react:react-native:+'
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+
+  // Jetpack Compose — needed because the Visual Notification Inbox view managers host
+  // the native `@Composable` inbox components inside a ComposeView.
+  def composeBom = platform('androidx.compose:compose-bom:2025.10.00')
+  implementation composeBom
+  implementation 'androidx.compose.ui:ui'
+  implementation 'androidx.compose.foundation:foundation'
+  implementation 'androidx.compose.runtime:runtime'
 }

package/android/consumer-rules.pro

@@ -1,3 +1,4 @@
-# Location module is an optional compileOnly dependency.
-# When not enabled, R8 must not fail on missing location classes.
+# Location and geofence modules are optional compileOnly dependencies.
+# When not enabled, R8 must not fail on their missing classes.
 -dontwarn io.customer.location.**
+-dontwarn io.customer.geofence.**

package/android/gradle.properties

@@ -2,4 +2,4 @@ zixflow.reactnative.kotlinVersion=2.1.20
 zixflow.reactnative.compileSdkVersion=36
 zixflow.reactnative.targetSdkVersion=36
 zixflow.reactnative.minSdkVersion=21
-zixflow.reactnative.sdkVersionAndroid=1.1.0
+zixflow.reactnative.sdkVersionAndroid=4.23.2

package/android/src/main/java/com/zixflow/reactnative/sdk/NativeZixflowModule.kt

@@ -1,6 +1,7 @@
 package com.zixflow.reactnative.sdk
 
 import android.app.Application
+import android.util.Log
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReadableMap
@@ -15,9 +16,8 @@ import com.zixflow.reactnative.sdk.util.assertNotNull
 import com.zixflow.sdk.Zixflow
 import com.zixflow.sdk.ZixflowBuilder
 import com.zixflow.sdk.core.di.SDKComponent
-import com.zixflow.sdk.core.util.CioLogLevel
+import com.zixflow.sdk.core.util.ZixflowLogLevel
 import com.zixflow.sdk.core.util.Logger
-import com.zixflow.sdk.data.model.Region
 import com.zixflow.sdk.events.Metric
 import com.zixflow.sdk.events.TrackMetric
 import com.zixflow.sdk.events.serializedName
@@ -47,8 +47,11 @@ class NativeZixflowModule(
 
 
     override fun initialize(config: ReadableMap?, args: ReadableMap?, promise: Promise?) {
+        Log.d("ZixflowRN", ">>> initialize() called")
+
         // Skip initialization if already initialized
         if (getSDKInstanceOrNull() != null) {
+            Log.d("ZixflowRN", ">>> SDK already initialized, skipping")
             logger.info("Zixflow SDK is already initialized. Skipping initialization.")
             promise?.resolve(true)
             return
@@ -56,60 +59,86 @@ class NativeZixflowModule(
 
         try {
             val packageConfig = config.toMap()
-            val cdpApiKey = packageConfig.getTypedValue<String>(
-                Keys.Config.CDP_API_KEY
-            ) ?: throw IllegalArgumentException("CDP API Key is required to initialize Zixflow")
+            val apiKey = packageConfig.getTypedValue<String>(
+                Keys.Config.API_KEY
+            ) ?: throw IllegalArgumentException("API Key is required to initialize Zixflow")
 
             val logLevelRawValue = packageConfig.getTypedValue<String>(Keys.Config.LOG_LEVEL)
-            val regionRawValue = packageConfig.getTypedValue<String>(Keys.Config.REGION)
-            val region = regionRawValue.let { Region.getRegion(it) }
             val screenViewRawValue =
                 packageConfig.getTypedValue<String>(Keys.Config.SCREEN_VIEW_USE)
 
+            val apiHostValue = packageConfig.getTypedValue<String>(Keys.Config.API_HOST)
+            val cdnHostValue = packageConfig.getTypedValue<String>(Keys.Config.CDN_HOST)
+
+            Log.d("ZixflowRN", "==========================================")
+            Log.d("ZixflowRN", "Initializing Zixflow SDK")
+            Log.d("ZixflowRN", "apiKey: $apiKey")
+            Log.d("ZixflowRN", "apiHost: $apiHostValue")
+            Log.d("ZixflowRN", "cdnHost: $cdnHostValue")
+            Log.d("ZixflowRN", "==========================================")
+
             ZixflowBuilder(
                 applicationContext = reactContext.applicationContext as Application,
-                cdpApiKey = cdpApiKey
+                apiKey = apiKey
             ).apply {
-                logLevelRawValue?.let { logLevel(CioLogLevel.getLogLevel(it)) }
-                regionRawValue?.let { region(region) }
+                logLevelRawValue?.let { logLevel(ZixflowLogLevel.getLogLevel(it)) }
                 screenViewRawValue?.let { screenViewUse(ScreenView.getScreenView(it)) }
 
                 packageConfig.getTypedValue<Boolean>(Keys.Config.AUTO_TRACK_DEVICE_ATTRIBUTES)
                     ?.let { autoTrackDeviceAttributes(it) }
-                packageConfig.getTypedValue<String>(Keys.Config.MIGRATION_SITE_ID)
-                    ?.let { migrationSiteId(it) }
                 packageConfig.getTypedValue<Int>(Keys.Config.FLUSH_AT)
                     ?.let { flushAt(it) }
                 packageConfig.getTypedValue<Int>(Keys.Config.FLUSH_INTERVAL)
                     ?.let { flushInterval(it) }
                 packageConfig.getTypedValue<Boolean>(Keys.Config.TRACK_APP_LIFECYCLE_EVENTS)
                     ?.let { trackApplicationLifecycleEvents(it) }
-                packageConfig.getTypedValue<String>(Keys.Config.API_HOST)
-                    ?.let { apiHost(it) }
-                packageConfig.getTypedValue<String>(Keys.Config.CDN_HOST)
-                    ?.let { cdnHost(it) }
+                apiHostValue?.let {
+                    Log.d("ZixflowRN", "Calling apiHost($it)")
+                    apiHost(it)
+                }
+                cdnHostValue?.let {
+                    Log.d("ZixflowRN", "Calling cdnHost($it)")
+                    cdnHost(it)
+                }
 
-                // Configure push messaging module based on config provided by customer app
+                // Configure push messaging module based on config provided by customer app.
+                // Live Activities are hosted by the FCM push module, so the `liveNotifications`
+                // config is applied to the same module.
                 packageConfig.getTypedValue<Map<String, Any>>(key = "push").let { pushConfig ->
                     NativeMessagingPushModule.addNativeModuleFromConfig(
                         builder = this,
-                        config = pushConfig ?: emptyMap()
+                        config = pushConfig ?: emptyMap(),
+                        liveNotificationsConfig = packageConfig.getTypedValue<Map<String, Any>>(key = "liveNotifications")
                     )
                 }
-                // Configure in-app messaging module based on config provided by customer app
                 packageConfig.getTypedValue<Map<String, Any>>(key = "inApp")?.let { inAppConfig ->
                     NativeMessagingInAppModule.addNativeModuleFromConfig(
                         builder = this,
-                        config = inAppConfig,
-                        region = region
+                        config = inAppConfig
                     )
                 }
-                // Configure location module if enabled via gradle property
+                // Configure location module. Geofence implies location, so register location
+                // (with the app's config if given, otherwise defaults) whenever location or
+                // geofence is enabled, since geofence relies on the location module's fixes.
+                // ZIXFLOW_LOCATION_ENABLED is already true for geofence-enabled builds.
                 if (BuildConfig.ZIXFLOW_LOCATION_ENABLED) {
-                    packageConfig.getTypedValue<Map<String, Any>>(key = "location")?.let { locationConfig ->
+                    val locationConfig = packageConfig.getTypedValue<Map<String, Any>>(key = "location")
+                    val geofenceConfigured = BuildConfig.ZIXFLOW_GEOFENCE_ENABLED &&
+                        packageConfig.getTypedValue<Map<String, Any>>(key = "geofence") != null
+                    if (locationConfig != null || geofenceConfigured) {
                         NativeLocationModule.addNativeModuleFromConfig(
                             builder = this,
-                            config = locationConfig
+                            config = locationConfig ?: emptyMap()
+                        )
+                    }
+                }
+                // Configure geofence module if enabled via gradle property; it runs
+                // automatically once registered and relies on the location module above.
+                if (BuildConfig.ZIXFLOW_GEOFENCE_ENABLED) {
+                    packageConfig.getTypedValue<Map<String, Any>>(key = "geofence")?.let { geofenceConfig ->
+                        NativeGeofenceModule.addNativeModuleFromConfig(
+                            builder = this,
+                            config = geofenceConfig
                         )
                     }
                 }
@@ -123,6 +152,22 @@ class NativeZixflowModule(
         }
     }
 
+    override fun setDeepLinkRoutingReady() {
+        // UIScene and React Native Linking readiness are iOS-only concerns.
+    }
+
+    override fun registerDeepLinkHandler() {
+        // UIScene deep-link acknowledgement is an iOS-only concern.
+    }
+
+    override fun unregisterDeepLinkHandler() {
+        // UIScene deep-link acknowledgement is an iOS-only concern.
+    }
+
+    override fun acknowledgeDeepLink(id: String?, handled: Boolean) {
+        // UIScene deep-link acknowledgement is an iOS-only concern.
+    }
+
     override fun identify(params: ReadableMap?) {
         val userId = params?.getString("userId")
         val traits = params?.getMap("traits")

package/android/src/main/java/com/zixflow/reactnative/sdk/ZixflowReactNativePackage.kt

@@ -6,10 +6,14 @@ import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.module.model.ReactModuleInfo
 import com.facebook.react.module.model.ReactModuleInfoProvider
 import com.facebook.react.uimanager.ViewManager
+import com.zixflow.reactnative.sdk.geofence.NativeGeofenceModule
+import com.zixflow.reactnative.sdk.liveactivities.NativeLiveActivitiesModule
 import com.zixflow.reactnative.sdk.location.NativeLocationModule
 import com.zixflow.reactnative.sdk.logging.NativeZixflowLoggingModule
 import com.zixflow.reactnative.sdk.messaginginapp.InlineInAppMessageViewManager
 import com.zixflow.reactnative.sdk.messaginginapp.NativeMessagingInAppModule
+import com.zixflow.reactnative.sdk.messaginginbox.NotificationInboxBellViewManager
+import com.zixflow.reactnative.sdk.messaginginbox.NotificationInboxViewManager
 import com.zixflow.reactnative.sdk.messagingpush.NativeMessagingPushModule
 import com.zixflow.reactnative.sdk.util.assertNotNull
 
@@ -22,7 +26,11 @@ class ZixflowReactNativePackage : BaseReactPackage() {
      * Creates the list of view managers for the Zixflow React Native SDK.
      */
     override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
-        return listOf(InlineInAppMessageViewManager())
+        return listOf(
+            InlineInAppMessageViewManager(),
+            NotificationInboxBellViewManager(),
+            NotificationInboxViewManager()
+        )
     }
 
     override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
@@ -31,11 +39,23 @@ class ZixflowReactNativePackage : BaseReactPackage() {
         // See: https://reactnative.dev/docs/fabric-native-components-introduction?platforms=android#4-write-the-reactwebviewpackage
         return when (name) {
             InlineInAppMessageViewManager.NAME -> InlineInAppMessageViewManager()
+            NotificationInboxBellViewManager.NAME -> NotificationInboxBellViewManager()
+            NotificationInboxViewManager.NAME -> NotificationInboxViewManager()
             NativeZixflowLoggingModule.NAME -> NativeZixflowLoggingModule(reactContext)
             NativeZixflowModule.NAME -> NativeZixflowModule(reactContext = reactContext)
+            // Unconditional on purpose, unlike Location below. Location has its own artifact
+            // (com.zixflow.android:location) that the flag switches between `api` and `compileOnly`,
+            // so gating it genuinely keeps a dependency off the consumer's classpath. Live
+            // Notifications ship inside messaging-push-fcm, already a hard dependency here, so a flag
+            // would remove nothing — and the module is inert until `liveNotifications` config enables
+            // a type. iOS gates its equivalent only because the subspec pulls in extra pods.
+            NativeLiveActivitiesModule.NAME -> NativeLiveActivitiesModule(reactContext)
             NativeLocationModule.NAME -> if (BuildConfig.ZIXFLOW_LOCATION_ENABLED) {
                 NativeLocationModule(reactContext)
             } else null
+            NativeGeofenceModule.NAME -> if (BuildConfig.ZIXFLOW_GEOFENCE_ENABLED) {
+                NativeGeofenceModule(reactContext)
+            } else null
             NativeMessagingInAppModule.NAME -> NativeMessagingInAppModule(reactContext)
             NativeMessagingPushModule.NAME -> NativeMessagingPushModule(reactContext)
             else -> assertNotNull<NativeModule>(value = null) { "Unknown module name: $name" }
@@ -69,9 +89,13 @@ class ZixflowReactNativePackage : BaseReactPackage() {
         // doesn't crash at import time. getModule() returns null when disabled.
         val moduleNames: List<String> = listOf(
             InlineInAppMessageViewManager.NAME,
+            NotificationInboxBellViewManager.NAME,
+            NotificationInboxViewManager.NAME,
             NativeZixflowLoggingModule.NAME,
             NativeZixflowModule.NAME,
+            NativeLiveActivitiesModule.NAME,
             NativeLocationModule.NAME,
+            NativeGeofenceModule.NAME,
             NativeMessagingInAppModule.NAME,
             NativeMessagingPushModule.NAME,
         )

package/android/src/main/java/com/zixflow/reactnative/sdk/constant/Keys.kt

@@ -3,18 +3,34 @@ package com.zixflow.reactnative.sdk.constant
 internal object Keys {
     object Config {
         const val LOG_LEVEL = "logLevel"
-        const val REGION = "region"
         const val AUTO_TRACK_DEVICE_ATTRIBUTES = "autoTrackDeviceAttributes"
-        const val CDP_API_KEY = "cdpApiKey"
+        const val API_KEY = "apiKey"
         const val SITE_ID = "siteId"
-        const val MIGRATION_SITE_ID = "migrationSiteId"
         const val TRACK_APP_LIFECYCLE_EVENTS = "trackApplicationLifecycleEvents"
         const val FLUSH_AT = "flushAt"
         const val FLUSH_INTERVAL = "flushInterval"
         const val SCREEN_VIEW_USE = "screenViewUse"
         const val API_HOST = "apiHost"
         const val CDN_HOST = "cdnHost"
+        const val NOTIFICATION_INBOX_ACCESSIBILITY_LABELS = "notificationInboxAccessibilityLabels"
+        const val COLOR_SCHEME = "colorScheme"
         // Push messaging
         const val PUSH_CLICK_BEHAVIOR = "pushClickBehavior"
     }
+
+    /**
+     * Keys of the `notificationInboxAccessibilityLabels` sub-map.
+     *
+     * [BELL_WITH_UNREAD_COUNT] carries a template string containing [COUNT_PLACEHOLDER] rather than
+     * a callback, because wrapper configuration crosses a bridge that carries data but not
+     * functions. The native SDK takes a `(Int) -> String`, so the template is converted to one when
+     * the module is configured.
+     */
+    object InboxAccessibilityLabels {
+        const val BELL = "bell"
+        const val BELL_WITH_UNREAD_COUNT = "bellWithUnreadCount"
+        const val LOADING_INDICATOR = "loadingIndicator"
+        const val EMPTY_STATE = "emptyState"
+        const val COUNT_PLACEHOLDER = "{count}"
+    }
 }

package/android/src/main/java/com/zixflow/reactnative/sdk/geofence/NativeGeofenceModule.kt

@@ -0,0 +1,65 @@
+package com.zixflow.reactnative.sdk.geofence
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.annotations.ReactModule
+import com.zixflow.geofence.GeofenceLocationMode
+import com.zixflow.geofence.GeofenceModuleConfig
+import com.zixflow.geofence.ModuleGeofence
+import com.zixflow.reactnative.sdk.NativeZixflowGeofenceSpec
+import com.zixflow.reactnative.sdk.extension.getTypedValue
+import com.zixflow.sdk.ZixflowBuilder
+import com.zixflow.sdk.core.di.SDKComponent
+import com.zixflow.sdk.core.util.Logger
+
+/**
+ * React Native module implementation for Zixflow Geofence Native SDK
+ * using TurboModules with new architecture.
+ *
+ * The reference to [ModuleGeofence] is isolated in this file so the geofence dependency is
+ * only loaded when the module is enabled and bundled. Geofence depends on the location
+ * module, which the caller registers alongside it.
+ */
+@ReactModule(name = NativeGeofenceModule.NAME)
+class NativeGeofenceModule(
+    private val reactContext: ReactApplicationContext,
+) : NativeZixflowGeofenceSpec(reactContext) {
+    private val logger: Logger
+        get() = SDKComponent.logger
+
+    private fun getModuleGeofence() = runCatching {
+        ModuleGeofence.instance()
+    }.onFailure {
+        logger.error("Geofence module is not initialized. Ensure geofence config is provided during SDK initialization.")
+    }.getOrNull()
+
+    override fun refreshFromCurrentLocation() {
+        getModuleGeofence()?.refreshFromCurrentLocation()
+    }
+
+    companion object {
+        const val NAME = "NativeZixflowGeofence"
+
+        /**
+         * Adds the geofence module to the native Android SDK based on the configuration
+         * provided by the customer app.
+         *
+         * @param builder instance of ZixflowBuilder to add the geofence module.
+         * @param config configuration provided by the customer app for the geofence module.
+         */
+        internal fun addNativeModuleFromConfig(
+            builder: ZixflowBuilder,
+            config: Map<String, Any>
+        ) {
+            val locationModeValue = config.getTypedValue<String>("locationMode")
+            // Uppercase before matching so casing can't diverge from iOS (which uppercases too);
+            // enumValueOf is case-sensitive. Unknown values fall back to the SDK default.
+            val locationMode = locationModeValue?.let { value ->
+                runCatching { enumValueOf<GeofenceLocationMode>(value.uppercase()) }.getOrNull()
+            }
+
+            val configBuilder = GeofenceModuleConfig.Builder()
+            locationMode?.let { configBuilder.setLocationMode(it) }
+            builder.addZixflowModule(ModuleGeofence(configBuilder.build()))
+        }
+    }
+}