rns-nativecall 1.0.7 → 1.0.9

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

@@ -2,20 +2,25 @@ package com.rnsnativecall
 
 import android.app.Activity
 import android.content.Intent
+import android.os.Build
 import android.os.Bundle
 import android.view.WindowManager
-import android.os.Build
 
 class AcceptCallActivity : Activity() {
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
-
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O_MR1) {
+            setShowWhenLocked(true)
+            setTurnScreenOn(true)
+        }
         val launchIntent = packageManager.getLaunchIntentForPackage(packageName)
         if (launchIntent != null) {
             launchIntent.apply {
-                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or 
-                         Intent.FLAG_ACTIVITY_SINGLE_TOP or 
-                         Intent.FLAG_ACTIVITY_REORDER_TO_FRONT)
+                addFlags(
+                    Intent.FLAG_ACTIVITY_NEW_TASK or
+                        Intent.FLAG_ACTIVITY_SINGLE_TOP or
+                        Intent.FLAG_ACTIVITY_REORDER_TO_FRONT,
+                )
                 putExtras(intent.extras ?: Bundle())
                 putExtra("navigatingToCall", true)
             }
@@ -25,4 +30,4 @@ class AcceptCallActivity : Activity() {
         finish()
         overridePendingTransition(0, 0)
     }
-}
+}

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

@@ -1,8 +1,6 @@
 package com.rnsnativecall
 
 import android.app.*
-import android.app.Service
-import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
 import android.content.IntentFilter
@@ -13,33 +11,22 @@ import android.os.Handler
 import android.os.IBinder
 import android.os.Looper
 import androidx.core.app.NotificationCompat
-import androidx.core.content.ContextCompat
 import com.facebook.react.HeadlessJsTaskService
 
 class CallForegroundService : Service() {
-    private var unlockReceiver: UnlockReceiver? = null // Store reference for unregistering
+    private var unlockReceiver: UnlockReceiver? = null
 
     companion object {
-        private const val CHANNEL_ID = "CALL_WAKE_SILENT"
-
         fun stop(context: Context) {
-            val intent = Intent(context, CallForegroundService::class.java)
-            context.stopService(intent)
+            context.stopService(Intent(context, CallForegroundService::class.java))
         }
     }
 
     override fun onCreate() {
         super.onCreate()
-
-        // --- DYNAMIC REGISTRATION FIX ---
-        // Registering here makes the system allow the USER_PRESENT broadcast
-        // because the app is already in the Foreground (via this service).
         unlockReceiver = UnlockReceiver()
         val filter = IntentFilter(Intent.ACTION_USER_PRESENT)
-
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-            // Prefer NOT_EXPORTED for dynamically-registered receivers to avoid
-            // background delivery issues and to restrict broadcasts to our process.
             registerReceiver(unlockReceiver, filter, Context.RECEIVER_NOT_EXPORTED)
         } else {
             registerReceiver(unlockReceiver, filter)
@@ -52,43 +39,10 @@ class CallForegroundService : Service() {
         startId: Int,
     ): Int {
         val data = intent?.extras
-        val name = data?.getString("name") ?: "Someone"
-        val uuid = data?.getString("callUuid") ?: "default_uuid"
-
-        val notificationId = uuid.hashCode()
-
-        createNotificationChannel()
-
-        val notification =
-            NotificationCompat
-                .Builder(this, CHANNEL_ID)
-                .setContentTitle(name)
-                .setContentText("Connecting...")
-                .setSmallIcon(applicationInfo.icon)
-                .setPriority(NotificationCompat.PRIORITY_LOW)
-                .setCategory(NotificationCompat.CATEGORY_SERVICE)
-                .setOngoing(true)
-                .build()
-
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-            startForeground(
-                notificationId,
-                notification,
-                ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC,
-            )
-        } else {
-            startForeground(notificationId, notification)
-        }
-
-        // Launch the Headless Task
         val headlessIntent =
             Intent(this, CallHeadlessTask::class.java).apply {
                 val bundle = Bundle()
-                data?.let { b ->
-                    for (key in b.keySet()) {
-                        bundle.putString(key, b.get(key)?.toString())
-                    }
-                }
+                data?.let { b -> for (key in b.keySet()) bundle.putString(key, b.get(key)?.toString()) }
                 putExtras(bundle)
             }
 
@@ -99,52 +53,18 @@ class CallForegroundService : Service() {
             e.printStackTrace()
         }
 
-        // / Auto - stop after 30 s
-        Handler(Looper.getMainLooper()).postDelayed({
-            try {
-                stopSelf()
-            } catch (e: Exception) {
-            }
-        }, 30000)
-
+        Handler(Looper.getMainLooper()).postDelayed({ stopSelf() }, 30000)
         return START_NOT_STICKY
     }
 
     override fun onDestroy() {
-        // --- CLEANUP ---
-        // Unregister to prevent memory leaks once the call ends or service stops
         try {
             unlockReceiver?.let { unregisterReceiver(it) }
         } catch (e: Exception) {
-            e.printStackTrace()
-        }
-
-        try {
-            stopForeground(true)
-        } catch (_: Exception) {
         }
         super.onDestroy()
     }
 
-    private fun createNotificationChannel() {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            val channel =
-                NotificationChannel(
-                    CHANNEL_ID,
-                    "Call Service",
-                    NotificationManager.IMPORTANCE_LOW,
-                ).apply {
-                    description = "Incoming call connection state"
-                    setSound(null, null)
-                    enableVibration(false)
-                    setBypassDnd(false)
-                    lockscreenVisibility = NotificationCompat.VISIBILITY_PUBLIC
-                }
-            val manager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-            manager.createNotificationChannel(channel)
-        }
-    }
-
     override fun onBind(intent: Intent?): IBinder? = null
 }
 
@@ -154,36 +74,19 @@ class CallUiForegroundService : Service() {
         flags: Int,
         startId: Int,
     ): Int {
-        val notification =
-            NativeCallManager.pendingCallNotification
-                ?: run {
-                    stopSelf()
-                    return START_NOT_STICKY
-                }
+        val notification = NativeCallManager.pendingCallNotification ?: return START_NOT_STICKY
+        val id = NativeCallManager.pendingNotificationId ?: return START_NOT_STICKY
 
-        val notificationId =
-            NativeCallManager.pendingNotificationId
-                ?: run {
-                    stopSelf()
-                    return START_NOT_STICKY
-                }
-
-        // Inside CallUiForegroundService.onStartCommand
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-            startForeground(
-                notificationId,
-                notification,
-                ServiceInfo.FOREGROUND_SERVICE_TYPE_PHONE_CALL,
-            )
+            startForeground(id, notification, ServiceInfo.FOREGROUND_SERVICE_TYPE_PHONE_CALL)
         } else {
-            startForeground(notificationId, notification)
+            startForeground(id, notification)
         }
-
         return START_NOT_STICKY
     }
 
     override fun onDestroy() {
-        stopForeground(true)
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) stopForeground(STOP_FOREGROUND_REMOVE)
         super.onDestroy()
     }
 

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)
 
@@ -57,10 +56,10 @@ class CallMessagingService : FirebaseMessagingService() {
             // Foreground → send event directly
             CallModule.sendEventToJS("onCallReceived", data)
         } else {
-            // Background → start foreground service (which in turn starts headless)
+            // Background → start the SILENT wake service
             val serviceIntent =
                 Intent(context, CallForegroundService::class.java).apply {
-                    putExtra("callUuid", uuid) // Key: Pass the UUID here
+                    putExtra("callUuid", uuid)
                     putExtras(
                         Bundle().apply {
                             data.forEach { (k, v) -> putString(k, v) }
@@ -68,11 +67,9 @@ class CallMessagingService : FirebaseMessagingService() {
                     )
                 }
 
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-                context.startForegroundService(serviceIntent)
-            } else {
-                context.startService(serviceIntent)
-            }
+            // FIX: Always use startService here now.
+            // We are no longer making this a "Foreground Service" at the wake stage.
+            context.startService(serviceIntent)
         }
     }
 

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/NativeCallManager.kt

@@ -1,17 +1,12 @@
 package com.rnsnativecall
 
-import android.app.Notification
-import android.app.NotificationChannel
-import android.app.NotificationManager
-import android.app.PendingIntent
+import android.app.*
 import android.content.Context
 import android.content.Intent
-import android.content.pm.ServiceInfo
 import android.graphics.Color
 import android.media.AudioAttributes
 import android.media.RingtoneManager
 import android.os.Build
-import android.os.Bundle
 import android.os.Handler
 import android.os.Looper
 import androidx.core.app.NotificationCompat
@@ -22,13 +17,10 @@ object NativeCallManager {
     const val channelId = "CALL_CHANNEL_V15_URGENT"
     private var currentCallData: Map<String, String>? = null
 
-    // Change these to internal so the Service can access them
-    @JvmStatic internal var pendingCallNotification: android.app.Notification? = null
+    @JvmStatic internal var pendingCallNotification: Notification? = null
 
     @JvmStatic internal var pendingNotificationId: Int? = null
 
-    fun getCurrentCallData(): Map<String, String>? = currentCallData
-
     fun handleIncomingPush(
         context: Context,
         data: Map<String, String>,
@@ -36,7 +28,6 @@ object NativeCallManager {
         Handler(Looper.getMainLooper()).post {
             val uuid = data["callUuid"] ?: return@post
             this.currentCallData = data
-
             val name = data["name"] ?: "Incoming Call"
             val notificationId = uuid.hashCode()
             val ringtoneUri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE)
@@ -48,15 +39,7 @@ object NativeCallManager {
                     PendingIntent.FLAG_UPDATE_CURRENT
                 }
 
-            // 1. Content Intent (Tap notification)
-            val noOpIntent =
-                Intent("com.rnsnativecall.ACTION_NOTIFICATION_TAP_NOOP").apply {
-                    `package` = context.packageName
-                    putExtra("EXTRA_CALL_UUID", uuid)
-                }
-            val contentIntent = PendingIntent.getBroadcast(context, notificationId + 3, noOpIntent, pendingFlags)
-
-            // 2. Full Screen Intent (Wake lockscreen)
+            // Intents
             val overlayIntent =
                 Intent(context, NotificationOverlayActivity::class.java).apply {
                     putExtra("EXTRA_CALL_UUID", uuid)
@@ -65,7 +48,6 @@ object NativeCallManager {
                 }
             val fullScreenPendingIntent = PendingIntent.getActivity(context, notificationId, overlayIntent, pendingFlags)
 
-            // 3. Answer Action
             val answerIntent =
                 Intent(context, CallActionReceiver::class.java).apply {
                     action = "ACTION_ANSWER"
@@ -74,7 +56,6 @@ object NativeCallManager {
                 }
             val answerPendingIntent = PendingIntent.getBroadcast(context, notificationId + 1, answerIntent, pendingFlags)
 
-            // 4. Reject Action
             val rejectIntent =
                 Intent(context, CallActionReceiver::class.java).apply {
                     action = "ACTION_REJECT"
@@ -83,24 +64,25 @@ object NativeCallManager {
                 }
             val rejectPendingIntent = PendingIntent.getBroadcast(context, notificationId + 2, rejectIntent, pendingFlags)
 
-            // Setup Channel with System-Managed Sound
+            // Channel
             val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-
-            val channel =
-                NotificationChannel(channelId, "Incoming Calls", NotificationManager.IMPORTANCE_HIGH).apply {
-                    lockscreenVisibility = NotificationCompat.VISIBILITY_PUBLIC
-                    enableVibration(true)
-                    setBypassDnd(true)
-                    setSound(
-                        ringtoneUri,
-                        AudioAttributes
-                            .Builder()
-                            .setUsage(AudioAttributes.USAGE_NOTIFICATION_RINGTONE)
-                            .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
-                            .build(),
-                    )
-                }
-            notificationManager.createNotificationChannel(channel)
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                val channel =
+                    NotificationChannel(channelId, "Incoming Calls", NotificationManager.IMPORTANCE_HIGH).apply {
+                        lockscreenVisibility = Notification.VISIBILITY_PUBLIC
+                        enableVibration(true)
+                        setBypassDnd(true)
+                        setSound(
+                            ringtoneUri,
+                            AudioAttributes
+                                .Builder()
+                                .setUsage(AudioAttributes.USAGE_NOTIFICATION_RINGTONE)
+                                .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
+                                .build(),
+                        )
+                    }
+                notificationManager.createNotificationChannel(channel)
+            }
 
             val caller =
                 Person
@@ -116,31 +98,19 @@ object NativeCallManager {
                     .setPriority(NotificationCompat.PRIORITY_MAX)
                     .setCategory(NotificationCompat.CATEGORY_CALL)
                     .setOngoing(true)
-                    .setAutoCancel(false)
-                    .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
-                    .setWhen(0)
-                    .setUsesChronometer(false)
-                    .setContentIntent(contentIntent)
                     .setFullScreenIntent(fullScreenPendingIntent, true)
-                    .setStyle(
-                        NotificationCompat.CallStyle
-                            .forIncomingCall(caller, rejectPendingIntent, answerPendingIntent)
-                            .setAnswerButtonColorHint(Color.GREEN)
-                            .setDeclineButtonColorHint(Color.RED),
-                    ).setForegroundServiceBehavior(NotificationCompat.FOREGROUND_SERVICE_IMMEDIATE)
+                    .setStyle(NotificationCompat.CallStyle.forIncomingCall(caller, rejectPendingIntent, answerPendingIntent))
+                    .setForegroundServiceBehavior(NotificationCompat.FOREGROUND_SERVICE_IMMEDIATE)
 
             val notification = builder.build()
             pendingCallNotification = notification
             pendingNotificationId = notificationId
 
-            // Relay to UI Service
+            // 1. Start the LOUD UI Service (Google allows this for PHONE_CALL)
             val uiIntent = Intent(context, CallUiForegroundService::class.java)
             ContextCompat.startForegroundService(context, uiIntent)
 
-            // Manual notify ensures the banner pops immediately
-            val manager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-            manager.notify(notificationId, notification)
-
+            // 2. Stop the SILENT Wake service (which no longer needs DATA_SYNC)
             CallForegroundService.stop(context)
         }
     }
@@ -151,55 +121,8 @@ object NativeCallManager {
     ) {
         pendingCallNotification = null
         pendingNotificationId = null
-
-        val notificationManager =
-            context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-
-        uuid?.let { notificationManager.cancel(it.hashCode()) }
-
+        val manager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        uuid?.let { manager.cancel(it.hashCode()) }
         context.stopService(Intent(context, CallUiForegroundService::class.java))
     }
-
-    fun connecting(
-        context: Context,
-        uuid: String,
-        name: String,
-        callType: String,
-    ) {
-        val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-        val builder =
-            NotificationCompat
-                .Builder(context, channelId)
-                .setSmallIcon(context.applicationInfo.icon)
-                .setContentTitle(name)
-                .setContentText("Connecting…")
-                .setPriority(NotificationCompat.PRIORITY_MAX)
-                .setCategory(NotificationCompat.CATEGORY_CALL)
-                .setOngoing(true)
-                .setStyle(NotificationCompat.BigTextStyle().bigText("Connecting…"))
-        notificationManager.notify(uuid.hashCode(), builder.build())
-    }
-
-    fun aborting(
-        context: Context,
-        uuid: String,
-        name: String,
-        callType: String,
-    ) {
-        val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-        val builder =
-            NotificationCompat
-                .Builder(context, channelId)
-                .setSmallIcon(context.applicationInfo.icon)
-                .setContentTitle(name)
-                .setContentText("Aborting…")
-                .setPriority(NotificationCompat.PRIORITY_MAX)
-                .setCategory(NotificationCompat.CATEGORY_CALL)
-                .setOngoing(true)
-        notificationManager.notify(uuid.hashCode(), builder.build())
-    }
-
-    fun stopRingtone() {
-        // No-op: Sound is now managed by the Notification Channel life-cycle
-    }
 }

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.7",
+    "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",

package/withNativeCallVoip.js

@@ -86,10 +86,9 @@ function withAndroidConfig(config) {
         const permissions = [
             'android.permission.VIBRATE',
             'android.permission.FOREGROUND_SERVICE',
-            'android.permission.FOREGROUND_SERVICE_PHONE_CALL', // ADDED THIS
-            'android.permission.FOREGROUND_SERVICE_DATA_SYNC', // ADDED THIS
-            'android.permission.USE_FULL_SCREEN_INTENT', // ADDED THIS
-            'android.permission.MANAGE_ONGOING_CALLS', // ADDED THIS
+            'android.permission.FOREGROUND_SERVICE_PHONE_CALL',
+            'android.permission.USE_FULL_SCREEN_INTENT',
+            'android.permission.MANAGE_ONGOING_CALLS',
             'android.permission.POST_NOTIFICATIONS',
             'android.permission.WAKE_LOCK',
             'android.permission.DISABLE_KEYGUARD',
@@ -108,7 +107,7 @@ function withAndroidConfig(config) {
 
         const services = [
             { name: 'com.rnsnativecall.CallMessagingService', exported: 'false', filter: 'com.google.firebase.MESSAGING_EVENT' },
-            { name: 'com.rnsnativecall.CallForegroundService', type: 'dataSync' },
+            { name: 'com.rnsnativecall.CallForegroundService' },
             { name: 'com.rnsnativecall.CallUiForegroundService', type: 'phoneCall' },
             { name: 'com.rnsnativecall.CallHeadlessTask' }
         ];