zixflow-reactnative 1.1.3 → 1.1.5

package/ios/wrappers/NativeZixflow.swift

@@ -2,14 +2,102 @@ import ZixflowAnalytics
 import ZixflowDataPipelines
 import ZixflowInternalCommon
 import ZixflowMessagingInApp
+import Foundation
 
 @objc(NativeZixflow)
 public class NativeZixflow: NSObject {
     private let logger: ZixflowInternalCommon.Logger = DIGraphShared.shared.logger
+    private weak var objcEventEmitter: AnyObject?
+    private var deepLinkHandlerToken: UUID?
     /// Checks whether the Zixflow SDK has been initialized.
     /// Returns `true` if the SDK has been successfully initialized, `false` otherwise.
     private var isInitialized: Bool { Zixflow.shared.implementation != nil }
 
+    /// Installs React Native scene deep-link routing before the JavaScript bridge starts.
+    /// Call this at the start of `scene(_:willConnectTo:options:)` in a UIScene host.
+    @objc
+    public static func configureSceneDeepLinkRouting() {
+        // A natively initialized host owns its callback. Scene connection happens after
+        // application launch, so never replace a callback that native initialization installed.
+        guard Zixflow.shared.implementation == nil else { return }
+        ZixflowReactNativeDeepLinkRouter.install()
+    }
+
+    /// Installs scene deep-link routing for the acknowledged JavaScript handler before the React
+    /// Native bridge starts. Call this at the start of `scene(_:willConnectTo:options:)` when the
+    /// host uses `Zixflow.setDeepLinkHandler`.
+    @objc
+    public static func configureAcknowledgedSceneDeepLinkRouting() {
+        // The cold scene connection happens before JavaScript can register its handler. Record the
+        // host's ownership choice now so initialization cannot drain a buffered URL into Linking.
+        guard Zixflow.shared.implementation == nil else { return }
+        ZixflowReactNativeDeepLinkRouter.installAcknowledgedHandler()
+    }
+
+    /// Installs deep-link routing for an Expo-owned scene lifecycle.
+    ///
+    /// Expo forwards scene URLs into React Native Linking itself, including on React Native
+    /// versions that do not expose the scene Linking selector used by the generic integration.
+    @objc
+    public static func configureExpoSceneDeepLinkRouting() {
+        guard Zixflow.shared.implementation == nil else { return }
+        // Native initialization preserves an existing callback when its config does not provide one.
+        ZixflowReactNativeDeepLinkRouter.installForExpoSceneLifecycle()
+    }
+
+    /// Marks the React Native Linking listener as ready for buffered scene URLs.
+    @objc
+    func setDeepLinkRoutingReady() {
+        ZixflowReactNativeDeepLinkRouter.markReactNativeReady()
+    }
+
+    @objc
+    public func setEventEmitter(_ emitter: AnyObject) {
+        objcEventEmitter = emitter
+    }
+
+    @objc
+    func registerDeepLinkHandler() {
+        guard objcEventEmitter != nil else {
+            logger.error("Zixflow could not register the React Native deep-link handler")
+            return
+        }
+
+        deepLinkHandlerToken = ZixflowReactNativeDeepLinkRouter.registerHandler { [weak self] id, url in
+            self?.sendDeepLink(id: id, url: url)
+        }
+    }
+
+    @objc
+    func unregisterDeepLinkHandler() {
+        guard let token = deepLinkHandlerToken else { return }
+        ZixflowReactNativeDeepLinkRouter.unregisterHandler(token)
+        deepLinkHandlerToken = nil
+    }
+
+    @objc
+    func acknowledgeDeepLink(_ id: String, handled: Bool) {
+        ZixflowReactNativeDeepLinkRouter.acknowledge(id, handled: handled)
+    }
+
+    @objc
+    func invalidate() {
+        unregisterDeepLinkHandler()
+    }
+
+    private func sendDeepLink(id: String, url: String) {
+        guard let emitter = objcEventEmitter else { return }
+
+        // Codegen derives this selector from `onDeepLinkReceived` in NativeZixflow.ts. Keep it
+        // in sync with that spec property and the forwarding override in NativeZixflow.mm.
+        let selector = Selector(("emitOnDeepLinkReceived:"))
+        guard emitter.responds(to: selector) else {
+            logger.error("Zixflow could not emit a React Native deep-link event")
+            return
+        }
+        _ = emitter.perform(selector, with: ["id": id, "url": url] as NSDictionary)
+    }
+
     /// Ensures that the Zixflow SDK is initialized before performing operations.
     /// Logs an error and returns false if the SDK is not initialized.
     private func ensureInitialized() -> Bool {
@@ -30,6 +118,7 @@ public class NativeZixflow: NSObject {
         // Skip initialization if already initialized
         if isInitialized {
             logger.info("Zixflow SDK is already initialized. Skipping initialization.")
+            ZixflowReactNativeDeepLinkRouter.markReactNativeReady()
             resolve(true)
             return
         }
@@ -48,12 +137,56 @@ public class NativeZixflow: NSObject {
 
             let sdkConfigBuilder = try SDKConfigBuilder.create(from: config)
 
+            let shouldInstallSceneRouter =
+                ZixflowReactNativeDeepLinkRouter.isSceneLifecycleEnabled ||
+                (packageSource == "Expo" && ZixflowReactNativeDeepLinkRouter.isExpoSceneLifecycleEnabled)
+            if shouldInstallSceneRouter {
+                _ = sdkConfigBuilder.deepLinkCallback { url in
+                    ZixflowReactNativeDeepLinkRouter.accept(url)
+                    return true // React Native Linking cannot report handling; JavaScript owns fallback.
+                }
+            }
+
             #if ZIXFLOW_LOCATION_ENABLED
-            if let locationModule = NativeLocation.module(from: config) {
+            // Geofence implies location: register the location module whenever location
+            // config is provided or geofence is enabled, since geofence relies on the
+            // location module's fixes.
+            #if ZIXFLOW_GEOFENCE_ENABLED
+            // Match NativeGeofence.module(from:): only a dictionary counts as configured,
+            // so a non-map value (e.g. null bridged from JS) doesn't imply location.
+            let geofenceConfigured = config["geofence"] as? [String: Any] != nil
+            #else
+            let geofenceConfigured = false
+            #endif
+            if let locationModule = NativeLocation.module(from: config, geofenceEnabled: geofenceConfigured) {
                 _ = sdkConfigBuilder.addModule(locationModule)
             }
             #endif
 
+            #if ZIXFLOW_GEOFENCE_ENABLED
+            // Geofence runs automatically once registered; relies on the location module above.
+            if let geofenceModule = NativeGeofence.module(from: config) {
+                _ = sdkConfigBuilder.addModule(geofenceModule)
+            }
+            #endif
+
+            #if ZIXFLOW_LIVEACTIVITIES_ENABLED
+            if let liveActivitiesModule = NativeLiveActivities.module(from: config) {
+                _ = sdkConfigBuilder.addModule(liveActivitiesModule)
+            }
+            #endif
+
+            // Customer value wins; default on when the geofence module is added, off otherwise.
+            #if ZIXFLOW_GEOFENCE_ENABLED
+            // Match NativeGeofence.module(from:): only a dictionary adds the module, so
+            // background delivery shouldn't default on for a non-map geofence value.
+            let geofenceAdded = config["geofence"] as? [String: Any] != nil
+            #else
+            let geofenceAdded = false
+            #endif
+            let allowBackgroundDelivery = (config["ios"] as? [String: Any])?["allowBackgroundDelivery"] as? Bool
+            _ = sdkConfigBuilder.allowBackgroundDelivery(allowBackgroundDelivery ?? geofenceAdded)
+
             let builtConfig = sdkConfigBuilder.build()
 
             // Only Zixflow.initialize must run on the main thread (e.g. for Location module).
@@ -77,6 +210,7 @@ public class NativeZixflow: NSObject {
                 self.logger.debug(
                     "Zixflow SDK (\(packageSource ?? "") \(packageVersion ?? "")) initialized with config: \(config)"
                 )
+                ZixflowReactNativeDeepLinkRouter.markReactNativeReady()
                 resolve(true)
             }
         } catch {

package/ios/wrappers/ZixflowReactNativeDeepLinkRequestStore.swift

@@ -0,0 +1,123 @@
+import Foundation
+
+struct ZixflowReactNativeDeepLinkRequestStore {
+    enum Acceptance: Equatable {
+        case buffered(UUID)
+        case linking(URL)
+        case handler(UUID, URL)
+    }
+
+    enum Resolution: Equatable {
+        case handled
+        case fallback(URL)
+    }
+
+    private enum DeliveryMode: Equatable {
+        case unavailable
+        case linking
+        case handler
+    }
+
+    private enum RequestState: Equatable {
+        case buffered
+        case awaitingAcknowledgement
+    }
+
+    private struct Request {
+        let id: UUID
+        let url: URL
+        var state: RequestState
+    }
+
+    private var isLinkingReady = false
+    private var requiresHandler = false
+    private var hasHandler = false
+    private var requests: [Request] = []
+
+    private var deliveryMode: DeliveryMode {
+        if hasHandler {
+            return .handler
+        }
+        if !requiresHandler, isLinkingReady {
+            return .linking
+        }
+        return .unavailable
+    }
+
+    var requiresAcknowledgedHandler: Bool {
+        requiresHandler
+    }
+
+    var canDeliverWithLinking: Bool {
+        isLinkingReady
+    }
+
+    mutating func requireAcknowledgedHandler() {
+        requiresHandler = true
+    }
+
+    mutating func accept(_ url: URL) -> Acceptance {
+        switch deliveryMode {
+        case .unavailable:
+            let request = Request(id: UUID(), url: url, state: .buffered)
+            requests.append(request)
+            return .buffered(request.id)
+        case .linking:
+            return .linking(url)
+        case .handler:
+            let request = Request(id: UUID(), url: url, state: .awaitingAcknowledgement)
+            requests.append(request)
+            return .handler(request.id, request.url)
+        }
+    }
+
+    mutating func useLinking() -> [URL] {
+        isLinkingReady = true
+        guard deliveryMode == .linking else { return [] }
+
+        let urls = requests.compactMap { request in
+            request.state == .buffered ? request.url : nil
+        }
+        requests.removeAll { $0.state == .buffered }
+        return urls
+    }
+
+    mutating func useHandler() -> [(UUID, URL)] {
+        hasHandler = true
+        var deliveries: [(UUID, URL)] = []
+        for index in requests.indices where requests[index].state == .buffered {
+            requests[index].state = .awaitingAcknowledgement
+            deliveries.append((requests[index].id, requests[index].url))
+        }
+        return deliveries
+    }
+
+    mutating func removeHandler() {
+        hasHandler = false
+    }
+
+    mutating func acknowledge(_ id: UUID, handled: Bool) -> Resolution? {
+        guard let index = requests.firstIndex(where: {
+            $0.id == id && $0.state == .awaitingAcknowledgement
+        }) else { return nil }
+
+        let url = requests.remove(at: index).url
+        return handled ? .handled : .fallback(url)
+    }
+
+    mutating func expireReadiness(_ id: UUID) -> URL? {
+        expire(id, expectedState: .buffered)
+    }
+
+    mutating func expireAcknowledgement(_ id: UUID) -> URL? {
+        expire(id, expectedState: .awaitingAcknowledgement)
+    }
+
+    private mutating func expire(_ id: UUID, expectedState: RequestState) -> URL? {
+        guard let index = requests.firstIndex(where: {
+            $0.id == id && $0.state == expectedState
+        }) else { return nil }
+
+        return requests.remove(at: index).url
+    }
+}

package/ios/wrappers/ZixflowReactNativeDeepLinkRouter.swift

@@ -0,0 +1,312 @@
+@_spi(Internal) import ZixflowInternalCommon
+import Foundation
+import UIKit
+
+enum ZixflowReactNativeDeepLinkRouter {
+    private static let readinessTimeout: TimeInterval = 10
+    private static let acknowledgementTimeout: TimeInterval = 10
+    private static let sceneManifestKey = "UIApplicationSceneManifest"
+    private static let sceneConfigurationsKey = "UISceneConfigurations"
+    private static let sceneOpenURLContextsSelector = NSSelectorFromString("scene:openURLContexts:")
+    // React Native 0.83.6 and 0.88.0-nightly-20260823-0c7f63a4e use this
+    // notification name and payload for Linking URL events.
+    private static let openURLNotification = Notification.Name("RCTOpenURLNotification")
+    private static let stateLock = NSLock()
+    private static var requestStore = ZixflowReactNativeDeepLinkRequestStore()
+    private static var handlerEmitter: ((_ id: String, _ url: String) -> Void)?
+    private static var handlerToken: UUID?
+
+    static var requiresAcknowledgedHandler: Bool {
+        stateLock.lock()
+        defer { stateLock.unlock() }
+        return requestStore.requiresAcknowledgedHandler
+    }
+
+    private static var hasSceneManifest: Bool {
+        guard let manifest = Bundle.main.object(forInfoDictionaryKey: sceneManifestKey) as? [String: Any],
+              let configurations = manifest[sceneConfigurationsKey] as? [String: Any]
+        else { return false }
+
+        return !configurations.isEmpty
+    }
+
+    /// Mirrors `RCTIsSceneDelegateApp()` without linking to the internal symbol, and also requires
+    /// React Native's scene-Linking entry point. A scene manifest alone does not make older React
+    /// Native versions scene-aware.
+    static var isSceneLifecycleEnabled: Bool {
+        guard hasSceneManifest,
+              let linkingManager = NSClassFromString("RCTLinkingManager")
+        else { return false }
+
+        return linkingManager.responds(to: sceneOpenURLContextsSelector)
+    }
+
+    /// Expo owns scene-to-Linking forwarding even when its React Native version does not expose
+    /// the scene selector itself.
+    static var isExpoSceneLifecycleEnabled: Bool {
+        hasSceneManifest && NSClassFromString("EXExpoAppSceneDelegate") != nil
+    }
+
+    static func install() {
+        guard isSceneLifecycleEnabled else { return }
+        installCallback(requiringAcknowledgedHandler: false)
+    }
+
+    static func installAcknowledgedHandler() {
+        guard isSceneLifecycleEnabled else {
+            DIGraphShared.shared.logger.error(
+                "Zixflow could not install acknowledged deep-link routing because the host " +
+                    "does not expose a supported React Native scene lifecycle"
+            )
+            return
+        }
+        installCallback(requiringAcknowledgedHandler: true)
+    }
+
+    /// Expo owns scene-to-Linking forwarding even on React Native versions that do not expose the
+    /// scene selector themselves. Prefer the generic React Native capability when available, then
+    /// fall back to Expo's scene delegate capability.
+    static func installForExpoSceneLifecycle() {
+        guard isSceneLifecycleEnabled || isExpoSceneLifecycleEnabled else {
+            DIGraphShared.shared.logger.error(
+                "Zixflow could not install Expo scene deep-link routing because the host " +
+                    "does not expose a supported React Native or Expo scene lifecycle"
+            )
+            return
+        }
+        installCallback(requiringAcknowledgedHandler: false)
+    }
+
+    private static func installCallback(requiringAcknowledgedHandler: Bool) {
+        stateLock.lock()
+        if requiringAcknowledgedHandler {
+            requestStore.requireAcknowledgedHandler()
+        }
+        stateLock.unlock()
+        DIGraphShared.shared.deepLinkUtil.setDeepLinkCallback { url in
+            accept(url)
+            return true
+        }
+    }
+
+    static func accept(_ url: URL) {
+        stateLock.lock()
+        let acceptance = requestStore.accept(url)
+        stateLock.unlock()
+
+        switch acceptance {
+        case let .buffered(id):
+            DIGraphShared.shared.logger.info(
+                "Zixflow buffered an SDK deep link until a React Native route is ready"
+            )
+            scheduleReadinessExpiration(for: id)
+        case let .linking(url):
+            route(url)
+        case let .handler(id, url):
+            publishToHandler(id: id, url: url)
+        }
+    }
+
+    static func markReactNativeReady() {
+        let markReady = {
+            stateLock.lock()
+            let urls = requestStore.useLinking()
+            stateLock.unlock()
+
+            urls.forEach(route)
+        }
+        if Thread.isMainThread {
+            markReady()
+        } else {
+            DispatchQueue.main.async(execute: markReady)
+        }
+    }
+
+    static func registerHandler(
+        _ emitter: @escaping (_ id: String, _ url: String) -> Void
+    ) -> UUID {
+        let token = UUID()
+        stateLock.lock()
+        let hasAcknowledgedHandlerConfiguration = requestStore.requiresAcknowledgedHandler
+        handlerToken = token
+        handlerEmitter = emitter
+        let deliveries = requestStore.useHandler()
+        stateLock.unlock()
+
+        if !hasAcknowledgedHandlerConfiguration {
+            DIGraphShared.shared.logger.error(
+                "Zixflow registered an acknowledged deep-link handler without configuring " +
+                    "acknowledged scene routing before React Native started"
+            )
+        }
+        for (id, url) in deliveries {
+            publishToHandler(id: id, url: url)
+        }
+        return token
+    }
+
+    static func unregisterHandler(_ token: UUID) {
+        stateLock.lock()
+        guard handlerToken == token else {
+            stateLock.unlock()
+            return
+        }
+        handlerToken = nil
+        handlerEmitter = nil
+        requestStore.removeHandler()
+        stateLock.unlock()
+    }
+
+    static func acknowledge(_ id: String, handled: Bool) {
+        guard let requestId = UUID(uuidString: id) else {
+            DIGraphShared.shared.logger.error(
+                "Zixflow ignored an invalid React Native deep-link acknowledgement"
+            )
+            return
+        }
+
+        stateLock.lock()
+        let resolution = requestStore.acknowledge(requestId, handled: handled)
+        stateLock.unlock()
+
+        switch resolution {
+        case .handled:
+            DIGraphShared.shared.logger.info(
+                "React Native acknowledged the Zixflow deep link"
+            )
+        case let .fallback(url):
+            DIGraphShared.shared.logger.info(
+                "React Native declined the Zixflow deep link; using the native fallback"
+            )
+            fallback(url)
+        case nil:
+            DIGraphShared.shared.logger.info(
+                "Zixflow ignored a late or unknown React Native deep-link acknowledgement; " +
+                    "the native fallback may have already routed the destination"
+            )
+        }
+    }
+
+    static func route(_ url: URL) {
+        let publish = {
+            // React Native's AppDelegate URL entry point rejects scene-based hosts. Linking listens
+            // for this notification in both lifecycle modes, so publish the URL without choosing a scene.
+            DIGraphShared.shared.logger.info(
+                "Zixflow published an SDK deep link to React Native Linking"
+            )
+            NotificationCenter.default.post(
+                name: openURLNotification,
+                object: nil,
+                userInfo: ["url": url.absoluteString]
+            )
+        }
+        if Thread.isMainThread {
+            publish()
+        } else {
+            DispatchQueue.main.async(execute: publish)
+        }
+    }
+
+    private static func publishToHandler(id: UUID, url: URL) {
+        let publish = {
+            stateLock.lock()
+            let emitter = handlerEmitter
+            stateLock.unlock()
+
+            emitter?(id.uuidString, url.absoluteString)
+            DispatchQueue.main.asyncAfter(deadline: .now() + acknowledgementTimeout) {
+                expireAcknowledgement(id)
+            }
+        }
+        if Thread.isMainThread {
+            publish()
+        } else {
+            DispatchQueue.main.async(execute: publish)
+        }
+    }
+
+    private static func scheduleReadinessExpiration(for id: UUID) {
+        DispatchQueue.main.asyncAfter(deadline: .now() + readinessTimeout) {
+            expireReadiness(id)
+        }
+    }
+
+    private static func expireReadiness(_ id: UUID) {
+        stateLock.lock()
+        let url = requestStore.expireReadiness(id)
+        stateLock.unlock()
+
+        guard let url else { return }
+
+        DIGraphShared.shared.logger.error(
+            "Zixflow is using the native fallback because React Native deep-link routing " +
+                "did not become ready in time"
+        )
+        fallback(url)
+    }
+
+    private static func expireAcknowledgement(_ id: UUID) {
+        stateLock.lock()
+        let url = requestStore.expireAcknowledgement(id)
+        stateLock.unlock()
+
+        guard let url else { return }
+
+        DIGraphShared.shared.logger.error(
+            "Zixflow is using the native fallback because the React Native deep-link " +
+                "handler did not acknowledge the URL in time"
+        )
+        fallback(url)
+    }
+
+    private static func fallback(_ url: URL) {
+        let open = {
+            let uiKit = DIGraphShared.shared.uIKitWrapper
+            if uiKit.continueNSUserActivity(webpageURL: url) {
+                DIGraphShared.shared.logger.info(
+                    "Zixflow deep link was handled by the host AppDelegate fallback"
+                )
+            } else if isAppOwnedCustomScheme(url) {
+                stateLock.lock()
+                let linkingIsReady = requestStore.canDeliverWithLinking
+                stateLock.unlock()
+                route(url)
+                if linkingIsReady {
+                    DIGraphShared.shared.logger.info(
+                        "Zixflow forwarded the host app's custom-scheme deep link to React " +
+                            "Native Linking"
+                    )
+                } else {
+                    DIGraphShared.shared.logger.error(
+                        "Zixflow published the host app's custom-scheme deep link before " +
+                            "React Native Linking was marked ready; the destination may not be handled"
+                    )
+                }
+            } else {
+                uiKit.open(url: url)
+                DIGraphShared.shared.logger.info(
+                    "Zixflow opened the deep link through the system fallback"
+                )
+            }
+        }
+        if Thread.isMainThread {
+            open()
+        } else {
+            DispatchQueue.main.async(execute: open)
+        }
+    }
+
+    private static func isAppOwnedCustomScheme(_ url: URL) -> Bool {
+        guard let scheme = url.scheme,
+              scheme.caseInsensitiveCompare("http") != .orderedSame,
+              scheme.caseInsensitiveCompare("https") != .orderedSame,
+              let urlTypes = Bundle.main.object(forInfoDictionaryKey: "CFBundleURLTypes")
+              as? [[String: Any]]
+        else { return false }
+
+        return urlTypes.contains { urlType in
+            guard let schemes = urlType["CFBundleURLSchemes"] as? [String] else { return false }
+            return schemes.contains { $0.caseInsensitiveCompare(scheme) == .orderedSame }
+        }
+    }
+}

package/ios/wrappers/geofence/NativeGeofence.mm

@@ -0,0 +1,46 @@
+#import <React/RCTBridgeModule.h>
+#import <RNZixflowSpec/RNZixflowSpec.h>
+
+// Objective-C wrapper for new architecture TurboModule implementation
+@interface RCTNativeZixflowGeofence : NSObject <NativeZixflowGeofenceSpec>
+// Bridge to Swift implementation for cross-language compatibility
+@property(nonatomic, strong) id<NativeZixflowGeofenceSpec> swiftBridge;
+@end
+
+@implementation RCTNativeZixflowGeofence
+
+RCT_EXPORT_MODULE()
+
+// Create TurboModule instance for new architecture JSI integration
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params {
+  return std::make_shared<facebook::react::NativeZixflowGeofenceSpecJSI>(params);
+}
+
+- (instancetype)init {
+  if (self = [super init]) {
+    // Use runtime class lookup - NativeGeofence class only exists when the ZixflowLocationGeofence subspec is installed
+    Class swiftClass = NSClassFromString(@"NativeZixflowGeofence");
+    if (swiftClass) {
+      _swiftBridge = [[swiftClass alloc] init];
+    }
+  }
+  return self;
+}
+
+// Module initialization can happen on background thread
++ (BOOL)requiresMainQueueSetup {
+  return NO;
+}
+
+- (void)refreshFromCurrentLocation {
+  if (!_swiftBridge) return;
+  [_swiftBridge refreshFromCurrentLocation];
+}
+
+// Export class factory function for React Native component registration
+Class<RCTBridgeModule> NativeZixflowGeofenceCls(void) {
+  return RCTNativeZixflowGeofence.class;
+}
+
+@end

package/ios/wrappers/geofence/NativeGeofence.swift

@@ -0,0 +1,27 @@
+#if ZIXFLOW_GEOFENCE_ENABLED
+import ZixflowDataPipelines
+import ZixflowLocationGeofence
+
+/// Registers the optional geofence module with the native iOS SDK and exposes its app-facing
+/// methods. The reference to `GeofenceModule` is isolated here so it is only compiled when the
+/// geofence subspec is installed. Geofence depends on the location module, which the caller
+/// registers alongside it.
+@objc(NativeZixflowGeofence)
+public class NativeGeofence: NSObject {
+
+    /// Returns a `GeofenceModule` when the app opts into geofence via the `geofence` config,
+    /// applying the optional `locationMode` (defaults to `.automatic`).
+    static func module(from config: [String: Any]) -> GeofenceModule? {
+        guard let geofenceConfig = config["geofence"] as? [String: Any] else { return nil }
+        let locationModeValue = geofenceConfig["locationMode"] as? String
+        let locationMode: GeofenceLocationMode =
+            locationModeValue?.uppercased() == "MANUAL" ? .manual : .automatic
+        return GeofenceModule(config: GeofenceModuleConfig(locationMode: locationMode))
+    }
+
+    @objc
+    func refreshFromCurrentLocation() {
+        Zixflow.geofence.refreshFromCurrentLocation()
+    }
+}
+#endif