zixflow-reactnative 1.1.3 → 1.1.5

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

@@ -10,12 +10,17 @@ import com.zixflow.messaginginapp.di.inAppMessaging
 import com.zixflow.messaginginapp.gist.data.model.InboxMessage
 import com.zixflow.messaginginapp.gist.data.model.response.InboxMessageFactory
 import com.zixflow.messaginginapp.inbox.NotificationInbox
+import com.zixflow.messaginginapp.type.ColorScheme
+import com.zixflow.messaginginapp.type.NotificationInboxAccessibilityLabels
 import com.zixflow.reactnative.sdk.NativeZixflowMessagingInAppSpec
+import com.zixflow.reactnative.sdk.constant.Keys
+import com.zixflow.reactnative.sdk.extension.getTypedValue
 import com.zixflow.reactnative.sdk.extension.toMap
 import com.zixflow.sdk.Zixflow
 import com.zixflow.sdk.ZixflowBuilder
 import com.zixflow.sdk.core.di.SDKComponent
 import com.zixflow.sdk.core.util.Logger
+import com.zixflow.sdk.data.model.Region
 
 /**
  * React Native module implementation for Zixflow In-App Messaging Native SDK
@@ -30,6 +35,7 @@ class NativeMessagingInAppModule(
 
     private val inAppEventListener = ReactInAppEventListener.instance
     private val inboxChangeListener = ReactNotificationInboxChangeListener.instance
+    private val inboxEventListener = ReactInboxEventListener.instance
 
     // Dedicated lock for inbox listener setup to avoid blocking other operations
     private val inboxListenerLock = Any()
@@ -60,6 +66,7 @@ class NativeMessagingInAppModule(
     override fun invalidate() {
         inAppEventListener.clearEventEmitter()
         clearInboxChangeListener()
+        clearInboxEventListener()
         super.invalidate()
     }
 
@@ -67,10 +74,76 @@ class NativeMessagingInAppModule(
         inAppMessagingModule?.dismissMessage()
     }
 
+    // Nullable like every other argument-taking override here, and for the same reason: Codegen
+    // declares the parameter non-null, so a non-null Kotlin type would throw
+    // `Intrinsics.checkNotNullParameter` before the body runs when JavaScript passes null — which
+    // is what an untyped caller reading a stored theme sends on first launch.
+    override fun setColorScheme(colorScheme: String?) {
+        val resolved = colorSchemeFromRawValue(colorScheme)
+        if (resolved == null) {
+            // Leave the current scheme alone rather than resetting it to AUTO, so a bad value
+            // cannot quietly undo a scheme the app set correctly earlier.
+            logger.error(
+                "Unrecognized in-app colorScheme '$colorScheme', expected one of auto, light, " +
+                    "dark. Leaving the color scheme unchanged."
+            )
+            return
+        }
+        val module = inAppMessagingModule
+        if (module == null) {
+            // Reachable when the host calls this before Zixflow.initialize, or without the
+            // in-app module configured. Logged rather than ignored: the scheme is silently not
+            // applied, and nothing else surfaces that.
+            logger.error(
+                "In-app messaging is not available, so the color scheme was not applied. " +
+                    "Ensure Zixflow SDK is initialized with the inApp configuration."
+            )
+            return
+        }
+        module.setColorScheme(resolved)
+    }
+
     override fun setupInboxListener() {
         setupInboxChangeListener()
     }
 
+    /**
+     * Registers the native inbox event forwarder with the SDK and wires it to the React Native
+     * event emitter. Called when a JS inbox event listener is registered.
+     */
+    override fun registerInboxEventListener() {
+        inboxEventListener.setEventEmitter { data ->
+            emitOnInboxEventReceived(data)
+        }
+        val module = inAppMessagingModule
+        if (module == null) {
+            // Without this the failure is invisible: the JS subscription reports success while the SDK
+            // never forwards anything, so inbox callbacks silently never arrive. Matches the guidance
+            // used by getMessages() for the same situation.
+            logger.error(
+                "Cannot register inbox event listener: in-app messaging is not available. " +
+                    "Ensure Zixflow SDK is initialized before registering the listener."
+            )
+            return
+        }
+        module.setInboxEventListener(inboxEventListener)
+    }
+
+    /**
+     * Unregisters the native inbox event forwarder by installing a no-op listener (the native API is
+     * non-null), restoring the SDK's default action handling. Called when the JS inbox event
+     * listener is removed.
+     */
+    override fun unregisterInboxEventListener() {
+        inAppMessagingModule?.setInboxEventListener(NoOpInboxEventListener)
+        inboxEventListener.clearEventEmitter()
+    }
+
+    private fun clearInboxEventListener() {
+        inAppMessagingModule?.setInboxEventListener(NoOpInboxEventListener)
+        inboxEventListener.clearEventEmitter()
+    }
+
     override fun getMessages(topic: String?, promise: Promise?) {
         try {
             val inbox = requireInboxInstance() ?: run {
@@ -196,9 +269,86 @@ class NativeMessagingInAppModule(
             val module = ModuleMessagingInApp(
                 MessagingInAppModuleConfig.Builder().apply {
                     setEventListener(eventListener = ReactInAppEventListener.instance)
+                    colorSchemeFromConfig(config)?.let { colorScheme ->
+                        setColorScheme(colorScheme)
+                    }
+                    inboxAccessibilityLabelsFromConfig(config)?.let { labels ->
+                        setNotificationInboxAccessibilityLabels(labels)
+                    }
                 }.build(),
             )
             builder.addZixflowModule(module)
         }
+
+        /**
+         * Maps the wrapper's `colorScheme` value onto the native [ColorScheme], or null when the
+         * value is absent or unrecognized.
+         *
+         * The accepted values are lowercase because that is the wire contract the JavaScript
+         * `ZixflowColorScheme` enum serializes to and the one iOS already matches. Kept free of
+         * logging so each caller can report a bad value in its own terms: at initialization an
+         * unrecognized value falls back to AUTO, while the runtime setter leaves the scheme the
+         * app already chose untouched.
+         */
+        internal fun colorSchemeFromRawValue(rawValue: String?): ColorScheme? = when (rawValue) {
+            "auto" -> ColorScheme.AUTO
+            "light" -> ColorScheme.LIGHT
+            "dark" -> ColorScheme.DARK
+            else -> null
+        }
+
+        private fun colorSchemeFromConfig(config: Map<String, Any>): ColorScheme? {
+            // Absent is not a mistake — the SDK's own AUTO default stands — so only a value the
+            // host actually provided is worth reporting.
+            val rawValue = config.getTypedValue<String>(Keys.Config.COLOR_SCHEME) ?: return null
+
+            return colorSchemeFromRawValue(rawValue).also { resolved ->
+                if (resolved == null) {
+                    SDKComponent.logger.error(
+                        "Unrecognized in-app colorScheme '$rawValue', expected one of auto, " +
+                            "light, dark. Falling back to the device appearance."
+                    )
+                }
+            }
+        }
+
+        /**
+         * Builds the host's inbox accessibility labels from the wrapper configuration, or null when
+         * the app provided none — in which case the SDK keeps its default of emitting no labels at
+         * all rather than falling back to English.
+         *
+         * `bellWithUnreadCount` arrives as a template string because the bridge carries data but not
+         * functions; it is converted here into the `(Int) -> String` the native SDK expects. A
+         * template without the placeholder is returned verbatim for every count; the JavaScript
+         * layer warns about that case, where the developer can actually see it.
+         */
+        private fun inboxAccessibilityLabelsFromConfig(
+            config: Map<String, Any>
+        ): NotificationInboxAccessibilityLabels? {
+            val labels = config.getTypedValue<Map<String, Any>>(
+                Keys.Config.NOTIFICATION_INBOX_ACCESSIBILITY_LABELS
+            ) ?: return null
+
+            val unreadCountTemplate = labels.getTypedValue<String>(
+                Keys.InboxAccessibilityLabels.BELL_WITH_UNREAD_COUNT
+            )
+            return NotificationInboxAccessibilityLabels(
+                bell = labels.getTypedValue<String>(Keys.InboxAccessibilityLabels.BELL),
+                bellWithUnreadCount = unreadCountTemplate?.let { template ->
+                    { count: Int ->
+                        template.replace(
+                            Keys.InboxAccessibilityLabels.COUNT_PLACEHOLDER,
+                            count.toString()
+                        )
+                    }
+                },
+                loadingIndicator = labels.getTypedValue<String>(
+                    Keys.InboxAccessibilityLabels.LOADING_INDICATOR
+                ),
+                emptyState = labels.getTypedValue<String>(
+                    Keys.InboxAccessibilityLabels.EMPTY_STATE
+                )
+            )
+        }
     }
 }

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

@@ -0,0 +1,99 @@
+package com.zixflow.reactnative.sdk.messaginginapp
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableMap
+import com.zixflow.messaginginapp.gist.data.model.InboxMessage
+import com.zixflow.messaginginapp.type.InboxEventListener
+
+/**
+ * React Native bridge for Zixflow Visual Notification Inbox events.
+ *
+ * Registered on the SDK (via [com.zixflow.messaginginapp.ModuleMessagingInApp.setInboxEventListener])
+ * only while a JS listener is registered. Because the New-Arch event emitter is one-way we cannot
+ * round-trip a bool back from JS, so [messageActionTaken] forwards the event fire-and-forget and
+ * RETURNS `true` — telling the SDK the host handled the action so the SDK suppresses its default
+ * navigation. The JS host owns action handling while a listener is registered. Observational
+ * callbacks forward fire-and-forget.
+ */
+class ReactInboxEventListener private constructor() : InboxEventListener {
+    // Event emitter function to send events to React Native layer
+    private var eventEmitter: ((ReadableMap) -> Unit)? = null
+
+    // Sets the event emitter function
+    internal fun setEventEmitter(emitter: ((ReadableMap) -> Unit)?) {
+        this.eventEmitter = emitter
+    }
+
+    // Clears the event emitter to prevent memory leaks
+    internal fun clearEventEmitter() {
+        this.eventEmitter = null
+    }
+
+    // Emits an inbox message event to React Native with a serialized message payload
+    private fun emitInboxEvent(
+        eventType: String,
+        message: InboxMessage,
+        actionName: String? = null,
+        actionValue: String? = null,
+    ) {
+        // Get the emitter, return early if not set
+        val emitter = eventEmitter ?: return
+
+        val data = Arguments.createMap().apply {
+            putString("eventType", eventType)
+            putMap("message", message.toWritableMap())
+            actionName?.let { putString("actionName", it) }
+            actionValue?.let { putString("actionValue", it) }
+        }
+
+        emitter.invoke(data)
+    }
+
+    override fun messageActionTaken(
+        message: InboxMessage,
+        actionName: String,
+        actionValue: String,
+    ): Boolean {
+        emitInboxEvent(
+            eventType = "messageActionTaken",
+            message = message,
+            actionName = actionName,
+            actionValue = actionValue,
+        )
+        // Host (React Native) owns action handling while a listener is registered.
+        return true
+    }
+
+    override fun messageShown(message: InboxMessage) = emitInboxEvent(
+        eventType = "messageShown",
+        message = message,
+    )
+
+    override fun messageOpened(message: InboxMessage) = emitInboxEvent(
+        eventType = "messageOpened",
+        message = message,
+    )
+
+    override fun messageDismissed(message: InboxMessage) = emitInboxEvent(
+        eventType = "messageDismissed",
+        message = message,
+    )
+
+    companion object {
+        // Singleton instance with public visibility for direct access by Expo plugin
+        val instance: ReactInboxEventListener by lazy { ReactInboxEventListener() }
+    }
+}
+
+/**
+ * No-op inbox listener used to clear the forwarder from the SDK. Returning `false` from
+ * [messageActionTaken] restores the SDK's default action handling. The native
+ * `setInboxEventListener` API is non-null, so a no-op is installed rather than clearing.
+ */
+internal object NoOpInboxEventListener : InboxEventListener {
+    override fun messageActionTaken(
+        message: InboxMessage,
+        actionName: String,
+        actionValue: String,
+    ): Boolean = false
+}

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

@@ -0,0 +1,38 @@
+package com.zixflow.reactnative.sdk.messaginginbox
+
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.viewmanagers.NotificationInboxBellNativeManagerDelegate
+import com.facebook.react.viewmanagers.NotificationInboxBellNativeManagerInterface
+
+/**
+ * View manager for the Visual Notification Inbox bell (just the bell; host opens its own UI).
+ *
+ * Registers the `onTap` direct event so taps reach the JS wrapper.
+ */
+@ReactModule(name = NotificationInboxBellViewManager.NAME)
+class NotificationInboxBellViewManager :
+    NotificationInboxBellNativeManagerInterface<ReactNotificationInboxBellView>,
+    SimpleViewManager<ReactNotificationInboxBellView>() {
+    private val delegate = NotificationInboxBellNativeManagerDelegate(this)
+
+    override fun getName() = NAME
+    override fun getDelegate(): ViewManagerDelegate<ReactNotificationInboxBellView> = delegate
+
+    override fun createViewInstance(
+        reactContext: ThemedReactContext
+    ): ReactNotificationInboxBellView = ReactNotificationInboxBellView(reactContext)
+
+    override fun getExportedCustomDirectEventTypeConstants(): MutableMap<String, Any> {
+        val customEvents = super.getExportedCustomDirectEventTypeConstants() ?: mutableMapOf()
+        customEvents[ReactNotificationInboxBellView.ON_TAP] =
+            mapOf("registrationName" to ReactNotificationInboxBellView.ON_TAP)
+        return customEvents
+    }
+
+    companion object {
+        internal const val NAME = "NotificationInboxBellNative"
+    }
+}

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

@@ -0,0 +1,30 @@
+package com.zixflow.reactnative.sdk.messaginginbox
+
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.viewmanagers.NotificationInboxViewNativeManagerDelegate
+import com.facebook.react.viewmanagers.NotificationInboxViewNativeManagerInterface
+
+/**
+ * View manager for the Visual Notification Inbox message list (the Jist-rendered list,
+ * embeddable in the host's own screen). No props or events; sizing comes from the JS style.
+ */
+@ReactModule(name = NotificationInboxViewManager.NAME)
+class NotificationInboxViewManager :
+    NotificationInboxViewNativeManagerInterface<ReactNotificationInboxView>,
+    SimpleViewManager<ReactNotificationInboxView>() {
+    private val delegate = NotificationInboxViewNativeManagerDelegate(this)
+
+    override fun getName() = NAME
+    override fun getDelegate(): ViewManagerDelegate<ReactNotificationInboxView> = delegate
+
+    override fun createViewInstance(
+        reactContext: ThemedReactContext
+    ): ReactNotificationInboxView = ReactNotificationInboxView(reactContext)
+
+    companion object {
+        internal const val NAME = "NotificationInboxViewNative"
+    }
+}

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

@@ -0,0 +1,96 @@
+package com.zixflow.reactnative.sdk.messaginginbox
+
+import android.content.Context
+import android.view.Choreographer
+import android.view.View
+import android.widget.FrameLayout
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.platform.ComposeView
+import com.facebook.react.bridge.WritableMap
+import com.zixflow.reactnative.sdk.extension.sendUIEventToReactJS
+
+/**
+ * Base React Native view that hosts a Jetpack Compose [content] inside a [ComposeView].
+ *
+ * Mirrors the role that the native SDK's `WrapperInlineView` plays for inline in-app
+ * messages, but the Visual Notification Inbox components are plain `@Composable`s, so we
+ * host them directly in a [ComposeView] rather than going through an inline-message wrapper.
+ *
+ * Subclasses provide the composable via [content] and emit events with [emitEvent].
+ *
+ * Layout note: React Native (Yoga) lays this view out, so the [ComposeView] is sized to the
+ * bounds RN assigns. Because RN children measured by native code don't always re-trigger a
+ * layout pass, we schedule a manual measure/layout via the [Choreographer] whenever the view
+ * is attached, matching how other RN-hosted native views keep themselves laid out.
+ */
+abstract class ReactComposeHostView(context: Context) : FrameLayout(context) {
+
+    private val composeView: ComposeView = ComposeView(context).apply {
+        layoutParams = LayoutParams(
+            LayoutParams.MATCH_PARENT,
+            LayoutParams.MATCH_PARENT
+        )
+        setContent { content() }
+    }
+
+    /** The Compose UI hosted by this view. Implemented by each concrete inbox component. */
+    @Composable
+    protected abstract fun content()
+
+    /**
+     * The Compose child is attached here rather than in `init`, gating setup on attachment the same
+     * way [com.zixflow.messaginginapp.ui.core.BaseInlineInAppMessageView] gates its subscription.
+     *
+     * Fabric measures a newly created view before the mount batch's INSERT attaches it to the
+     * window ([com.facebook.react.fabric.mounting.SurfaceMountingManager.updateLayout]), and
+     * `AbstractComposeView.onMeasure` unconditionally creates its composition, which needs a window
+     * to resolve the recomposer. Adding the child in `init` therefore threw
+     * `IllegalStateException: Cannot locate windowRecomposer` during that measure; the mount batch
+     * aborted and the half-mounted hierarchy crashed the host app.
+     */
+    override fun onAttachedToWindow() {
+        super.onAttachedToWindow()
+        if (composeView.parent == null) {
+            addView(composeView)
+        }
+    }
+
+    /**
+     * Dispatches a UI event back to the JS side using the React Native event dispatcher.
+     *
+     * @param eventName name registered in the view manager's
+     *   `getExportedCustomDirectEventTypeConstants`.
+     * @param payload optional event data.
+     */
+    protected fun emitEvent(eventName: String, payload: WritableMap? = null) {
+        sendUIEventToReactJS(eventName = eventName, payload = payload)
+    }
+
+    /**
+     * React Native lays out views off the main Android layout pass, so manually re-run
+     * measure + layout against the bounds RN assigned. Without this, native children of
+     * RN-managed views can render with a zero size.
+     */
+    override fun requestLayout() {
+        super.requestLayout()
+        post(measureAndLayout)
+    }
+
+    private val measureAndLayout = Runnable {
+        // The callback is posted for the next frame, by which point the view may have been detached
+        // (Fabric recycles these). Measuring the Compose child without a window throws, so skip it —
+        // a later attach re-runs layout anyway.
+        if (!isAttachedToWindow) {
+            return@Runnable
+        }
+        measure(
+            MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
+            MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY)
+        )
+        layout(left, top, right, bottom)
+    }
+
+    private fun View.post(action: Runnable) {
+        Choreographer.getInstance().postFrameCallback { action.run() }
+    }
+}

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

@@ -0,0 +1,48 @@
+package com.zixflow.reactnative.sdk.messaginginbox
+
+import android.content.Context
+import android.view.MotionEvent
+import androidx.compose.runtime.Composable
+import com.facebook.react.bridge.Arguments
+import com.zixflow.messaginginbox.NotificationInboxOverlay
+
+/**
+ * React Native host for the Visual Notification Inbox bell.
+ *
+ * Hosts the native [NotificationInboxOverlay] composable rather than `NotificationInboxBell`: only the
+ * overlay ties the bell to the SDK's own inbox panel, and the wrapper deliberately does not reimplement
+ * panel presentation. Sized to the frame React Native assigns, that composition *is* a bell that opens
+ * the inbox — the component wrappers expose.
+ *
+ * Remote branding still styles the bell (colors, icon). Branding's bell *position* has no effect here:
+ * alignment resolves inside this view's bounds, so the JS host owns placement via `style`.
+ *
+ * [ON_TAP] is observational — the SDK opens the panel itself, so the host has nothing to do in response.
+ */
+class ReactNotificationInboxBellView(context: Context) : ReactComposeHostView(context) {
+    @Composable
+    override fun content() {
+        NotificationInboxOverlay()
+    }
+
+    /**
+     * Reports taps without consuming them.
+     *
+     * `dispatchTouchEvent` rather than `onTouchEvent`: the Compose child consumes the bell tap, so a
+     * parent `onTouchEvent` would never run. Dispatching to super first keeps the gesture flowing to
+     * Compose (which opens the panel); we only observe the outcome. Reporting on ACTION_UP and only
+     * when the touch was consumed approximates "the bell took this tap" rather than firing for taps
+     * that landed on the transparent area around it.
+     */
+    override fun dispatchTouchEvent(event: MotionEvent): Boolean {
+        val handled = super.dispatchTouchEvent(event)
+        if (handled && event.actionMasked == MotionEvent.ACTION_UP) {
+            emitEvent(ON_TAP, Arguments.createMap())
+        }
+        return handled
+    }
+
+    companion object {
+        const val ON_TAP = "onTap"
+    }
+}

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

@@ -0,0 +1,17 @@
+package com.zixflow.reactnative.sdk.messaginginbox
+
+import android.content.Context
+import androidx.compose.runtime.Composable
+import com.zixflow.messaginginbox.NotificationInboxView
+
+/**
+ * React Native host for the native [NotificationInboxView] composable (the Jist-rendered
+ * message list). Sizing is driven by the JS `style` prop. Message actions are handled by the
+ * existing global InboxEventListener, so this component emits no per-message events.
+ */
+class ReactNotificationInboxView(context: Context) : ReactComposeHostView(context) {
+    @Composable
+    override fun content() {
+        NotificationInboxView()
+    }
+}

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

@@ -23,6 +23,7 @@ import com.zixflow.reactnative.sdk.NativeZixflowMessagingPushSpec
 import com.zixflow.reactnative.sdk.constant.Keys
 import com.zixflow.reactnative.sdk.extension.getTypedValue
 import com.zixflow.reactnative.sdk.extension.takeIfNotBlank
+import com.zixflow.reactnative.sdk.liveactivities.NativeLiveActivitiesModule
 import com.zixflow.reactnative.sdk.util.unsupportedOnAndroid
 import com.zixflow.sdk.Zixflow
 import com.zixflow.sdk.ZixflowBuilder
@@ -257,7 +258,8 @@ class NativeMessagingPushModule(
          */
         internal fun addNativeModuleFromConfig(
             builder: ZixflowBuilder,
-            config: Map<String, Any>
+            config: Map<String, Any>,
+            liveNotificationsConfig: Map<String, Any>? = null,
         ) {
             val androidConfig =
                 config.getTypedValue<Map<String, Any>>(key = "android") ?: emptyMap()
@@ -275,6 +277,14 @@ class NativeMessagingPushModule(
             val module = ModuleMessagingPushFCM(
                 moduleConfig = MessagingPushModuleConfig.Builder().apply {
                     setPushClickBehavior(pushClickBehavior = pushClickBehavior)
+                    // Live Notifications are hosted by the FCM push module, so their config is
+                    // applied to the same MessagingPushModuleConfig.
+                    liveNotificationsConfig?.let { liveConfig ->
+                        NativeLiveActivitiesModule.applyLiveActivitiesConfig(
+                            builder = this,
+                            config = liveConfig,
+                        )
+                    }
                 }.build(),
             )
             builder.addZixflowModule(module)

package/android/src/main/res/values/zixflow_config.xml

@@ -9,5 +9,5 @@
     This will be updated by update-version script with React Native package version
     whenever new version of React Native package is released
     -->
-    <string name="zixflow_react_native_sdk_client_version">1.1.0</string>
+    <string name="zixflow_react_native_sdk_client_version">1.1.5</string>
 </resources>

package/android/zixflow-core.gradle

@@ -1,12 +1,25 @@
 dependencies {
+    // The real published Maven Central group id is "com.zixflow.com.android" (not
+    // "com.zixflow.android") -- a known artifact-id quirk in how the native Android SDK
+    // is published. Using the "corrected-looking" coordinate fails dependency resolution.
     api "com.zixflow.com.android:datapipelines:$zixflowAndroidSDKVersion"
     api "com.zixflow.com.android:messaging-push-fcm:$zixflowAndroidSDKVersion"
     api "com.zixflow.com.android:messaging-in-app:$zixflowAndroidSDKVersion"
+    // Visual Notification Inbox UI (Compose-based).
+    api "com.zixflow.com.android:messaging-inbox:$zixflowAndroidSDKVersion"
     // Location module is optional - customers enable it by adding
-    // zixflow_location_enabled=true in their gradle.properties
-    if (project.zixflowLocationEnabled) {
+    // zixflow_location_enabled=true in their gradle.properties.
+    // Geofence implies Location: enabling geofence pulls in location too.
+    if (project.zixflowLocationEnabled || project.zixflowGeofenceEnabled) {
         api "com.zixflow.com.android:location:$zixflowAndroidSDKVersion"
     } else {
         compileOnly "com.zixflow.com.android:location:$zixflowAndroidSDKVersion"
     }
+    // Geofence module is optional - customers enable it by adding
+    // zixflow_geofence_enabled=true in their gradle.properties
+    if (project.zixflowGeofenceEnabled) {
+        api "com.zixflow.com.android:geofence:$zixflowAndroidSDKVersion"
+    } else {
+        compileOnly "com.zixflow.com.android:geofence:$zixflowAndroidSDKVersion"
+    }
 }