rns-nativecall 1.0.8 → 1.0.9

package/android/src/main/java/com/rnsnativecall/CallMessagingService.kt

@@ -24,7 +24,6 @@ class CallMessagingService : FirebaseMessagingService() {
         val type = data["type"] ?: ""
 
         if (type == "CANCEL") {
-            NativeCallManager.stopRingtone()
             // Pass context here to persist the cancellation
             CallState.markCanceled(uuid, context)
 

package/android/src/main/java/com/rnsnativecall/CallModule.kt

@@ -2,16 +2,17 @@ package com.rnsnativecall
 
 import android.app.NotificationManager
 import android.content.Context
-import com.facebook.react.bridge.*
-import com.facebook.react.modules.core.DeviceEventManagerModule
 import android.content.Intent
+import android.net.Uri
 import android.os.Build
 import android.provider.Settings
-import android.net.Uri
-
-class CallModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
 
-    init { 
+class CallModule(
+    reactContext: ReactApplicationContext,
+) : ReactContextBaseJavaModule(reactContext) {
+    init {
         instance = this
         notifyReady()
     }
@@ -40,20 +41,26 @@ class CallModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
     }
 
     @ReactMethod
-    fun displayIncomingCall(uuid: String, name: String, callType: String, promise: Promise) {
+    fun displayIncomingCall(
+        uuid: String,
+        name: String,
+        callType: String,
+        promise: Promise,
+    ) {
         try {
-            val data = mapOf(
-                "callUuid" to uuid,
-                "name" to name,
-                "callType" to callType
-            )
+            val data =
+                mapOf(
+                    "callUuid" to uuid,
+                    "name" to name,
+                    "callType" to callType,
+                )
             NativeCallManager.handleIncomingPush(reactApplicationContext, data)
             promise.resolve(true)
         } catch (e: Exception) {
             promise.reject("CALL_ERROR", e.message)
         }
     }
-    
+
     // Inside your CallModule class
     @ReactMethod
     fun checkOverlayPermission(promise: Promise) {
@@ -64,34 +71,39 @@ class CallModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
         }
     }
 
-     @ReactMethod
-     fun requestOverlayPermission() {
-         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-             if (!Settings.canDrawOverlays(reactApplicationContext)) {
-                 val intent = Intent(
-                     Settings.ACTION_MANAGE_OVERLAY_PERMISSION,
-                     Uri.parse("package:${reactApplicationContext.packageName}")
-                 )
-                 intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-                 reactApplicationContext.startActivity(intent)
-          }
-         }
-     }
+    @ReactMethod
+    fun requestOverlayPermission() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            if (!Settings.canDrawOverlays(reactApplicationContext)) {
+                val intent =
+                    Intent(
+                        Settings.ACTION_MANAGE_OVERLAY_PERMISSION,
+                        Uri.parse("package:${reactApplicationContext.packageName}"),
+                    )
+                intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                reactApplicationContext.startActivity(intent)
+            }
+        }
+    }
 
     /**
-     * Combined Validity Check: 
+     * Combined Validity Check:
      * Used by Headless Task to see if it should proceed with the UI.
      */
     @ReactMethod
-    fun checkCallValidity(uuid: String, promise: Promise) {
-       // Pass context so it can check the persistent disk storage
-       val isValid = CallState.shouldProceed(uuid, reactApplicationContext)
-       val isCanceled = CallState.isCanceled(uuid, reactApplicationContext)
-    
-       val map = Arguments.createMap().apply {
-           putBoolean("isValid", isValid)
-           putBoolean("isCanceled", isCanceled)
-       }
+    fun checkCallValidity(
+        uuid: String,
+        promise: Promise,
+    ) {
+        // Pass context so it can check the persistent disk storage
+        val isValid = CallState.shouldProceed(uuid, reactApplicationContext)
+        val isCanceled = CallState.isCanceled(uuid, reactApplicationContext)
+
+        val map =
+            Arguments.createMap().apply {
+                putBoolean("isValid", isValid)
+                putBoolean("isCanceled", isCanceled)
+            }
         promise.resolve(map)
     }
 
@@ -112,29 +124,34 @@ class CallModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
      * Useful for checking if the UI is still relevant.
      */
     @ReactMethod
-    fun checkCallStatus(uuid: String, promise: Promise) {
+    fun checkCallStatus(
+        uuid: String,
+        promise: Promise,
+    ) {
         val isCanceled = CallState.isCanceled(uuid)
         val isCurrent = CallState.getCurrent() == uuid
-        
-        val map = Arguments.createMap().apply {
-            putBoolean("isCanceled", isCanceled)
-            putBoolean("isActive", isCurrent)
-            putBoolean("shouldDisplay", isCurrent && !isCanceled)
-        }
+
+        val map =
+            Arguments.createMap().apply {
+                putBoolean("isCanceled", isCanceled)
+                putBoolean("isActive", isCurrent)
+                putBoolean("shouldDisplay", isCurrent && !isCanceled)
+            }
         promise.resolve(map)
     }
 
     @ReactMethod
     fun endNativeCall(uuid: String) {
-        NativeCallManager.stopRingtone()
+        NativeCallManager.dismissIncomingCall(this, uuid)
         CallState.clear(uuid)
         pendingCallDataMap = null
-        
+
         val notificationManager = reactApplicationContext.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
         notificationManager.cancel(101)
     }
 
     @ReactMethod fun addListener(eventName: String) {}
+
     @ReactMethod fun removeListeners(count: Int) {}
 
     companion object {
@@ -149,14 +166,17 @@ class CallModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
             return reactContext != null && reactContext.hasActiveCatalystInstance()
         }
 
-        @JvmStatic 
+        @JvmStatic
         fun setPendingCallData(data: Map<String, String>) {
-             pendingCallDataMap = data 
+            pendingCallDataMap = data
         }
 
-        @JvmStatic 
-        fun setPendingCallData(eventName: String, data: Map<String, String>) {
-             pendingEvents[eventName] = data 
+        @JvmStatic
+        fun setPendingCallData(
+            eventName: String,
+            data: Map<String, String>,
+        ) {
+            pendingEvents[eventName] = data
         }
 
         @JvmStatic
@@ -174,23 +194,33 @@ class CallModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
         }
 
         @JvmStatic
-        fun setPendingEvent(eventName: String, data: Map<String, String>) {
+        fun setPendingEvent(
+            eventName: String,
+            data: Map<String, String>,
+        ) {
             pendingEvents[eventName] = data
         }
 
         @JvmStatic
-        fun sendEventToJS(eventName: String, params: Any?) {
+        fun sendEventToJS(
+            eventName: String,
+            params: Any?,
+        ) {
             val reactContext = instance?.reactApplicationContext
-            val bridgeData = when (params) {
-                is Map<*, *> -> {
-                    val map = Arguments.createMap()
-                    params.forEach { (key, value) ->
-                        map.putString(key.toString(), value.toString())
+            val bridgeData =
+                when (params) {
+                    is Map<*, *> -> {
+                        val map = Arguments.createMap()
+                        params.forEach { (key, value) ->
+                            map.putString(key.toString(), value.toString())
+                        }
+                        map
+                    }
+
+                    else -> {
+                        null
                     }
-                    map
                 }
-                else -> null
-            }
 
             if (isReady()) {
                 reactContext
@@ -202,4 +232,4 @@ class CallModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
             }
         }
     }
-}
+}

package/android/src/main/java/com/rnsnativecall/UnlockReceiver.kt

@@ -5,18 +5,20 @@ import android.content.Context
 import android.content.Intent
 
 class UnlockReceiver : BroadcastReceiver() {
-    override fun onReceive(context: Context, intent: Intent) {
+    override fun onReceive(
+        context: Context,
+        intent: Intent,
+    ) {
         android.util.Log.d("UnlockReceiver", "Device Unlocked! Action: ${intent.action}")
-        
+
         if (intent.action == Intent.ACTION_USER_PRESENT) {
-            val activeData = NativeCallManager.getCurrentCallData()
-            
-            if (activeData != null) {
-                android.util.Log.d("UnlockReceiver", "Re-triggering call for: ${activeData["name"]}")
-                NativeCallManager.handleIncomingPush(context, activeData)
-            } else {
-                android.util.Log.d("UnlockReceiver", "No active call data found to re-trigger.")
-            }
+            // val activeData = NativeCallManager.getCurrentCallData()
+
+            // if (activeData != null) {
+            //     NativeCallManager.handleIncomingPush(context, activeData)
+            // } else {
+            //     android.util.Log.d("UnlockReceiver", "No active call data found to re-trigger.")
+            // }
         }
     }
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "rns-nativecall",
-    "version": "1.0.8",
+    "version": "1.0.9",
     "description": "High-performance React Native module for handling native VoIP call UI on Android and iOS.",
     "main": "index.js",
     "types": "index.d.ts",