omikit-plugin 4.1.6 → 4.1.7

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.6.21 |
+| iOS | OmiKit | 1.11.19 |
 
 ### 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,65 @@ 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) |
 
+### 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.6.22"
 
   // 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"}