omikit-plugin 3.3.29 → 4.0.2

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

@@ -120,7 +120,7 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
   private val mainScope = CoroutineScope(Dispatchers.Main)
   private var isIncoming: Boolean = false
   private var isAnswerCall: Boolean = false
-  private var permissionPromise: Promise? = null
+  @Volatile private var permissionPromise: Promise? = null
   
   // Call state management to prevent concurrent calls
   private var isCallInProgress: Boolean = false
@@ -134,7 +134,22 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
   override fun getName(): String {
     return NAME
   }
-  
+
+  override fun getConstants(): MutableMap<String, Any> {
+    return mutableMapOf(
+      "CALL_STATE_CHANGED" to CALL_STATE_CHANGED,
+      "MUTED" to MUTED,
+      "HOLD" to HOLD,
+      "SPEAKER" to SPEAKER,
+      "REMOTE_VIDEO_READY" to REMOTE_VIDEO_READY,
+      "CLICK_MISSED_CALL" to CLICK_MISSED_CALL,
+      "SWITCHBOARD_ANSWER" to SWITCHBOARD_ANSWER,
+      "CALL_QUALITY" to CALL_QUALITY,
+      "AUDIO_CHANGE" to AUDIO_CHANGE,
+      "REQUEST_PERMISSION" to REQUEST_PERMISSION
+    )
+  }
+
   /**
    * Check if we can start a new call (no concurrent calls, cooldown passed)
    */
@@ -145,12 +160,11 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
       
       // Check if call is in progress or cooldown not passed
       if (isCallInProgress) {
-        Log.d("OMISDK", "🚫 Call blocked: Call already in progress")
+
         return false
       }
       
       if (timeSinceLastCall < callCooldownMs) {
-        Log.d("OMISDK", "🚫 Call blocked: Cooldown period (${callCooldownMs - timeSinceLastCall}ms remaining)")
         return false
       }
       
@@ -165,7 +179,6 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
     synchronized(callStateLock) {
       isCallInProgress = true
       lastCallTime = System.currentTimeMillis()
-      Log.d("OMISDK", "📞 Call started, marking in progress")
     }
   }
   
@@ -175,7 +188,6 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
   private fun markCallEnded() {
     synchronized(callStateLock) {
       isCallInProgress = false
-      Log.d("OMISDK", "📴 Call ended, clearing in progress flag")
     }
   }
 
@@ -183,11 +195,8 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
     private val handler = Handler(Looper.getMainLooper())
 
   override fun incomingReceived(callerId: Int?, phoneNumber: String?, isVideo: Boolean?) {
-    Log.d("OMISDK", "=>> incomingReceived CALLED - BEFORE: isIncoming: $isIncoming, isAnswerCall: $isAnswerCall")
     isIncoming = true;
     isAnswerCall = false; // Reset answer state for new incoming call
-    Log.d("OMISDK", "=>> incomingReceived AFTER SET - isIncoming: $isIncoming, isAnswerCall: $isAnswerCall, phoneNumber: $phoneNumber")
-
     val typeNumber = OmiKitUtils().checkTypeNumber(phoneNumber ?: "")
 
     val map: WritableMap = WritableNativeMap().apply {
@@ -210,11 +219,8 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
       transactionId: String?,
   ) {
       isAnswerCall = true
-      Log.d("OMISDK", "=>> ON CALL ESTABLISHED => ")
 
       Handler(Looper.getMainLooper()).postDelayed({
-          Log.d("OmikitReactNative", "onCallEstablished")
-
           val typeNumber = OmiKitUtils().checkTypeNumber(phoneNumber ?: "")
 
           // ✅ Sử dụng safe WritableMap creation
@@ -233,18 +239,13 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
   }
 
   override fun onCallEnd(callInfo: MutableMap<String, Any?>, statusCode: Int) {
-      Log.d("OMISDK RN", "=>> onCallEnd CALLED - BEFORE RESET: isIncoming: $isIncoming, isAnswerCall: $isAnswerCall")
-      Log.d("OMISDK RN", "=>> onCallEnd callInfo => $callInfo")
-
       // Reset call state variables
       isIncoming = false
       isAnswerCall = false
       // Clear call progress state when remote party ends call
       markCallEnded()
-      Log.d("OMISDK", "=>> onCallEnd AFTER RESET - isIncoming: $isIncoming, isAnswerCall: $isAnswerCall")
-
       // Kiểm tra kiểu dữ liệu trước khi ép kiểu để tránh lỗi
-      val call = callInfo ?: mutableMapOf()
+      val call = callInfo
 
       val timeStartToAnswer = (call["time_start_to_answer"] as? Long) ?: 0L
       val timeEnd = (call["time_end"] as? Long) ?: 0L
@@ -267,18 +268,14 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
       )
       
       val map = createSafeWritableMap(eventData)
-
-      Log.d("OMISDK RN", "=>> onCallEnd  => ")
       sendEvent(CALL_STATE_CHANGED, map)
   }
 
   override fun onConnecting() {
-      Log.d("OMISDK", "=>> ON CONNECTING CALL => ")
-
       val map: WritableMap = WritableNativeMap().apply {
           putString("callerNumber", "")
           putBoolean("isVideo", NotificationService.isVideo)
-          putBoolean("incoming", isIncoming ?: false)
+          putBoolean("incoming", isIncoming)
           putString("transactionId", "")
           putString("_id", "")
           putInt("status", CallState.connecting.value)
@@ -299,18 +296,12 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
       val prePhoneNumber = OmiClient.prePhoneNumber ?: ""
       val typeNumber = OmiKitUtils().checkTypeNumber(prePhoneNumber)
 
-      Log.d("OMISDK", "=>> onRinging CALLED - BEFORE: isIncoming: $isIncoming, isAnswerCall: $isAnswerCall, callDirection: $callDirection")
-
       if (callDirection == "inbound") {
         isIncoming = true;
-        Log.d("OMISDK", "=>> onRinging SET isIncoming = true for inbound call")
       } else if (callDirection == "outbound") {
         isIncoming = false;
-        Log.d("OMISDK", "=>> onRinging SET isIncoming = false for outbound call")
       }
 
-      Log.d("OMISDK", "=>> onRinging AFTER: isIncoming: $isIncoming, isAnswerCall: $isAnswerCall")
-
       // ✅ Sử dụng safe WritableMap creation
       val eventData = mapOf(
           "callerNumber" to if (callDirection == "inbound") prePhoneNumber else "",
@@ -322,8 +313,6 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
       )
       
       val map = createSafeWritableMap(eventData)
-
-      Log.d("OMISDK", if (callDirection == "inbound") "=>> ON INCOMING CALL => " else "=>> ON RINGING CALL => ")
       sendEvent(CALL_STATE_CHANGED, map)
   }
 
@@ -331,13 +320,21 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
   override fun networkHealth(stat: Map<String, *>, quality: Int) {
     val map: WritableMap = WritableNativeMap()
     map.putInt("quality", quality)
+    // Pass full diagnostics from stat map
+    val statMap: WritableMap = WritableNativeMap()
+    (stat["mos"] as? Number)?.let { statMap.putDouble("mos", it.toDouble()) }
+    (stat["jitter"] as? Number)?.let { statMap.putDouble("jitter", it.toDouble()) }
+    (stat["latency"] as? Number)?.let { statMap.putDouble("latency", it.toDouble()) }
+    (stat["ppl"] as? Number)?.let { statMap.putDouble("packetLoss", it.toDouble()) }
+    (stat["lcn"] as? Number)?.let { statMap.putInt("lcn", it.toInt()) }
+    map.putMap("stat", statMap)
     sendEvent(CALL_QUALITY, map)
   }
 
   override fun onAudioChanged(audioInfo: Map<String, Any>) {
     val audio: WritableMap = WritableNativeMap()
-    audio.putString("name", audioInfo["name"] as String)
-    audio.putInt("type", audioInfo["type"] as Int)
+    audio.putString("name", audioInfo["name"] as? String ?: "")
+    audio.putInt("type", audioInfo["type"] as? Int ?: 0)
     val map: WritableMap = WritableNativeMap()
     val writeList = WritableNativeArray()
     writeList.pushMap(audio)
@@ -355,13 +352,9 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
   }
 
   override fun onOutgoingStarted(callerId: Int, phoneNumber: String?, isVideo: Boolean?) {
-      Log.d("OMISDK", "=>> onOutgoingStarted CALLED - BEFORE: isIncoming: $isIncoming, isAnswerCall: $isAnswerCall")
-      
       // For outgoing calls, set states appropriately
       isIncoming = false;
       isAnswerCall = false;
-      Log.d("OMISDK", "=>> onOutgoingStarted AFTER SET - isIncoming: $isIncoming, isAnswerCall: $isAnswerCall")
-
       val typeNumber = OmiKitUtils().checkTypeNumber(phoneNumber ?: "")
 
       val map: WritableMap = WritableNativeMap().apply {
@@ -384,8 +377,6 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
   }
 
   override fun onRegisterCompleted(statusCode: Int) {
-    Log.d("OMISDK", "=> ON REGISTER COMPLETED => status code: $statusCode")
-
     if (statusCode != 200) {
       val normalizedStatusCode = if (statusCode == 403) 853 else statusCode
       val typeNumber = ""
@@ -413,7 +404,6 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
         }
       })
     }
-    Log.d("OMISDK", "=>> onRequestPermission => $map")
     sendEvent(REQUEST_PERMISSION, map)
 
   }
@@ -456,16 +446,14 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
 
   override fun initialize() {
     super.initialize()
-    
-    
+
+    moduleInstance = this
     reactApplicationContext!!.addActivityEventListener(this)
     Handler(Looper.getMainLooper()).post {
-      OmiClient.getInstance(reactApplicationContext!!).addCallStateListener(this)
-      
-      // ✅ Add listener cho AUTO-UNREGISTER status
-      OmiClient.getInstance(reactApplicationContext!!).addCallStateListener(autoUnregisterListener)
-      
-      OmiClient.getInstance(reactApplicationContext!!).setDebug(false)
+      val client = OmiClient.getInstance(reactApplicationContext!!)
+      client.addCallStateListener(this)
+      client.addCallStateListener(autoUnregisterListener)
+      client.setDebug(false)
     }
   }
 
@@ -482,7 +470,6 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
       OmiClient.getInstance(reactApplicationContext!!).setDebug(false)
       promise.resolve(true)
     } catch (e: Exception) {
-      Log.e("OmikitPlugin", "❌ Error in startServices: ${e.message}", e)
       promise.resolve(false)
     }
   }
@@ -493,7 +480,7 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
   // ✅ Method để check status AUTO-UNREGISTER (DEPRECATED)
   @ReactMethod
   fun getAutoUnregisterStatus(promise: Promise) {
-    Log.w("OmikitPlugin", "⚠️ DEPRECATED: getAutoUnregisterStatus() - Use Silent Registration API instead")
+
     try {
       OmiClient.getInstance(reactApplicationContext!!).getAutoUnregisterStatus { isScheduled, timeUntilExecution ->
         try {
@@ -504,12 +491,10 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
           )
           promise.resolve(Arguments.makeNativeMap(status))
         } catch (e: Exception) {
-          Log.e("OmikitPlugin", "❌ Error in getAutoUnregisterStatus callback: ${e.message}", e)
           promise.resolve(null)
         }
       }
     } catch (e: Exception) {
-      Log.e("OmikitPlugin", "❌ Error calling getAutoUnregisterStatus: ${e.message}", e)
       promise.resolve(null)
     }
   }
@@ -517,7 +502,7 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
   // ✅ Method để manually prevent AUTO-UNREGISTER (DEPRECATED)
   @ReactMethod
   fun preventAutoUnregister(reason: String, promise: Promise) {
-    Log.w("OmikitPlugin", "⚠️ DEPRECATED: preventAutoUnregister() - No longer supported in new SDK version")
+
     // Function removed - no longer supported
     promise.resolve(false)
   }
@@ -525,47 +510,37 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
   // ✅ Convenience methods cho các scenario phổ biến (DEPRECATED)
   @ReactMethod
   fun prepareForIncomingCall(promise: Promise) {
-    Log.w("OmikitPlugin", "⚠️ DEPRECATED: prepareForIncomingCall() - Use Silent Registration API instead")
     try {
       OmiClient.getInstance(reactApplicationContext!!).prepareForIncomingCall()
       promise.resolve(true)
     } catch (e: Exception) {
-      Log.e("OmikitPlugin", "❌ Prepare for incoming call failed: ${e.message}", e)
       promise.resolve(false)
     }
   }
 
   @ReactMethod
   fun prepareForOutgoingCall(promise: Promise) {
-    Log.w("OmikitPlugin", "⚠️ DEPRECATED: prepareForOutgoingCall() - Use Silent Registration API instead")
     try {
       OmiClient.getInstance(reactApplicationContext!!).prepareForOutgoingCall()
       promise.resolve(true)
     } catch (e: Exception) {
-      Log.e("OmikitPlugin", "❌ Prepare for outgoing call failed: ${e.message}", e)
       promise.resolve(false)
     }
   }
 
   private fun prepareAudioSystem() {
     try {
-      // ✅ Check network connectivity first
       if (!isNetworkAvailable()) {
         return
       }
-      
+
       // Release any existing audio focus
       val audioManager = reactApplicationContext?.getSystemService(android.content.Context.AUDIO_SERVICE) as? android.media.AudioManager
       audioManager?.let {
-        // Reset audio mode
         it.mode = android.media.AudioManager.MODE_NORMAL
       }
-      
-      // Small delay để audio system ổn định
-      Thread.sleep(200)
-      
     } catch (e: Exception) {
-      Log.w("OmikitPlugin", "⚠️ Audio preparation warning: ${e.message}")
+      Log.w("OmikitPlugin", "Audio preparation warning: ${e.message}")
     }
   }
 
@@ -573,11 +548,17 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
   private fun isNetworkAvailable(): Boolean {
     return try {
       val connectivityManager = reactApplicationContext?.getSystemService(android.content.Context.CONNECTIVITY_SERVICE) as? android.net.ConnectivityManager
-      val activeNetwork = connectivityManager?.activeNetworkInfo
-      val isConnected = activeNetwork?.isConnectedOrConnecting == true
-      isConnected
+        ?: return true
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+        val network = connectivityManager.activeNetwork ?: return false
+        val capabilities = connectivityManager.getNetworkCapabilities(network) ?: return false
+        capabilities.hasCapability(android.net.NetworkCapabilities.NET_CAPABILITY_INTERNET)
+      } else {
+        @Suppress("DEPRECATION")
+        connectivityManager.activeNetworkInfo?.isConnectedOrConnecting == true
+      }
     } catch (e: Exception) {
-      Log.w("OmikitPlugin", "⚠️ Network check failed: ${e.message}")
+      Log.w("OmikitPlugin", "Network check failed: ${e.message}")
       true // Assume network is available if check fails
     }
   }
@@ -614,22 +595,32 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
     return map
   }
 
-  @RequiresApi(Build.VERSION_CODES.M)
   @ReactMethod
   fun systemAlertWindow(promise: Promise) {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
+      promise.resolve(true)
+      return
+    }
     val result = Settings.canDrawOverlays(reactApplicationContext)
     promise.resolve(result)
   }
 
-  @RequiresApi(Build.VERSION_CODES.M)
   @ReactMethod
   fun openSystemAlertSetting(promise: Promise) {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
+      promise.resolve(true)
+      return
+    }
+    val ctx = reactApplicationContext ?: run {
+      promise.resolve(false)
+      return
+    }
     val intent = Intent(
       Settings.ACTION_MANAGE_OVERLAY_PERMISSION,
-      Uri.parse("package:" + reactApplicationContext.packageName)
+      Uri.parse("package:" + ctx.packageName)
     )
     intent.flags = Intent.FLAG_ACTIVITY_NEW_TASK
-    reactApplicationContext.startActivity(intent)
+    ctx.startActivity(intent)
     promise.resolve(true)
   }
 
@@ -657,7 +648,7 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
                 val audioNotificationDescription = data.getString("audioNotificationDescription") ?: "Cuộc gọi audio"
                 val videoNotificationDescription = data.getString("videoNotificationDescription") ?: "Cuộc gọi video"
                 val representName = data.getString("representName") ?: ""
-                val isUserBusy = data.getBoolean("isUserBusy")
+                val isUserBusy = if (data.hasKey("isUserBusy")) data.getBoolean("isUserBusy") else false
 
                 // Configure push notification with extracted parameters
                 OmiClient.getInstance(context).configPushNotification(
@@ -681,15 +672,11 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
 
                 // Configure decline call behavior
                 OmiClient.getInstance(context).configureDeclineCallBehavior(isUserBusy)
-
-                Log.d("OmikitPlugin", "✅ Push notification configured successfully")
                 promise.resolve(true)
             } catch (e: Exception) {
-                Log.e("OmikitPlugin", "❌ Error configuring push notification: ${e.message}", e)
                 promise.reject("E_CONFIG_FAILED", "Failed to configure push notification", e)
             }
         } ?: run {
-            Log.e("OmikitPlugin", "❌ Current activity is null")
             promise.reject("E_NULL_ACTIVITY", "Current activity is null")
         }
     } catch (e: Exception) {
@@ -704,32 +691,34 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
       val userName = data.getString("userName")
       val password = data.getString("password")
       val realm = data.getString("realm")
-      val host = data.getString("host") ?: "vh.omicrm.com"
-      val isVideo = data.getBoolean("isVideo")
+      val host = data.getString("host").let { if (it.isNullOrEmpty()) "vh.omicrm.com" else it }
+      val isVideo = if (data.hasKey("isVideo")) data.getBoolean("isVideo") else false
       val firebaseToken = data.getString("fcmToken")
       val projectId = data.getString("projectId") ?: ""
+      val isSkipDevices = if (data.hasKey("isSkipDevices")) data.getBoolean("isSkipDevices") else false
 
       // Validate required parameters
       if (!ValidationHelper.validateRequired(mapOf(
           "userName" to userName,
-          "password" to password, 
+          "password" to password,
           "realm" to realm,
           "fcmToken" to firebaseToken
         ), promise)) return@launch
 
       withContext(Dispatchers.Default) {
         try {
-          // ✅ Cleanup trước khi register
+          // Cleanup before register using logout callback
           try {
-            OmiClient.getInstance(reactApplicationContext!!).logout()
-            delay(500) // Chờ cleanup hoàn tất
+            val logoutComplete = kotlinx.coroutines.CompletableDeferred<Unit>()
+            OmiClient.getInstance(reactApplicationContext!!).logout {
+              logoutComplete.complete(Unit)
+            }
+            // Wait for logout callback with timeout
+            kotlinx.coroutines.withTimeoutOrNull(3000) { logoutComplete.await() }
           } catch (e: Exception) {
-            Log.w("OmikitPlugin", "⚠️ Cleanup warning (expected): ${e.message}")
+            Log.w("OmikitPlugin", "Cleanup warning (expected): ${e.message}")
           }
-          
-          // ✅ Sử dụng Silent Registration API mới từ OmiSDK 2.3.67
-          Log.d("OmikitPlugin", "🔇 Using Silent Registration API for user: $userName")
-          
+
           OmiClient.getInstance(reactApplicationContext!!).silentRegister(
             userName = userName ?: "",
             password = password ?: "",
@@ -737,26 +726,18 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
             isVideo = isVideo ?: true,
             firebaseToken = firebaseToken ?: "",
             host = host,
-            projectId = projectId
+            projectId = projectId,
+            isSkipDevices = isSkipDevices
           ) { success, statusCode, message ->
-            Log.d("OmikitPlugin", "🔇 Silent registration callback - success: $success, status: $statusCode, message: $message")
-            if (success) {
-              Log.d("OmikitPlugin", "✅ Silent registration successful - no notification, no auto-unregister")
-              // ✅ Resolve promise với kết quả từ callback
-              promise.resolve(success)
+            if (success || statusCode == 200) {
+              promise.resolve(true)
             } else {
-              Log.e("OmikitPlugin", "❌ Silent registration failed: $message")
-              if (statusCode == 200) {
-                promise.resolve(true)
-              } else {
-                val (errorCode, errorMessage) = OmiRegistrationStatus.getError(statusCode)
-                promise.reject(errorCode, "$errorMessage (Status: $statusCode)")
-              }
+              val (errorCode, errorMessage) = OmiRegistrationStatus.getError(statusCode)
+              promise.reject(errorCode, "$errorMessage (Status: $statusCode)")
             }
           }
           
         } catch (e: Exception) {
-          Log.e("OmikitPlugin", "❌ Error during silent registration: ${e.message}", e)
           promise.reject("ERROR_INITIALIZATION_EXCEPTION", "OMICALL initialization failed due to an unexpected error: ${e.message}. Please check your network connection and configuration.", e)
         }
       }
@@ -765,22 +746,18 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
 
   @ReactMethod
   fun initCallWithApiKey(data: ReadableMap, promise: Promise) {
-    Log.d("OmikitPlugin", "🔑 initCallWithApiKey called")
     mainScope.launch {
       var loginResult = false
       val usrName = data.getString("fullName") ?: ""
       val usrUuid = data.getString("usrUuid")  ?: ""
       val apiKey = data.getString("apiKey") ?: ""
-      val isVideo = data.getBoolean("isVideo") ?: false
+      val isVideo = if (data.hasKey("isVideo")) data.getBoolean("isVideo") else false
       val phone = data.getString("phone")
       val firebaseToken = data.getString("fcmToken") ?: ""
       val projectId = data.getString("projectId") ?: ""
       
-      Log.d("OmikitPlugin", "🔑 Parameters - usrName: $usrName, usrUuid: $usrUuid, isVideo: $isVideo")
-
       withContext(Dispatchers.Default) {
         try {
-          Log.d("OmikitPlugin", "🔑 Starting validation")
           // Validate required parameters
           if (!ValidationHelper.validateRequired(mapOf(
               "fullName" to usrName,
@@ -792,8 +769,6 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
             return@withContext
           }
 
-          Log.d("OmikitPlugin", "✅ Validation passed")
-
           // Check RECORD_AUDIO permission for Android 14+
           val hasRecordAudio = ContextCompat.checkSelfPermission(
             reactApplicationContext, 
@@ -801,28 +776,22 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
           ) == PackageManager.PERMISSION_GRANTED
 
           if (!hasRecordAudio) {
-            Log.e("OmikitPlugin", "❌ RECORD_AUDIO permission is required for Android 14+")
             promise.resolve(false)
             return@withContext
           }
-
-          Log.d("OmikitPlugin", "✅ RECORD_AUDIO permission granted")
-
-          // ✅ Cleanup trước khi register với mutex
+          // Cleanup before register using logout callback
           try {
-            Log.d("OmikitPlugin", "🧹 Starting cleanup")
             omiClientMutex.withLock {
-              OmiClient.getInstance(reactApplicationContext!!).logout()
+              val logoutComplete = kotlinx.coroutines.CompletableDeferred<Unit>()
+              OmiClient.getInstance(reactApplicationContext!!).logout {
+                logoutComplete.complete(Unit)
+              }
+              kotlinx.coroutines.withTimeoutOrNull(3000) { logoutComplete.await() }
             }
-            delay(1000) // Chờ cleanup hoàn tất
-            Log.d("OmikitPlugin", "✅ Cleanup completed")
           } catch (e: Exception) {
-            Log.w("OmikitPlugin", "⚠️ Cleanup warning (expected): ${e.message}")
+            Log.w("OmikitPlugin", "Cleanup warning (expected): ${e.message}")
           }
 
-          Log.d("OmikitPlugin", "🔑 Using API key registration for user: $usrName")
-
-          Log.d("OmikitPlugin", "🔑 Calling OmiClient.registerWithApiKey...")
           omiClientMutex.withLock {
             loginResult = OmiClient.registerWithApiKey(
               apiKey ?: "",
@@ -834,16 +803,7 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
               projectId
             )
           }
-          
-          Log.d("OmikitPlugin", "🔑 OmiClient.registerWithApiKey returned: $loginResult")
-          
-          if (loginResult) {
-            Log.d("OmikitPlugin", "✅ API key registration successful")
-            promise.resolve(true)
-          } else {
-            Log.e("OmikitPlugin", "❌ API key registration failed")
-            promise.resolve(false)
-          }
+           promise.resolve(loginResult)
         } catch (e: Exception) {
           Log.e("OmikitPlugin", "❌ Error during API key registration: ${e.message}", e)
           promise.resolve(false)
@@ -855,21 +815,17 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
   @ReactMethod
   fun getInitialCall(counter: Int = 1, promise: Promise) {
       val context = reactApplicationContext ?: run {
-          Log.e("getInitialCall", "❌ React context is null")
           promise.resolve(false)
           return
       }
 
       val call = Utils.getActiveCall(context)
-      Log.d("getInitialCall RN", "📞 Active call: $call")
-
       if (call == null) {
           if (counter <= 0) {
               promise.resolve(false)
           } else {
               mainScope.launch {
-                  Log.d("getInitialCall RN", "🔄 Retrying in 2s... (Attempts left: $counter)")
-                  delay(1000) // Wait 2 seconds
+                  delay(1000) // Wait 1 second before retry
                   getInitialCall(counter - 1, promise) // Retry recursively
               }
           }
@@ -893,11 +849,8 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
                              statusPendingCall == 5 // 5 = User clicked pickup (CONFIRMED)
 
       if (shouldAutoAnswer) {
-          Log.d("getInitialCall RN", "🚀 AUTO-ANSWER: User clicked pickup (statusPendingCall=$statusPendingCall), answering call immediately")
           try {
               OmiClient.getInstance(context).pickUp()
-              Log.d("getInitialCall RN", "✅ AUTO-ANSWER: Call answered successfully")
-
               // Status already cleared by getStatusPendingCall()
           } catch (e: Exception) {
               Log.e("getInitialCall RN", "❌ AUTO-ANSWER: Failed to answer call: ${e.message}", e)
@@ -922,8 +875,6 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
       promise.resolve(map)
 
       if (statusPendingCall == 2 && call.state != 5) {
-          Log.d("getInitialCall RN", "🚀 Incoming Receive Triggered ($statusPendingCall)")
-
           val eventMap: WritableMap = WritableNativeMap().apply {
               putBoolean("isVideo", call.isVideo ?: false)
               putBoolean("incoming", true)
@@ -946,25 +897,34 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
       )
     val map: WritableMap = WritableNativeMap()
     if (audio == PackageManager.PERMISSION_GRANTED) {
-      currentActivity?.runOnUiThread {
-        val phoneNumber = data.getString("phoneNumber") as String
-        val isVideo = data.getBoolean("isVideo") ?: false;
-        
+      val activity = currentActivity
+      if (activity == null) {
+        promise.reject("E_NO_ACTIVITY", "Current activity is null")
+        return
+      }
+      activity.runOnUiThread {
+        val phoneNumber = data.getString("phoneNumber")
+        if (phoneNumber.isNullOrEmpty()) {
+          promise.reject("E_INVALID_PHONE", "Phone number is required")
+          return@runOnUiThread
+        }
+        val isVideo = if (data.hasKey("isVideo")) data.getBoolean("isVideo") else false
+
         val startCallResult =
           OmiClient.getInstance(reactApplicationContext!!).startCall(phoneNumber, isVideo)
-        var statusCalltemp = startCallResult.value as Int;
+        var statusCalltemp = startCallResult.value as Int
         if (startCallResult.value == 200 || startCallResult.value == 407) {
           statusCalltemp = 8
         }
         map.putInt("status", statusCalltemp)
         map.putString("_id", "")
-        map.putString("message", messageCall(startCallResult.value) as String)
+        map.putString("message", messageCall(startCallResult.value))
         promise.resolve(map)
       }
     } else {
       map.putInt("status", 4)
       map.putString("_id", "")
-      map.putString("message", messageCall(406) as String)
+      map.putString("message", messageCall(406))
       promise.resolve(map)
     }
   }
@@ -976,28 +936,27 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
         reactApplicationContext!!,
         Manifest.permission.RECORD_AUDIO
       )
-    Log.d("OMISDK", "📤 Start Call With UUID")
     val map: WritableMap = WritableNativeMap()
     if (audio == PackageManager.PERMISSION_GRANTED) {
       mainScope.launch {
         val uuid = data.getString("usrUuid") ?: ""
-        val isVideo = data.getBoolean("isVideo") ?: false;
-        
+        val isVideo = if (data.hasKey("isVideo")) data.getBoolean("isVideo") else false
+
         val startCallResult =
           OmiClient.getInstance(reactApplicationContext!!).startCallWithUuid(uuid, isVideo)
-        var statusCalltemp = startCallResult.value as Int;
+        var statusCalltemp = startCallResult.value as Int
         if (startCallResult.value == 200 || startCallResult.value == 407) {
           statusCalltemp = 8
         }
         map.putInt("status", statusCalltemp)
         map.putString("_id", "")
-        map.putString("message", messageCall(startCallResult.value) as String)
+        map.putString("message", messageCall(startCallResult.value))
         promise.resolve(map)
       }
     } else {
       map.putInt("status", 4)
       map.putString("_id", "")
-      map.putString("message", messageCall(406) as String)
+      map.putString("message", messageCall(406))
       promise.resolve(map)
     }
   }
@@ -1008,7 +967,7 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
       val appContext = reactApplicationContext.applicationContext
       val activity = currentActivity
 
-      if (appContext == null) {
+      if (appContext == null) { 
           promise.reject("E_NULL_CONTEXT", "Application context is null")
           return
       }
@@ -1044,15 +1003,11 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
 
  @ReactMethod
   fun rejectCall(promise: Promise) {
-      Log.d("OMISDK", "➡️ rejectCall called - isIncoming: $isIncoming, isAnswerCall: $isAnswerCall")
       if (isIncoming) {
-          Log.d("OMISDK", "📞 Incoming call")
           ValidationHelper.safeOmiClientAccess(reactApplicationContext!!) { omiClient ->
               if (!isAnswerCall) {
-                  Log.d("OMISDK", "🚫 Declining call with declineWithCode(true)")
                   omiClient.declineWithCode(true) // 486 Busy Here
               } else {
-                  Log.d("OMISDK", "📴 Call already answered, hanging up")
                   omiClient.hangUp()
               }
           }
@@ -1060,7 +1015,6 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
           markCallEnded()
           promise.resolve(true)
       } else {
-          Log.d("OMISDK", "📤 Not incoming call, skipping reject")
           promise.resolve(false)
       }
   }
@@ -1120,7 +1074,9 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
 
   @ReactMethod
   fun toggleSpeaker(promise: Promise) {
-    currentActivity?.runOnUiThread {
+    val activity = currentActivity
+    if (activity == null) { promise.resolve(null); return }
+    activity.runOnUiThread {
       val newStatus = OmiClient.getInstance(reactApplicationContext!!).toggleSpeaker()
       promise.resolve(newStatus)
       sendEvent(SPEAKER, newStatus)
@@ -1129,7 +1085,9 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
 
   @ReactMethod
   fun sendDTMF(data: ReadableMap, promise: Promise) {
-    currentActivity?.runOnUiThread {
+    val activity = currentActivity
+    if (activity == null) { promise.resolve(false); return }
+    activity.runOnUiThread {
       val character = data.getString("character")
       var characterCode: Int? = character?.toIntOrNull()
       if (character == "*") {
@@ -1147,7 +1105,9 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
 
   @ReactMethod
   fun switchOmiCamera(promise: Promise) {
-    currentActivity?.runOnUiThread {
+    val activity = currentActivity
+    if (activity == null) { promise.resolve(false); return }
+    activity.runOnUiThread {
       OmiClient.getInstance(reactApplicationContext!!).switchCamera()
       promise.resolve(true)
     }
@@ -1155,7 +1115,9 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
 
   @ReactMethod
   fun toggleOmiVideo(promise: Promise) {
-    currentActivity?.runOnUiThread {
+    val activity = currentActivity
+    if (activity == null) { promise.resolve(false); return }
+    activity.runOnUiThread {
       OmiClient.getInstance(reactApplicationContext!!).toggleCamera()
       promise.resolve(true)
     }
@@ -1261,14 +1223,111 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
     }
   }
 
+  // MARK: - Getter Functions
+  @ReactMethod
+  fun getProjectId(promise: Promise) {
+    try {
+      val info = OmiClient.registrationInfo
+      if (info?.projectId != null) {
+        promise.resolve(info.projectId)
+        return
+      }
+      // Fallback: get from Firebase project ID
+      val firebaseProjectId = try {
+        com.google.firebase.FirebaseApp.getInstance().options.projectId
+      } catch (e: Exception) { null }
+      promise.resolve(firebaseProjectId)
+    } catch (e: Throwable) {
+      promise.resolve(null)
+    }
+  }
+
+  @ReactMethod
+  fun getAppId(promise: Promise) {
+    try {
+      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)
+    } catch (e: Throwable) {
+      promise.resolve(null)
+    }
+  }
+
+  @ReactMethod
+  fun getDeviceId(promise: Promise) {
+    try {
+      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,
+          Settings.Secure.ANDROID_ID
+        )
+      } catch (e: Exception) { null }
+      promise.resolve(androidId)
+    } catch (e: Throwable) {
+      promise.resolve(null)
+    }
+  }
+
+  @ReactMethod
+  fun getFcmToken(promise: Promise) {
+    try {
+      val info = OmiClient.registrationInfo
+      if (info?.firebaseToken != null) {
+        promise.resolve(info.firebaseToken)
+        return
+      }
+      // Fallback: get FCM token directly from Firebase Messaging
+      try {
+        com.google.firebase.messaging.FirebaseMessaging.getInstance().token
+          .addOnSuccessListener { token -> promise.resolve(token) }
+          .addOnFailureListener { promise.resolve(null) }
+      } catch (e: Exception) {
+        promise.resolve(null)
+      }
+    } catch (e: Throwable) {
+      promise.resolve(null)
+    }
+  }
+
+  @ReactMethod
+  fun getSipInfo(promise: Promise) {
+    try {
+      val sipUser = OmiClient.getInstance(reactApplicationContext!!).getSipUser()
+      val sipRealm = OmiClient.getInstance(reactApplicationContext!!).getSipRealm()
+      if (!sipUser.isNullOrEmpty() && !sipRealm.isNullOrEmpty()) {
+        promise.resolve("$sipUser@$sipRealm")
+      } else {
+        promise.resolve(sipUser)
+      }
+    } catch (e: Throwable) {
+      promise.resolve(null)
+    }
+  }
+
+  @ReactMethod
+  fun getVoipToken(promise: Promise) {
+    // VoIP token is iOS only, Android returns null
+    promise.resolve(null)
+  }
+
   @ReactMethod
   fun getAudio(promise: Promise) {
     val inputs = OmiClient.getInstance(reactApplicationContext!!).getAudioOutputs()
     val writeList = WritableNativeArray()
     inputs.forEach {
       val map = WritableNativeMap()
-      map.putString("name", it["name"] as String)
-      map.putInt("type", it["type"] as Int)
+      map.putString("name", it["name"] as? String ?: "")
+      map.putInt("type", it["type"] as? Int ?: 0)
       writeList.pushMap(map)
     }
     promise.resolve(writeList)
@@ -1278,8 +1337,8 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
   fun getCurrentAudio(promise: Promise) {
     val currentAudio = OmiClient.getInstance(reactApplicationContext!!).getCurrentAudio()
     val map: WritableMap = WritableNativeMap()
-    map.putString("name", currentAudio["name"] as String)
-    map.putInt("type", currentAudio["type"] as Int)
+    map.putString("name", currentAudio["name"] as? String ?: "")
+    map.putInt("type", currentAudio["type"] as? Int ?: 0)
     val writeList = WritableNativeArray()
     writeList.pushMap(map)
     promise.resolve(writeList)
@@ -1294,14 +1353,16 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
 
   @ReactMethod
   fun transferCall(data: ReadableMap, promise: Promise) {
-    currentActivity?.runOnUiThread {
+    val activity = currentActivity
+    if (activity == null) { promise.resolve(false); return }
+    activity.runOnUiThread {
       val phone = data.getString("phoneNumber")
-      Log.d("phone", "phone transferCall  ==>> ${phone} ")
-      if (reactApplicationContext != null) {
-        Log.d("phone", "phone transferCall  reactApplicationContext ==>> ${phone} ")
-        OmiClient.getInstance(reactApplicationContext!!).forwardCallTo(phone as String)
-        promise.resolve(true)
+      if (phone.isNullOrEmpty()) {
+        promise.reject("E_INVALID_PHONE", "Phone number is required for transfer")
+        return@runOnUiThread
       }
+      OmiClient.getInstance(reactApplicationContext!!).forwardCallTo(phone)
+      promise.resolve(true)
     }
   }
 
@@ -1310,6 +1371,9 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
     const val REQUEST_PERMISSIONS_CODE = 1001
     const val REQUEST_OVERLAY_PERMISSION_CODE = 1002
 
+    // Singleton reference for companion methods to access module instance
+    @Volatile var moduleInstance: OmikitPluginModule? = null
+
     fun onDestroy() {
       try {
         // Cleanup OmiClient resources safely
@@ -1320,7 +1384,6 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
 
     fun onResume(act: ReactActivity) {
       act.let { context ->
-        Log.d("OMISDK_REACT", "=>> onResume => ")
         OmiClient.getInstance(context, true)
         OmiClient.isAppReady = true;
       }
@@ -1349,37 +1412,28 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
       act: ReactActivity
     ) {
       try {
-        val deniedPermissions = mutableListOf<String>()
         val grantedPermissions = mutableListOf<String>()
-        
+
         for (i in permissions.indices) {
           if (grantResults[i] == PackageManager.PERMISSION_GRANTED) {
             grantedPermissions.add(permissions[i])
-          } else {
-            deniedPermissions.add(permissions[i])
           }
         }
-        
-        Log.d("OmikitPlugin", "✅ Granted: ${grantedPermissions.joinToString()}")
-        if (deniedPermissions.isNotEmpty()) {
-          Log.w("OmikitPlugin", "❌ Denied: ${deniedPermissions.joinToString()}")
-        }
-        
+
         // Check if we have essential permissions for VoIP
         val hasRecordAudio = grantedPermissions.contains(Manifest.permission.RECORD_AUDIO)
         val hasCallPhone = grantedPermissions.contains(Manifest.permission.CALL_PHONE)
         val hasModifyAudio = grantedPermissions.contains(Manifest.permission.MODIFY_AUDIO_SETTINGS)
-        
+
         val canProceed = hasRecordAudio && hasCallPhone && hasModifyAudio
-        
-        if (canProceed) {
-          Log.d("OmikitPlugin", "🎉 Essential VoIP permissions granted!")
-        } else {
-          Log.e("OmikitPlugin", "⚠️ Missing essential VoIP permissions - app may not work properly")
-        }
-        
+
+        // Resolve the stored permission promise
+        moduleInstance?.permissionPromise?.resolve(canProceed)
+        moduleInstance?.permissionPromise = null
       } catch (e: Exception) {
-        Log.e("OmikitPlugin", "❌ Error handling permission results: ${e.message}", e)
+        Log.e("OmikitPlugin", "Error handling permission results: ${e.message}", e)
+        moduleInstance?.permissionPromise?.resolve(false)
+        moduleInstance?.permissionPromise = null
       }
     }
 
@@ -1392,7 +1446,6 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
       try {
         val isIncoming = intent.getBooleanExtra(SipServiceConstants.ACTION_IS_INCOMING_CALL, false)
         if (!isIncoming) {
-          Log.d("PICKUP-FIX", "Not an incoming call intent, skipping")
           return
         }
 
@@ -1400,20 +1453,17 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
           SipServiceConstants.ACTION_ACCEPT_INCOMING_CALL, false
         )
 
-        Log.d("PICKUP-FIX", "🚀 Early intent handler - isIncoming: $isIncoming, isAccepted: $isAcceptedCall")
 
         // Save to SharedPreferences so getInitialCall() can detect it later
         // setStatusPendingCall(true) → saves status=5 (CONFIRMED)
         // setStatusPendingCall(false) → saves status=2 (INCOMING)
         OmiKitUtils().setStatusPendingCall(act, isAcceptedCall)
-        Log.d("PICKUP-FIX", "✅ Saved pickup state to SharedPreferences (isAccepted=$isAcceptedCall)")
 
         if (isAcceptedCall) {
           // Try to answer immediately if possible (may fail if SDK not ready)
           try {
             OmiClient.getInstance(act, true)?.let { client ->
               client.pickUp()
-              Log.d("PICKUP-FIX", "✅ Successfully answered call immediately")
             } ?: Log.w("PICKUP-FIX", "⚠️ OmiClient not ready, will auto-answer in getInitialCall()")
           } catch (e: Exception) {
             Log.w("PICKUP-FIX", "⚠️ Cannot answer immediately (SDK not ready): ${e.message}. Will auto-answer in getInitialCall()")
@@ -1440,7 +1490,8 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
         )
         if (isReopenCall) {
           val activeCall = Utils.getActiveCall(context)
-          OmikitPluginModule(context).onCallEstablished(
+          // Use singleton module instance instead of creating a throwaway one
+          moduleInstance?.onCallEstablished(
             activeCall?.id ?: 0,
             activeCall?.remoteNumber,
             activeCall?.isVideo,
@@ -1453,7 +1504,6 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
           }
           OmiKitUtils().setStatusPendingCall(context, isAcceptedCall)
         }
-
       }
     }
   }
@@ -1461,19 +1511,16 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
   // ✅ Di chuyển sendEvent vào trong class để có thể access reactApplicationContext
   private fun sendEvent(eventName: String?, params: Any?) {
     if (eventName == null) {
-      Log.e("OmikitPlugin", "❌ eventName is null or empty. Không thể gửi event.")
       return
     }
     
     try {
       // ✅ Kiểm tra reactApplicationContext
       if (reactApplicationContext == null) {
-        Log.e("OmikitPlugin", "❌ reactApplicationContext is null")
         return
       }
       
       if (!reactApplicationContext.hasActiveReactInstance()) {
-        Log.w("OmikitPlugin", "⚠️ ReactApplicationContext không có active React instance")
         return
       }
       
@@ -1498,45 +1545,29 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
     }
   }
 
-  // ✅ Thêm method để React Native biết các event được hỗ trợ
-  override fun getConstants(): MutableMap<String, Any> {
-    return hashMapOf(
-      "CALL_STATE_CHANGED" to CALL_STATE_CHANGED,
-      "MUTED" to MUTED,
-      "HOLD" to HOLD,
-      "SPEAKER" to SPEAKER,
-      "CALL_QUALITY" to CALL_QUALITY,
-      "AUDIO_CHANGE" to AUDIO_CHANGE,
-      "SWITCHBOARD_ANSWER" to SWITCHBOARD_ANSWER,
-      "REQUEST_PERMISSION" to REQUEST_PERMISSION,
-      "CLICK_MISSED_CALL" to CLICK_MISSED_CALL,
-      "AUTO_UNREGISTER_STATUS" to "AUTO_UNREGISTER_STATUS"
-    )
-  }
-
   @ReactMethod
   fun checkAndRequestPermissions(isVideo: Boolean, promise: Promise) {
     try {
       val missingPermissions = getMissingPermissions(isVideo)
       
       if (missingPermissions.isEmpty()) {
-        Log.d("OmikitPlugin", "✅ All permissions already granted")
         promise.resolve(true)
         return
       }
       
-      Log.d("OmikitPlugin", "📋 Missing permissions: ${missingPermissions.joinToString()}")
-      
       // Store promise for callback
       permissionPromise = promise
       
+      val activity = reactApplicationContext?.currentActivity ?: run {
+        promise.resolve(false)
+        return
+      }
       ActivityCompat.requestPermissions(
-        reactApplicationContext.currentActivity!!,
+        activity,
         missingPermissions.toTypedArray(),
         REQUEST_PERMISSIONS_CODE,
       )
     } catch (e: Exception) {
-      Log.e("OmikitPlugin", "❌ Error checking permissions: ${e.message}", e)
       promise.resolve(false)
     }
   }
@@ -1621,15 +1652,16 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
         true
       }
       
-      permissionStatus["essentialGranted"] = grantedEssential
-      permissionStatus["essentialMissing"] = missingEssential
-      permissionStatus["canMakeVoipCalls"] = missingEssential.isEmpty()
-      permissionStatus["foregroundServicePermissions"] = foregroundServiceStatus
-      permissionStatus["canDrawOverlays"] = canDrawOverlays
-      permissionStatus["androidVersion"] = Build.VERSION.SDK_INT
-      permissionStatus["targetSdk"] = reactApplicationContext.applicationInfo.targetSdkVersion
-      
-      val map = Arguments.makeNativeMap(permissionStatus)
+      val map: WritableMap = WritableNativeMap()
+      map.putArray("essentialGranted", Arguments.fromList(grantedEssential.toList()))
+      map.putArray("essentialMissing", Arguments.fromList(missingEssential.toList()))
+      map.putBoolean("canMakeVoipCalls", missingEssential.isEmpty())
+      val fgServiceMap: WritableMap = WritableNativeMap()
+      foregroundServiceStatus.forEach { (k, v) -> fgServiceMap.putBoolean(k, v) }
+      map.putMap("foregroundServicePermissions", fgServiceMap)
+      map.putBoolean("canDrawOverlays", canDrawOverlays)
+      map.putInt("androidVersion", Build.VERSION.SDK_INT)
+      map.putInt("targetSdk", reactApplicationContext.applicationInfo.targetSdkVersion)
       promise.resolve(map)
       
     } catch (e: Exception) {
@@ -1704,48 +1736,54 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
       // Store promise for callback
       permissionPromise = promise
       
-      Log.d("OmikitPlugin", "🔐 Requesting permissions for codes ${permissionCodes.joinToString()}: ${permissionsToRequest.joinToString()}")
-      
+      val activity = reactApplicationContext?.currentActivity ?: run {
+        promise.reject("E_NULL_ACTIVITY", "Current activity is null")
+        return
+      }
       ActivityCompat.requestPermissions(
-        reactApplicationContext.currentActivity!!,
+        activity,
         permissionsToRequest.toTypedArray(),
         REQUEST_PERMISSIONS_CODE
       )
       
     } catch (e: Exception) {
-      Log.e("OmikitPlugin", "❌ Error requesting permissions by codes: ${e.message}", e)
       promise.reject("ERROR_PERMISSION_REQUEST", "Failed to request permissions: ${e.message}")
     }
   }
 
   private fun requestPermission(isVideo: Boolean) {
     val missingPermissions = getMissingPermissions(isVideo)
-    
+
     if (missingPermissions.isEmpty()) {
-      Log.d("OmikitPlugin", "✅ All permissions already granted")
       return
     }
-    
-    Log.d("OmikitPlugin", "📋 Requesting missing permissions for Android ${Build.VERSION.SDK_INT}: ${missingPermissions.joinToString()}")
-    
+
+    val activity = reactApplicationContext?.currentActivity ?: return
     ActivityCompat.requestPermissions(
-      reactApplicationContext.currentActivity!!,
+      activity,
       missingPermissions.toTypedArray(),
       REQUEST_PERMISSIONS_CODE,
     )
   }
 
-  override fun onActivityResult(p0: Activity?, p1: Int, p2: Int, p3: Intent?) {
+  override fun onActivityResult(activity: Activity, requestCode: Int, resultCode: Int, data: Intent?) {
+    if (requestCode == REQUEST_OVERLAY_PERMISSION_CODE) {
+      val granted = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+        Settings.canDrawOverlays(reactApplicationContext)
+      } else {
+        true
+      }
+      permissionPromise?.resolve(granted)
+      permissionPromise = null
+    }
   }
 
-  override fun onNewIntent(p0: Intent?) {
-    if (p0 != null && p0.hasExtra(SipServiceConstants.PARAM_IS_MISSED_CALL)) {
-      //do your Stuff
-
-      if (p0.getBooleanExtra(SipServiceConstants.PARAM_IS_MISSED_CALL, false)) {
+  override fun onNewIntent(intent: Intent) {
+    if (intent.hasExtra(SipServiceConstants.PARAM_IS_MISSED_CALL)) {
+      if (intent.getBooleanExtra(SipServiceConstants.PARAM_IS_MISSED_CALL, false)) {
         val map: WritableMap = WritableNativeMap()
-        map.putString("callerNumber", p0.getStringExtra(SipServiceConstants.PARAM_NUMBER) ?: "")
-        map.putBoolean("isVideo", p0.getBooleanExtra(SipServiceConstants.PARAM_IS_VIDEO, false))
+        map.putString("callerNumber", intent.getStringExtra(SipServiceConstants.PARAM_NUMBER) ?: "")
+        map.putBoolean("isVideo", intent.getBooleanExtra(SipServiceConstants.PARAM_IS_VIDEO, false))
         sendEvent(CLICK_MISSED_CALL, map)
       }
     }
@@ -1760,16 +1798,10 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
     }
   }
 
-  // ✅ Thêm listener cho AUTO-UNREGISTER status
+  // Auto-unregister listener - only handles onAutoUnregisterStatus
+  // Other callbacks are NO-OP to prevent double-firing events (Fix #1)
   private val autoUnregisterListener = object : OmiListener {
     override fun onAutoUnregisterStatus(isScheduled: Boolean, timeUntilExecution: Long) {
-      // ✅ Auto-unregister prevention removed - no longer supported in new SDK
-      if (isScheduled && timeUntilExecution > 0 && timeUntilExecution < 3000) {
-        Log.w("OmikitPlugin", "🚨 AUTO-UNREGISTER sắp thực hiện trong ${timeUntilExecution}ms - SDK tự xử lý")
-        // preventAutoUnregisterCrash deprecated - SDK handles automatically
-      }
-      
-      // ✅ Gửi event cho React Native
       try {
         val statusData = mapOf(
           "isScheduled" to isScheduled,
@@ -1779,94 +1811,48 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
         val map = createSafeWritableMap(statusData)
         sendEvent("AUTO_UNREGISTER_STATUS", map)
       } catch (e: Exception) {
-        Log.e("OmikitPlugin", "❌ Error sending AUTO_UNREGISTER_STATUS event: ${e.message}", e)
+        Log.e("OmikitPlugin", "Error sending AUTO_UNREGISTER_STATUS event: ${e.message}", e)
       }
     }
-    
-    // ✅ Implement các method khác của OmiListener (delegate to main listener)
-    override fun incomingReceived(callerId: Int?, phoneNumber: String?, isVideo: Boolean?) {
-      this@OmikitPluginModule.incomingReceived(callerId, phoneNumber, isVideo)
-    }
-    
-    override fun onCallEstablished(callerId: Int, phoneNumber: String?, isVideo: Boolean?, startTime: Long, transactionId: String?) {
-      this@OmikitPluginModule.onCallEstablished(callerId, phoneNumber, isVideo, startTime, transactionId)
-    }
-    
-    override fun onCallEnd(callInfo: MutableMap<String, Any?>, statusCode: Int) {
-      this@OmikitPluginModule.onCallEnd(callInfo, statusCode)
-    }
-    
-    override fun onConnecting() {
-      this@OmikitPluginModule.onConnecting()
-    }
-    
-    override fun onDescriptionError() {
-      this@OmikitPluginModule.onDescriptionError()
-    }
-    
-    override fun onFcmReceived(uuid: String, userName: String, avatar: String) {
-      this@OmikitPluginModule.onFcmReceived(uuid, userName, avatar)
-    }
-    
-    override fun onRinging(callerId: Int, transactionId: String?) {
-      this@OmikitPluginModule.onRinging(callerId, transactionId)
-    }
-    
-    override fun networkHealth(stat: Map<String, *>, quality: Int) {
-      this@OmikitPluginModule.networkHealth(stat, quality)
-    }
-    
-    override fun onAudioChanged(audioInfo: Map<String, Any>) {
-      this@OmikitPluginModule.onAudioChanged(audioInfo)
-    }
-    
-    override fun onHold(isHold: Boolean) {
-      this@OmikitPluginModule.onHold(isHold)
-    }
-    
-    override fun onMuted(isMuted: Boolean) {
-      this@OmikitPluginModule.onMuted(isMuted)
-    }
-    
-    override fun onOutgoingStarted(callerId: Int, phoneNumber: String?, isVideo: Boolean?) {
-      this@OmikitPluginModule.onOutgoingStarted(callerId, phoneNumber, isVideo)
-    }
-    
-    override fun onSwitchBoardAnswer(sip: String) {
-      this@OmikitPluginModule.onSwitchBoardAnswer(sip)
-    }
-    
-    override fun onRegisterCompleted(statusCode: Int) {
-      this@OmikitPluginModule.onRegisterCompleted(statusCode)
-    }
-    
-    override fun onRequestPermission(permissions: Array<String>) {
-      this@OmikitPluginModule.onRequestPermission(permissions)
-    }
-    
-    override fun onVideoSize(width: Int, height: Int) {
-      this@OmikitPluginModule.onVideoSize(width, height)
-    }
+
+    // NO-OP: main module listener handles these - avoid double-firing
+    override fun incomingReceived(callerId: Int?, phoneNumber: String?, isVideo: Boolean?) {}
+    override fun onCallEstablished(callerId: Int, phoneNumber: String?, isVideo: Boolean?, startTime: Long, transactionId: String?) {}
+    override fun onCallEnd(callInfo: MutableMap<String, Any?>, statusCode: Int) {}
+    override fun onConnecting() {}
+    override fun onDescriptionError() {}
+    override fun onFcmReceived(uuid: String, userName: String, avatar: String) {}
+    override fun onRinging(callerId: Int, transactionId: String?) {}
+    override fun networkHealth(stat: Map<String, *>, quality: Int) {}
+    override fun onAudioChanged(audioInfo: Map<String, Any>) {}
+    override fun onHold(isHold: Boolean) {}
+    override fun onMuted(isMuted: Boolean) {}
+    override fun onOutgoingStarted(callerId: Int, phoneNumber: String?, isVideo: Boolean?) {}
+    override fun onSwitchBoardAnswer(sip: String) {}
+    override fun onRegisterCompleted(statusCode: Int) {}
+    override fun onRequestPermission(permissions: Array<String>) {}
+    override fun onVideoSize(width: Int, height: Int) {}
   }
 
   // ✅ Helper function để hide notification một cách an toàn
   @ReactMethod
   fun hideSystemNotificationSafely(promise: Promise) {
     try {
-      // ✅ Delay 2 giây để đảm bảo registration hoàn tất
-      Handler(Looper.getMainLooper()).postDelayed({
+      val context = reactApplicationContext ?: run {
+        promise.resolve(false)
+        return
+      }
+      // Delay to ensure registration completes before hiding
+      mainScope.launch {
         try {
-          // ✅ Gọi function hide notification với error handling
-          OmiClient.getInstance(reactApplicationContext!!).hideSystemNotificationAndUnregister("Registration check completed")
-          Log.d("OmikitPlugin", "✅ Successfully hidden system notification and unregistered")
+          delay(2000)
+          OmiClient.getInstance(context).hideSystemNotificationAndUnregister("Registration check completed")
           promise.resolve(true)
         } catch (e: Exception) {
-          Log.e("OmikitPlugin", "❌ Failed to hide system notification: ${e.message}", e)
           promise.resolve(false)
         }
-      }, 2000) // Delay 2 giây
+      }
     } catch (e: Exception) {
-      Log.e("OmikitPlugin", "❌ Error in hideSystemNotificationSafely: ${e.message}", e)
       promise.resolve(false)
     }
   }
@@ -1876,10 +1862,8 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
   fun hideSystemNotificationOnly(promise: Promise) {
     try {
       OmiClient.getInstance(reactApplicationContext!!).hideSystemNotification()
-      Log.d("OmikitPlugin", "✅ Successfully hidden system notification (keeping registration)")
       promise.resolve(true)
     } catch (e: Exception) {
-      Log.e("OmikitPlugin", "❌ Failed to hide system notification only: ${e.message}", e)
       promise.resolve(false)
     }
   }
@@ -1889,10 +1873,8 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
   fun hideSystemNotificationAndUnregister(reason: String, promise: Promise) {
     try {
       OmiClient.getInstance(reactApplicationContext!!).hideSystemNotificationAndUnregister(reason)
-      Log.d("OmikitPlugin", "✅ Successfully hidden notification and unregistered: $reason")
       promise.resolve(true)
     } catch (e: Exception) {
-      Log.e("OmikitPlugin", "❌ Failed to hide notification and unregister: ${e.message}", e)
       promise.resolve(false)
     }
   }
@@ -1904,21 +1886,18 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
       val userName = data.getString("userName")
       val password = data.getString("password")
       val realm = data.getString("realm")
-      val host = data.getString("host") ?: "vh.omicrm.com"
+      val host = data.getString("host").let { if (it.isNullOrEmpty()) "vh.omicrm.com" else it }
       val firebaseToken = data.getString("fcmToken")
       val projectId = data.getString("projectId") ?: ""
 
       // Validate required parameters
       if (userName.isNullOrEmpty() || password.isNullOrEmpty() || realm.isNullOrEmpty() || firebaseToken.isNullOrEmpty()) {
-        Log.e("OmikitPlugin", "❌ Missing required parameters for credential check")
         promise.resolve(mapOf("success" to false, "message" to "Missing required parameters"))
         return@launch
       }
 
       withContext(Dispatchers.Default) {
         try {
-          Log.d("OmikitPlugin", "🔍 Checking credentials for user: $userName")
-          
           OmiClient.getInstance(reactApplicationContext!!).checkCredentials(
             userName = userName ?: "",
             password = password ?: "",
@@ -1927,8 +1906,6 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
             host = host,
             projectId = projectId
           ) { success, statusCode, message ->
-            Log.d("OmikitPlugin", "🔍 Credential check callback - success: $success, status: $statusCode, message: $message")
-            
             val result = mapOf(
               "success" to success,
               "statusCode" to statusCode,
@@ -1939,7 +1916,6 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
           }
           
         } catch (e: Exception) {
-          Log.e("OmikitPlugin", "❌ Error during credential check: ${e.message}", e)
           val errorResult = mapOf(
             "success" to false,
             "message" to e.message
@@ -1957,24 +1933,21 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
       val userName = data.getString("userName")
       val password = data.getString("password")
       val realm = data.getString("realm")
-      val host = data.getString("host") ?: "vh.omicrm.com"
-      val isVideo = data.getBoolean("isVideo")
+      val host = data.getString("host").let { if (it.isNullOrEmpty()) "vh.omicrm.com" else it }
+      val isVideo = if (data.hasKey("isVideo")) data.getBoolean("isVideo") else false
       val firebaseToken = data.getString("fcmToken")
       val projectId = data.getString("projectId") ?: ""
-      val showNotification = data.getBoolean("showNotification") ?: true
-      val enableAutoUnregister = data.getBoolean("enableAutoUnregister") ?: true
+      val showNotification = if (data.hasKey("showNotification")) data.getBoolean("showNotification") else true
+      val enableAutoUnregister = if (data.hasKey("enableAutoUnregister")) data.getBoolean("enableAutoUnregister") else true
 
       // Validate required parameters
       if (userName.isNullOrEmpty() || password.isNullOrEmpty() || realm.isNullOrEmpty() || firebaseToken.isNullOrEmpty()) {
-        Log.e("OmikitPlugin", "❌ Missing required parameters for registration with options")
         promise.resolve(mapOf("success" to false, "message" to "Missing required parameters"))
         return@launch
       }
 
       withContext(Dispatchers.Default) {
         try {
-          Log.d("OmikitPlugin", "⚙️ Registering with options for user: $userName - showNotification: $showNotification, enableAutoUnregister: $enableAutoUnregister")
-          
           OmiClient.getInstance(reactApplicationContext!!).registerWithOptions(
             userName = userName ?: "",
             password = password ?: "",
@@ -1986,8 +1959,6 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
             showNotification = showNotification,
             enableAutoUnregister = enableAutoUnregister
           ) { success, statusCode, message ->
-            Log.d("OmikitPlugin", "⚙️ Registration with options callback - success: $success, status: $statusCode, message: $message")
-            
             val result = mapOf(
               "success" to success,
               "statusCode" to statusCode,
@@ -1998,7 +1969,6 @@ class OmikitPluginModule(reactContext: ReactApplicationContext?) :
           }
           
         } catch (e: Exception) {
-          Log.e("OmikitPlugin", "❌ Error during registration with options: ${e.message}", e)
           val errorResult = mapOf(
             "success" to false,
             "message" to e.message