omikit-plugin 4.1.6 → 4.1.8

package/README.md

@@ -54,8 +54,8 @@ The [omikit-plugin](https://www.npmjs.com/package/omikit-plugin) enables VoIP/SI
 
 | Platform | SDK | Version |
 |----------|-----|---------|
-| Android | OMIKIT | 2.6.9 |
-| iOS | OmiKit | 1.11.9 |
+| Android | OMICore | 2.7.0 |
+| iOS | OmiKit | 1.11.23 |
 
 ### Platform Requirements
 
@@ -1086,6 +1086,7 @@ await initCallWithUserPassword({
 | `initCallWithUserPassword(data)` | `Promise<boolean>` | Login with SIP username/password |
 | `initCallWithApiKey(data)` | `Promise<boolean>` | Login with API key |
 | `logout()` | `Promise<boolean>` | Logout and unregister SIP |
+| `logoutAndWait()` | `Promise<boolean>` | (v4.1.7+) Logout that **resolves only after** the SDK finishes the backend `devices/remove` HTTP call and clears local state. Use before an immediate re-login to avoid race conditions |
 
 ### Call Control
 
@@ -1135,12 +1136,165 @@ await initCallWithUserPassword({
 | Function | Returns | Description |
 |----------|---------|-------------|
 | `getProjectId()` | `Promise<string\|null>` | Current project ID |
-| `getAppId()` | `Promise<string\|null>` | Current app ID |
-| `getDeviceId()` | `Promise<string\|null>` | Current device ID |
+| `getAppId()` | `Promise<string\|null>` | Current app ID. (v4.1.7+ Android) Sourced from `OmiClient.getAppId()` to match `getOmiDevices()` payload |
+| `getDeviceId()` | `Promise<string\|null>` | Current device ID. (v4.1.7+ Android) Sourced from `OmiClient.getDeviceId()` to match `getOmiDevices()` payload |
 | `getFcmToken()` | `Promise<string\|null>` | FCM push token |
 | `getSipInfo()` | `Promise<string\|null>` | SIP info (`user@realm`) |
 | `getVoipToken()` | `Promise<string\|null>` | VoIP token (iOS only) |
 
+### On-Premise Endpoint Configuration (v4.1.8+) — Native Only
+
+> For enterprise customers self-hosting OMI infrastructure. Override SDK default endpoints / SIP proxy / STUN / TURN with the customer's own hosts. Each field is **optional** — omit any field to keep the SDK default. Persisted natively across app relaunches.
+
+**There is no JavaScript API for this feature.** Config must be set in `AppDelegate` (iOS) / `MainApplication` (Android), BEFORE React Native bootstraps. Setting from JS would race the SDK's first HTTP / SIP call (FCM token, push registration, VoIP push handler) and those requests would hit the default cloud endpoints. The native API persists the config so subsequent app launches are race-free.
+
+#### iOS — `AppDelegate.m`
+
+Add the call at the top of `didFinishLaunchingWithOptions:`, BEFORE the existing RN bootstrap and BEFORE any other Omi call:
+
+```objc
+#import <OmiKit/OmiKit.h>
+
+- (BOOL)application:(UIApplication *)application
+    didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
+
+  [OmiClient setOnPremiseInfoWithMobileSdkHost:@"omisdk.your-domain.com"
+                                callEventHost:@"call-event.your-domain.com"
+                                publicApiHost:@"public.your-domain.com"
+                                 pushInfoHost:@"push-info.your-domain.com"
+                                  app2AppHost:@"app-2-app.your-domain.com"
+                                logUploadHost:@"log-upload.your-domain.com"
+                                     sipProxy:@"sig.your-domain.com:5222"
+                                   stunServer:@"stun.your-domain.com:3478"
+                                   turnServer:@"turn.your-domain.com:2222"
+                                 turnUsername:@"your-turn-user"
+                                 turnPassword:@"your-turn-pass"];
+
+  // ... existing RN bootstrap (RCTAppDelegate / RCTReactNativeFactory)
+}
+```
+
+To revert: `[OmiClient clearOnPremiseInfo];`
+
+#### Android — `MainApplication.kt`
+
+Add the call at the top of `onCreate()`, BEFORE `SoLoader.init` and RN init:
+
+```kotlin
+import vn.vihat.omicall.omisdk.OmiClient
+
+class MainApplication : Application(), ReactApplication {
+  override fun onCreate() {
+    super.onCreate()
+
+    OmiClient.setOnPremiseInfo(
+      this,
+      mobileSdkHost = "omisdk.your-domain.com",
+      callEventHost = "call-event.your-domain.com",
+      publicApiHost = "public.your-domain.com",
+      pushInfoHost  = "push-info.your-domain.com",
+      app2AppHost   = "app-2-app.your-domain.com",
+      logUploadHost = "log-upload.your-domain.com",
+      sipProxy      = "sig.your-domain.com:5222",
+      stunServer    = "stun.your-domain.com:3478",
+      turnServer    = "turn.your-domain.com:2222",
+      turnUsername  = "your-turn-user",
+      turnPassword  = "your-turn-pass",
+    )
+
+    SoLoader.init(this, false)
+    // ... existing RN bootstrap
+  }
+}
+```
+
+To revert: `OmiClient.clearOnPremiseInfo(this)`.
+
+#### Field Reference
+
+**HTTP host groups** (SDK replaces scheme + host only; path + query preserved 100%):
+
+| Field | Replaces |
+|-------|----------|
+| `mobileSdkHost` | `omisdk-v1*.omicrm.com` — devices, extensions, network info, ICE provider, rtp log |
+| `callEventHost` | `call-event-v2*.omicrm.com` — call-action APIs |
+| `publicApiHost` | `public-v1*.omicrm.com` — init call API |
+| `pushInfoHost` | `push-info-v2*.omicrm.com` — has-answered |
+| `app2AppHost` | `app-2-app*.omicrm.com` — agent/customer login |
+| `logUploadHost` | `elastic-v2*.omicrm.com` — log upload |
+
+**SIP / Media** (`"host:port"` format):
+
+| Field | SDK default |
+|-------|------------|
+| `sipProxy` | `171.244.138.14:5222` |
+| `stunServer` | `stun.omicrm.com:3478` |
+| `turnServer` | `turn.omicrm.com:2222` |
+| `turnUsername` | embedded credentials |
+| `turnPassword` | embedded credentials |
+
+#### Behavior Notes
+
+- Config is **persisted** natively (iOS `NSUserDefaults` key `omicall/onpremise_config_v1`, Android `SharedPreferences` `omicall_onpremise`/`config_v1`) — no need to set on every app launch after the first.
+- Priority: **HTTP** → on-premise > SDK default. **SIP / Media** → on-premise > dynamic API provider > SDK default.
+- **Android DNS**: when on-premise is active, the SDK bypasses custom public DNS (`8.8.8.8` / `1.1.1.1`) and uses **system DNS** so internal hostnames resolve over the customer's private network / VPN. Applies to both OkHttp HTTP layer and PJSIP native.
+- Empty strings, null, and missing fields are treated identically as "keep SDK default" for that field.
+- Requires native SDK: iOS `OmiKit ≥ 1.11.23`, Android `OMICore ≥ 2.7.0`.
+- Backward compatible: clients that do not call `setOnPremiseInfo` see byte-for-byte identical behavior to earlier versions.
+
+### Backend Device Registration Check (v4.1.7+)
+
+> Read-only diagnostics for verifying the local device record still exists on the OMI backend. Useful after app reinstall, account migration, or backend cleanup. The SDK **never** auto-logouts — your app decides the recovery action.
+
+| Function | Returns | Description |
+|----------|---------|-------------|
+| `getOmiDevices()` | `Promise<OmiDeviceInfo[]>` | Fetch all devices registered on the OMI backend for the active SIP user. Empty array when not logged in / network error / parse error — never rejects |
+| `isCurrentDeviceRegistered()` | `Promise<boolean>` | `true` if the local `deviceId` + `appId` is in the backend list. Returns `false` early when not logged in (no HTTP call) |
+| `needsReLogin()` | `Promise<boolean>` | `true` when SIP user is set locally but the backend has no matching device (stale session — user must logout + login again) |
+| `findSipNumberByDeviceId(devices, deviceId)` | `string \| null` | Pure JS helper. Returns the `sipNumber` for the given device ID in the array, or `null` if not found |
+
+**`OmiDeviceInfo` shape (camelCase, normalized at JS layer):**
+
+```typescript
+type OmiDeviceInfo = {
+  deviceId: string;
+  token: string;
+  deviceType: 'ios' | 'android' | string;
+  voipToken: string;
+  appId: string;
+  createdTime: string;
+  projectId: string;
+  sipNumber: string;
+};
+```
+
+**Recommended usage:**
+
+```typescript
+import {
+  getOmiDevices,
+  needsReLogin,
+  findSipNumberByDeviceId,
+  getDeviceId,
+  logoutAndWait,
+} from 'omikit-plugin';
+
+
+// Or: verify the SIP account matches the one bound to this device
+const devices = await getOmiDevices();
+const myDeviceId = await getDeviceId();
+const boundSip = findSipNumberByDeviceId(devices, myDeviceId ?? '');
+if (boundSip !== expectedUsername) {
+  await logoutAndWait();
+  // Then re-login with correct credentials
+}
+```
+
+**Notes:**
+
+- Each call performs a fresh HTTP request — no caching. Call once after login / on foreground, not in tight loops.
+- Requires native SDK: iOS `OmiKit ≥ 1.11.19`, Android `OMICore ≥ 2.6.21`.
+
 ### Notification Control
 
 | Function | Returns | Description |

package/android/build.gradle

@@ -65,7 +65,7 @@ dependencies {
   // OMISDK
   implementation("androidx.work:work-runtime:2.8.1")
   implementation "androidx.security:security-crypto:1.1.0-alpha06"
-  api "io.omicrm.vihat:omi-sdk:2.6.9"
+  api "io.omicrm.vihat:omi-sdk:2.7.0"
 
   // React Native — resolved from consumer's node_modules
   implementation "com.facebook.react:react-native:+"

package/android/src/main/java/com/omikitplugin/OmikitPluginModule.kt

@@ -1151,6 +1151,36 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
     }
   }
 
+  /// Logout and wait for the SDK to fully clean up before resolving.
+  ///
+  /// `OmiClient.logout(onCompleted)` is a `suspend fun` that:
+  ///   - Fires HTTP `devices/remove` (fire-and-forget background)
+  ///   - Clears local SharedPreferences
+  ///   - Stops SipService and polls for PJSIP shutdown (up to 5s internally)
+  ///   - Invokes `onCompleted` only after the stack is fully down
+  ///
+  /// We pass an empty callback purely to opt into the SDK's internal wait
+  /// loop — without it the SDK skips waiting and returns immediately.
+  /// The plugin's coroutine `await`s the suspend call, so the JS promise
+  /// resolves only once the SDK signals completion (or its 5s internal
+  /// timeout elapses).
+  @ReactMethod
+  fun logoutAndWait(promise: Promise) {
+    val ctx = reactApplicationContext
+    if (ctx == null) {
+      promise.resolve(true)
+      return
+    }
+    mainScope.launch {
+      try {
+        OmiClient.getInstance(ctx).logout { /* opt-in to internal wait */ }
+      } catch (_: Throwable) {
+        // ignored — local state still cleaned by the SDK, safe to proceed
+      }
+      promise.resolve(true)
+    }
+  }
+
   @ReactMethod
   fun getCurrentUser(promise: Promise) {
     mainScope.launch {
@@ -1230,13 +1260,22 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
   @ReactMethod
   fun getAppId(promise: Promise) {
     try {
+      // Prefer SDK public API (OmiSDK 2.6.21+) — guarantees same value used when
+      // adding device to backend, so consumers can match against getOmiDevices().
+      val ctx = reactApplicationContext
+      if (ctx != null) {
+        val sdkAppId = OmiClient.getInstance(ctx).getAppId()
+        if (sdkAppId.isNotEmpty()) {
+          promise.resolve(sdkAppId)
+          return
+        }
+      }
       val info = OmiClient.registrationInfo
       if (info?.appId != null) {
         promise.resolve(info.appId)
         return
       }
-      // Fallback: get package name of the host app
-      promise.resolve(reactApplicationContext?.packageName)
+      promise.resolve(ctx?.packageName)
     } catch (e: Throwable) {
       promise.resolve(null)
     }
@@ -1245,15 +1284,24 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
   @ReactMethod
   fun getDeviceId(promise: Promise) {
     try {
+      // Prefer SDK public API (OmiSDK 2.6.21+) — guarantees same value used when
+      // adding device to backend, so consumers can match against getOmiDevices().
+      val ctx = reactApplicationContext
+      if (ctx != null) {
+        val sdkDeviceId = OmiClient.getInstance(ctx).getDeviceId()
+        if (sdkDeviceId.isNotEmpty()) {
+          promise.resolve(sdkDeviceId)
+          return
+        }
+      }
       val info = OmiClient.registrationInfo
       if (info?.deviceId != null) {
         promise.resolve(info.deviceId)
         return
       }
-      // Fallback: get Android ID directly
       val androidId = try {
         Settings.Secure.getString(
-          reactApplicationContext?.contentResolver,
+          ctx?.contentResolver,
           Settings.Secure.ANDROID_ID
         )
       } catch (e: Exception) { null }
@@ -1305,6 +1353,87 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
     promise.resolve(null)
   }
 
+  // MARK: - Backend Device Registration Check APIs (OmiSDK 2.6.20+)
+
+  /// Fetch the list of devices currently registered on OMI backend for the
+  /// active SIP user. Returns empty array on logout / network failure.
+  @ReactMethod
+  fun getOmiDevices(promise: Promise) {
+    val ctx = reactApplicationContext
+    if (ctx == null) {
+      promise.resolve(WritableNativeArray())
+      return
+    }
+    mainScope.launch {
+      val devices = withContext(Dispatchers.IO) {
+        try {
+          OmiClient.getInstance(ctx).getOmiDevices()
+        } catch (_: Throwable) {
+          emptyList()
+        }
+      }
+      val array: WritableArray = WritableNativeArray()
+      for (d in devices) {
+        val map: WritableMap = WritableNativeMap()
+        map.putString("device_id", d.deviceId)
+        map.putString("token", d.token)
+        map.putString("device_type", d.deviceType)
+        map.putString("voip_token", d.voipToken)
+        map.putString("app_id", d.appId)
+        // created_time may overflow Int — use Double for cross-bridge safety.
+        if (d.createdTime != null) {
+          map.putDouble("created_time", d.createdTime!!.toDouble())
+        }
+        map.putString("project_id", d.projectId)
+        map.putString("sipNumber", d.sipNumber)
+        array.pushMap(map)
+      }
+      promise.resolve(array)
+    }
+  }
+
+  /// Verify whether THIS device is registered on backend for the current SIP
+  /// user. Returns false early when not logged in.
+  @ReactMethod
+  fun isCurrentDeviceRegistered(promise: Promise) {
+    val ctx = reactApplicationContext
+    if (ctx == null) {
+      promise.resolve(false)
+      return
+    }
+    mainScope.launch {
+      val registered = withContext(Dispatchers.IO) {
+        try {
+          OmiClient.getInstance(ctx).isCurrentDeviceRegistered()
+        } catch (_: Throwable) {
+          false
+        }
+      }
+      promise.resolve(registered)
+    }
+  }
+
+  /// Returns true when a SIP user is set locally but no matching device exists
+  /// on backend — i.e. user must logout + login again to re-register.
+  @ReactMethod
+  fun needsReLogin(promise: Promise) {
+    val ctx = reactApplicationContext
+    if (ctx == null) {
+      promise.resolve(false)
+      return
+    }
+    mainScope.launch {
+      val needs = withContext(Dispatchers.IO) {
+        try {
+          OmiClient.getInstance(ctx).needsReLogin()
+        } catch (_: Throwable) {
+          false
+        }
+      }
+      promise.resolve(needs)
+    }
+  }
+
   @ReactMethod
   fun getAudio(promise: Promise) {
     val inputs = OmiClient.getInstance(reactApplicationContext!!).getAudioOutputs()

package/ios/CallProcess/CallManager.swift

@@ -621,12 +621,16 @@ func startCall(_ phoneNumber: String, isVideo: Bool, completion: @escaping (_: S
     try? call.sendDTMF(character)
   }
   
-  /// Toogle mtue
-  func toggleMute() {
+  /// Toggle mute via CallKit so the native call UI (lock screen, banner) stays in sync.
+  /// Completion fires after performSetMutedCallAction: updates call.muted — safe to read there.
+  func toggleMute(completion: ((Error?) -> Void)? = nil) {
     guard let call = getAvailableCall() else {
+      completion?(nil)
       return
     }
-    try? call.toggleMute()
+    omiLib.callManager.toggleMute(for: call) { error in
+      completion?(error)
+    }
   }
   
   /// Toogle hold

package/ios/Library/OmikitPlugin.m

@@ -86,6 +86,11 @@ RCT_EXTERN_METHOD(toggleOmiVideo:(RCTPromiseResolveBlock)resolve
 RCT_EXTERN_METHOD(logout:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
+// Logout and wait — resolves ONLY after the SDK has finished its async cleanup
+// (HTTP devices/remove + local state reset). Use this before re-login.
+RCT_EXTERN_METHOD(logoutAndWait:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
 // Register video event
 RCT_EXTERN_METHOD(registerVideoEvent:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
@@ -135,6 +140,16 @@ RCT_EXTERN_METHOD(getAppId:(RCTPromiseResolveBlock)resolve
 RCT_EXTERN_METHOD(getVoipToken:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
+// Backend device registration check APIs (OmiKit iOS 1.11.19 / OmiSDK Android 2.6.20)
+RCT_EXTERN_METHOD(getOmiDevices:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(isCurrentDeviceRegistered:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(needsReLogin:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
 // Get audio
 RCT_EXTERN_METHOD(getAudio:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)

package/ios/Library/OmikitPlugin.swift

@@ -158,12 +158,13 @@ public class OmikitPlugin: RCTEventEmitter {
   }
 
   @objc(toggleMute:rejecter:)
-  func toggleMute(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) -> Void {
-    CallManager.shareInstance().toggleMute()
-    if let call = CallManager.shareInstance().getAvailableCall() {
-      resolve(call.muted)
+  func toggleMute(resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+    CallManager.shareInstance().toggleMute { [weak self] _ in
+      // Read call.muted AFTER CallKit completes — value is authoritative at this point.
+      let muted = CallManager.shareInstance().getAvailableCall()?.muted ?? false
+      resolve(muted)
+      self?.sendMuteStatus()
     }
-    sendMuteStatus()
   }
   
   @objc(toggleSpeaker:rejecter:)
@@ -377,6 +378,21 @@ public class OmikitPlugin: RCTEventEmitter {
     CallManager.shareInstance().logout()
     resolve(true)
   }
+
+  /// Logout and wait for the SDK to fully clean up.
+  /// Uses OmiKit 1.11.x `logoutWithCompletion:` which fires on main thread
+  /// after HTTP devices/remove returns AND local SIP state (`currentSip`) is
+  /// reset. Safe to call `initCallWithUserPassword` immediately after this resolves.
+  ///
+  /// Resolves with the `success` flag from the SDK (true = backend confirmed
+  /// remove, false = local cleanup happened but server call failed — either
+  /// way the local state is now sane).
+  @objc(logoutAndWait:rejecter:)
+  func logoutAndWait(resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+    OmiClient.logout { success in
+      resolve(success)
+    }
+  }
   
   
   @objc(registerVideoEvent:rejecter:)
@@ -537,6 +553,44 @@ public class OmikitPlugin: RCTEventEmitter {
     resolve(OmiClient.getVoipToken())
   }
 
+  // MARK: - Backend Device Registration Check APIs (OmiKit 1.11.19)
+
+  /// Fetch the list of devices currently registered on OMI backend for active SIP user.
+  /// Runs on a background queue because OmiKit performs a synchronous HTTP request.
+  @objc(getOmiDevices:rejecter:)
+  func getOmiDevices(resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+    DispatchQueue.global(qos: .userInitiated).async {
+      let devices = OmiClient.getOmiDevices()
+      DispatchQueue.main.async {
+        resolve(devices)
+      }
+    }
+  }
+
+  /// Verify whether THIS device is registered on backend for the current SIP user.
+  /// Hits the network (via getOmiDevices) — dispatch off main thread.
+  @objc(isCurrentDeviceRegistered:rejecter:)
+  func isCurrentDeviceRegistered(resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+    DispatchQueue.global(qos: .userInitiated).async {
+      let registered = OmiClient.isCurrentDeviceRegistered()
+      DispatchQueue.main.async {
+        resolve(registered)
+      }
+    }
+  }
+
+  /// Convenience guard built on top of isCurrentDeviceRegistered. Returns true
+  /// when a SIP user is set locally but no matching device exists on backend.
+  @objc(needsReLogin:rejecter:)
+  func needsReLogin(resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+    DispatchQueue.global(qos: .userInitiated).async {
+      let needs = OmiClient.needsReLogin()
+      DispatchQueue.main.async {
+        resolve(needs)
+      }
+    }
+  }
+
   // MARK: - Audio Methods
   @objc(getAudio:rejecter:)
   func getAudio(resolve: @escaping RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
@@ -638,6 +692,70 @@ public class OmikitPlugin: RCTEventEmitter {
     ]
   }
 
+  // Event emitter — works across Old Architecture, New Architecture (Fabric),
+  // and bridgeless modes.
+  //
+  // Why the custom override:
+  //   In NewArch, the JS side talks to the codegen TurboModule wrapper, which
+  //   does NOT forward `addListener`/`removeListeners` to this Swift instance.
+  //   RCTEventEmitter's private `_listenerCount` therefore stays at 0, and
+  //   the default `sendEvent` short-circuits ("Sending X with no listeners
+  //   registered") — dropping every event.
+  //
+  // The fix:
+  //   1. Forward `addListener`/`removeListeners` to super so the legacy
+  //      counter is incremented when JS subscribes via the interop bridge.
+  //   2. Track an independent counter as a safety net for paths where super
+  //      cannot increment (pure bridgeless callableJSModules-only mode).
+  //   3. In `sendEvent`, try `super.sendEvent` first (uses RN-wired dispatch
+  //      for the current architecture), then fall back to direct calls to
+  //      `RCTDeviceEventEmitter` via bridge or callableJSModules. JS code
+  //      subscribes through the global `DeviceEventEmitter`, which is the
+  //      same channel.
+  private var jsListenerCount: Int = 0
+
+  @objc public override func addListener(_ eventName: String!) {
+    super.addListener(eventName)
+    jsListenerCount += 1
+    if jsListenerCount == 1 {
+      startObserving()
+    }
+  }
+
+  @objc public override func removeListeners(_ count: Double) {
+    super.removeListeners(count)
+    jsListenerCount = max(0, jsListenerCount - Int(count))
+    if jsListenerCount == 0 {
+      stopObserving()
+    }
+  }
+
+  @objc public override func sendEvent(withName name: String!, body: Any!) {
+    // Preferred: super uses RN's wired dispatch for the active architecture.
+    // Requires the counter to be non-zero, which is guaranteed by our
+    // `addListener` forwarding above whenever the legacy bridge is involved.
+    if jsListenerCount > 0 {
+      super.sendEvent(withName: name, body: body)
+      return
+    }
+    // Fallback 1: bridge route — works on Old Arch and NewArch interop bridge.
+    if let bridge = self.bridge {
+      bridge.enqueueJSCall(
+        "RCTDeviceEventEmitter",
+        method: "emit",
+        args: body != nil ? [name as Any, body as Any] : [name as Any],
+        completion: nil
+      )
+      return
+    }
+    // Fallback 2: bridgeless mode — only callableJSModules is available.
+    self.callableJSModules?.invokeModule(
+      "RCTDeviceEventEmitter",
+      method: "emit",
+      withArgs: body != nil ? [name as Any, body as Any] : [name as Any]
+    )
+  }
+
   // MARK: - Stub Methods for TurboModule Compatibility
   // These methods are Android-only but required by Codegen spec
 

package/lib/commonjs/NativeOmikitPlugin.js.map

@@ -1 +1 @@
-{"version":3,"names":["_reactNative","require","_default","TurboModuleRegistry","get","exports","default"],"sourceRoot":"../../src","sources":["NativeOmikitPlugin.ts"],"mappings":";;;;;;AACA,IAAAA,YAAA,GAAAC,OAAA;AAAmD,IAAAC,QAAA,GAqKpCC,gCAAmB,CAACC,GAAG,CAAO,cAAc,CAAC;AAAAC,OAAA,CAAAC,OAAA,GAAAJ,QAAA"}
+{"version":3,"names":["_reactNative","require","_default","TurboModuleRegistry","get","exports","default"],"sourceRoot":"../../src","sources":["NativeOmikitPlugin.ts"],"mappings":";;;;;;AACA,IAAAA,YAAA,GAAAC,OAAA;AAAmD,IAAAC,QAAA,GA8KpCC,gCAAmB,CAACC,GAAG,CAAO,cAAc,CAAC;AAAAC,OAAA,CAAAC,OAAA,GAAAJ,QAAA"}