zixflow-reactnative 1.1.3 → 1.1.4

package/src/zixflow-inapp.ts

@@ -3,13 +3,16 @@ import { InlineInAppMessageView } from './components';
 import { NativeLoggerListener } from './native-logger-listener';
 import {
   NotificationInbox,
+  parseInboxMessage,
   type NotificationInboxSpec,
 } from './notification-inbox';
 import NativeZixflowMessagingInApp, {
   type Spec as CodegenSpec,
 } from './specs/modules/NativeZixflowMessagingInApp';
-import type { InAppMessageEventType } from './types';
+import type { ZixflowColorScheme, InAppMessageEventType } from './types';
+import { InboxEventType, InboxMessageEvent } from './types';
 import { callNativeModule, ensureNativeModule } from './utils/native-bridge';
+import { assert } from './utils/param-validation';
 
 /**
  * Ensures all methods defined in codegen spec are implemented by the public module
@@ -18,7 +21,12 @@ import { callNativeModule, ensureNativeModule } from './utils/native-bridge';
  */
 interface NativeInAppSpec extends Omit<
   CodegenSpec,
-  keyof TurboModule | NotificationInboxSpec | 'onInAppEventReceived'
+  | keyof TurboModule
+  | NotificationInboxSpec
+  | 'onInAppEventReceived'
+  | 'registerInboxEventListener'
+  | 'unregisterInboxEventListener'
+  | 'onInboxEventReceived'
 > {}
 
 // Reference to the native Zixflow Data Pipelines module for SDK operations
@@ -37,6 +45,13 @@ const withNativeModule = <R>(fn: (native: CodegenSpec) => R): R => {
 class ZixflowInAppMessaging implements NativeInAppSpec {
   private _notificationInbox?: NotificationInbox;
 
+  /**
+   * Live inbox subscriptions. The SDK's inbox forwarder is a SINGLE global listener, so it is
+   * registered when the first subscription is created and unregistered when the last one goes away —
+   * never per subscription, or one `remove()` would tear it out from under the others.
+   */
+  private _inboxListenerCount = 0;
+
   registerEventsListener(
     listener: (event: InAppMessageEvent) => void
   ): EventSubscription {
@@ -74,6 +89,91 @@ class ZixflowInAppMessaging implements NativeInAppSpec {
     });
   }
 
+  /**
+   * Registers a listener for Visual Notification Inbox events (action taken,
+   * shown, opened, dismissed).
+   *
+   * While a listener is registered the host owns action navigation: the native
+   * SDK suppresses its default action handling and forwards the event here.
+   * Call `.remove()` on the returned subscription to unregister and restore the
+   * SDK's default behavior.
+   *
+   * @param listener - callback invoked with an {@link InboxMessageEvent}
+   * @returns an EventSubscription; call `.remove()` to stop listening
+   */
+  registerInboxEventListener(
+    listener: (event: InboxMessageEvent) => void
+  ): EventSubscription {
+    const emitter = (data: any) => {
+      // Convert raw native payload to InboxMessageEvent with a parsed message
+      const event = new InboxMessageEvent(
+        data.eventType as InboxEventType,
+        parseInboxMessage(data.message),
+        data.actionName,
+        data.actionValue
+      );
+      listener(event);
+    };
+
+    return withNativeModule((native) => {
+      let registeredNativeForwarder = false;
+      try {
+        // Register the native forwarder with the SDK, then subscribe to the
+        // codegen-generated event emitter.
+        // Wrapped in try-catch due to previous reports of crashes on certain Android architectures.
+        if (this._inboxListenerCount === 0) {
+          native.registerInboxEventListener();
+          registeredNativeForwarder = true;
+        }
+        const subscription = native.onInboxEventReceived(emitter);
+        this._inboxListenerCount += 1;
+
+        // Wrap remove() so unregistering the LAST JS listener also unregisters the native forwarder
+        // (restoring the SDK's default action handling). Guarded so a double remove() cannot
+        // unbalance the count and drop the forwarder while other subscriptions are still live.
+        const originalRemove = subscription.remove.bind(subscription);
+        let removed = false;
+        subscription.remove = () => {
+          if (removed) {
+            return;
+          }
+          removed = true;
+          originalRemove();
+          this._inboxListenerCount -= 1;
+          if (this._inboxListenerCount === 0) {
+            withNativeModule((n) => n.unregisterInboxEventListener());
+          }
+        };
+        return subscription;
+      } catch (error) {
+        // If the forwarder was registered and subscribing then failed, roll it back. Otherwise the
+        // SDK keeps suppressing its own action handling while nothing in JS is listening, so inbox
+        // actions are reported as handled and silently go nowhere.
+        if (registeredNativeForwarder) {
+          try {
+            native.unregisterInboxEventListener();
+          } catch (rollbackError) {
+            NativeLoggerListener.warn(
+              'Failed to roll back inbox listener registration:',
+              rollbackError
+            );
+          }
+        }
+        NativeLoggerListener.warn(
+          'Failed to attach inbox event listener:',
+          error
+        );
+        // Return a no-op subscription to maintain backwards compatibility
+        return {
+          remove: () => {},
+          eventType: '',
+          key: 0,
+          subscriber: null as any,
+        } as EventSubscription;
+      }
+    });
+  }
+
   /**
    * Dismisses any currently displayed in-app message
    */
@@ -81,6 +181,23 @@ class ZixflowInAppMessaging implements NativeInAppSpec {
     withNativeModule((native) => native.dismissMessage());
   }
 
+  /**
+   * Overrides the color scheme used to render in-app messages.
+   *
+   * Takes effect immediately: messages already on screen — inline views included — are
+   * re-themed in place, so this can be called whenever the app's appearance setting
+   * changes rather than only before a message is shown.
+   *
+   * @param colorScheme - scheme to render with; `ZixflowColorScheme.Auto` returns to following
+   * the device appearance
+   */
+  setColorScheme(colorScheme: ZixflowColorScheme) {
+    // Validated here as well as in `initialize`: this is a public method reachable from
+    // untyped JavaScript, and without it a bad value reaches the native fallback silently.
+    assert.colorScheme(colorScheme);
+    withNativeModule((native) => native.setColorScheme(colorScheme));
+  }
+
   /**
    * Gets the message inbox instance for managing inbox messages
    *
@@ -122,6 +239,12 @@ class InAppMessageEvent {
 
 // Export in-app messaging types and components for simplified imports
 export type { InlineInAppMessageViewProps } from './components';
+export type {
+  NotificationInboxBellViewProps,
+  NotificationInboxViewProps,
+} from './components';
+export { NotificationInboxBellView, NotificationInboxView } from './components';
 export { NotificationInbox } from './notification-inbox';
 export type { InboxMessage, NotificationInboxChangeListener } from './types';
+export { InboxEventType, InboxMessageEvent } from './types';
 export { ZixflowInAppMessaging, InAppMessageEvent, InlineInAppMessageView };

package/src/zixflow-liveactivities.ts

@@ -0,0 +1,86 @@
+import { type TurboModule } from 'react-native';
+import {
+  default as NativeModule,
+  type Spec as CodegenSpec,
+} from './specs/modules/NativeZixflowLiveActivities';
+import type { LiveActivityPayload } from './types/live-activities';
+
+/**
+ * Ensures all methods defined in codegen spec are implemented by the public module
+ *
+ * @internal
+ */
+interface NativeLiveActivitiesSpec extends Omit<
+  CodegenSpec,
+  keyof TurboModule
+> {}
+
+/**
+ * Live Activities (iOS) / Live Notifications (Android).
+ *
+ * Start, update, and end live, updating notifications from built-in templates
+ * (Segments, Countdown Timer). Enable the activity types via the `liveNotifications`
+ * key of the SDK config passed to {@link Zixflow.initialize}.
+ *
+ * @public
+ */
+export class ZixflowLiveActivities implements NativeLiveActivitiesSpec {
+  /**
+   * Report an opened Live Activity and return the URL the app should route.
+   *
+   * Zixflow tracking URLs are unwrapped to their destination after attribution is recorded.
+   * A tracking URL without a destination returns `null`; any other URL is returned unchanged.
+   * This method never rejects, so it can safely compose with Expo Router's
+   * `redirectSystemPath` hook. On Android it is a pass-through.
+   *
+   * Use this in exactly one URL-routing layer. Calling it more than once for the same Zixflow
+   * tracking URL reports more than one opened event.
+   *
+   * @param url - The incoming URL from the host's linking lifecycle.
+   * @returns The URL to route, or `null` when the Zixflow URL has no destination.
+   */
+  async handleWidgetUrl(url: string): Promise<string | null> {
+    try {
+      return await NativeModule.handleWidgetUrl(url);
+    } catch {
+      return url;
+    }
+  }
+
+  /**
+   * Start a built-in-template activity.
+   *
+   * @param payload - Template payload; `payload.type` selects the template.
+   * @returns The SDK-minted activity id, used for later `update`/`end`.
+   */
+  start(payload: LiveActivityPayload): Promise<string> {
+    return NativeModule.start(payload);
+  }
+
+  /**
+   * Replace the whole content-state of a running activity.
+   *
+   * ActivityKit (iOS) replaces content-state wholesale, so pass the **full** desired
+   * state — not just the changed fields. Static attributes (e.g. `header`) cannot
+   * change after start and are ignored on iOS.
+   *
+   * @param activityId - Id returned by {@link ZixflowLiveActivities.start}.
+   * @param payload - The complete desired state.
+   */
+  update(activityId: string, payload: LiveActivityPayload): Promise<void> {
+    return NativeModule.update(activityId, payload);
+  }
+
+  /**
+   * End a running activity, optionally rendering a final content-state.
+   *
+   * @param activityId - Id returned by {@link ZixflowLiveActivities.start}.
+   * @param payload - **iOS only.** The final content-state to render as the activity ends.
+   *   ActivityKit keeps the last content-state on screen when none is given, so pass one to show
+   *   a terminal state (e.g. all segments complete). Android renders its own terminal state and
+   *   ignores this.
+   */
+  end(activityId: string, payload?: LiveActivityPayload): Promise<void> {
+    return NativeModule.end(activityId, payload);
+  }
+}

package/zixflow-reactnative-richpush.podspec

@@ -15,7 +15,10 @@ Pod::Spec.new do |s|
 
   s.source       = { :git => "https://github.com/zixflow/zixflow-reactnative.git", :tag => "#{s.version}" }
 
-  s.source_files = "ios/**/*.{h,m,mm,swift}"
+  # Dependency-only pod: installed into the NSE target, whose job is purely to pull in the minimal
+  # CIO push dependency below. It must NOT compile any sources — everything under ios/ is the React
+  # Native bridge (React + DataPipelines + InApp + Inbox), none of which the NSE target has or should
+  # have. Globbing them here made the NSE compile the whole bridge and fail on React headers.
 
   # Note: Zixflow iOS SDK dependencies need to be added to NSE target via CocoaPods
   # Add these pods to your NotificationServiceExtension target in your Podfile:

package/zixflow-reactnative.podspec

@@ -14,6 +14,9 @@ Pod::Spec.new do |s|
   s.platforms    = { :ios => min_ios_version_supported }
   s.source       = { :git => "https://github.com/zixflow/zixflow-reactnative.git", :tag => "#{s.version}" }
 
+  # The generated Swift compatibility header imports
+  # <zixflow_reactnative/zixflow_reactnative.h> in static-library builds.
+  s.header_dir   = "zixflow_reactnative"
   s.source_files = "ios/wrappers/**/*.{h,m,mm,swift}"
 
   # Use install_modules_dependencies helper to install the dependencies if React Native version >=0.71.0.
@@ -28,6 +31,9 @@ Pod::Spec.new do |s|
   # Reference: https://guides.cocoapods.org/syntax/podfile.html#pod
   s.dependency "Zixflow/DataPipelines", package["zixflowNativeiOSSdkVersion"]
   s.dependency "Zixflow/MessagingInApp", package["zixflowNativeiOSSdkVersion"]
+  # Visual Notification Inbox UI (SwiftUI). Not optional: the bridge in ios/wrappers/inbox/* imports
+  # ZixflowMessagingInbox, and a pod target only sees the modules its podspec declares.
+  s.dependency "Zixflow/MessagingInbox", package["zixflowNativeiOSSdkVersion"]
 
   # If we do not specify a default_subspec, then *all* dependencies inside of *all* the subspecs will be downloaded by cocoapods.
   # Users should opt into push dependencies - FCM subspec downloads Firebase dependencies while APN does not.
@@ -57,4 +63,24 @@ Pod::Spec.new do |s|
       'OTHER_SWIFT_FLAGS' => '$(inherited) -DZIXFLOW_LOCATION_ENABLED'
     }
   end
+
+  # Geofence module is optional - customers must opt in by adding this subspec.
+  # It pulls in Location transitively (Zixflow/LocationGeofence depends on it).
+  # Geofence implies Location, so this subspec also enables the Location wrapper code.
+  s.subspec "geofence" do |ss|
+    ss.dependency "Zixflow/LocationGeofence", package["zixflowNativeiOSSdkVersion"]
+    ss.pod_target_xcconfig = {
+      'OTHER_SWIFT_FLAGS' => '$(inherited) -DZIXFLOW_GEOFENCE_ENABLED -DZIXFLOW_LOCATION_ENABLED'
+    }
+  end
+
+  # Live Activities module is optional - customers must opt in by adding this subspec, and must
+  # also add a Widget Extension target that renders the built-in templates. See the docs.
+  s.subspec "liveactivities" do |ss|
+    ss.dependency "Zixflow/LiveActivities", package["zixflowNativeiOSSdkVersion"]
+    ss.dependency "Zixflow/LiveActivitiesTemplates", package["zixflowNativeiOSSdkVersion"]
+    ss.pod_target_xcconfig = {
+      'OTHER_SWIFT_FLAGS' => '$(inherited) -DZIXFLOW_LIVEACTIVITIES_ENABLED'
+    }
+  end
 end