rns-nativecall 0.6.2 → 0.6.4

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

@@ -1,135 +1,139 @@
 package com.rnsnativecall
 
 import android.app.ActivityManager
-import android.content.Context
-import android.content.Intent
-import android.os.Bundle
-import android.os.Handler
-import android.os.Looper
 import android.app.NotificationManager
 import android.app.NotificationChannel
 import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
 import android.os.Build
-import android.util.Log
+import android.os.Bundle
 import androidx.core.app.NotificationCompat
 import androidx.core.content.ContextCompat
 import com.google.firebase.messaging.FirebaseMessagingService
 import com.google.firebase.messaging.RemoteMessage
 import com.facebook.react.HeadlessJsTaskService
 
-class CallMessagingService : FirebaseMessagingService() {
-
-    companion object {
-        private val handler = Handler(Looper.getMainLooper())
-        private val pendingNotifications = mutableMapOf<String, Runnable>()
+import com.rnsnativecall.CallState
 
-        @JvmStatic
-        fun stopBackupTimer(uuid: String) {
-            pendingNotifications[uuid]?.let {
-                Log.d("CallMessagingService", "Stopping backup timer for UUID: $uuid")
-                handler.removeCallbacks(it)
-                pendingNotifications.remove(uuid)
-            }
-        }
-    }
-
-    private fun isAppInForeground(context: Context): Boolean {
-        val activityManager = context.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
-        val appProcesses = activityManager.runningAppProcesses ?: return false
-        return appProcesses.any { 
-            it.importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND && it.processName == context.packageName 
-        }
-    }
+class CallMessagingService : FirebaseMessagingService() {
 
     override fun onMessageReceived(remoteMessage: RemoteMessage) {
         val data = remoteMessage.data
         val context = applicationContext
+
         val uuid = data["callUuid"] ?: return
         val type = data["type"] ?: ""
-
+          
         if (type == "CANCEL") {
-            stopBackupTimer(uuid)
-            // Stop Headless service if it was running for this call
-            val stopHeadlessIntent = Intent(context, CallHeadlessTask::class.java)
-            context.stopService(stopHeadlessIntent)
-            
-            NativeCallManager.dismissIncomingCall(context, uuid)
+            NativeCallManager.stopRingtone()
+            CallState.markCanceled(uuid)
+            // Gate future headless runs for this UUID 
+            if (CallState.getCurrent() == uuid) {
+                CallState.clear(uuid) 
+            }
             showMissedCallNotification(context, data, uuid)
             return
         }
-        
+
+        // Inside onMessageReceived
+if (!CallState.setCurrent(uuid)) {
+    // We are busy! Start a SILENT headless task to send the WebSocket busy msg
+    val busyIntent = Intent(context, CallHeadlessTask::class.java).apply {
+        putExtras(Bundle().apply { 
+            data.forEach { (k, v) -> putString(k, v) }
+            putBoolean("isBusySignal", true) 
+        })
+    }
+    context.startService(busyIntent)
+    return 
+}
+
         if (isAppInForeground(context)) {
+            // Foreground → send event directly
             CallModule.sendEventToJS("onCallReceived", data)
         } else {
-       
-            // 2. Start Headless Task
+            // Show incoming call notification instantly 
+            //NativeCallManager.handleIncomingPush(context, data) /// i will use headless instead
+            // Background → start foreground service + headless task
+            // val serviceIntent = Intent(context, CallForegroundService::class.java).apply {
+            //     putExtras(Bundle().apply { data.forEach { (k, v) -> putString(k, v) } })
+            // }
+            // ContextCompat.startForegroundService(context, serviceIntent)
+
+            val headlessIntent = Intent(context, CallHeadlessTask::class.java).apply {
+                putExtras(Bundle().apply { data.forEach { (k, v) -> putString(k, v) } })
+            }
             try {
-                val headlessIntent = Intent(context, CallHeadlessTask::class.java).apply {
-                    val bundle = Bundle()
-                    data.forEach { (k, v) -> bundle.putString(k, v) }
-                    putExtras(bundle)
-                }
-                ContextCompat.startForegroundService(context, headlessIntent)
+                context.startService(headlessIntent)
                 HeadlessJsTaskService.acquireWakeLockNow(context)
-            } catch (e: Exception) { 
-                e.printStackTrace() 
+            } catch (e: Exception) {
+                e.printStackTrace()
             }
 
-            // 3. Set Backup Timer (The Ghost Prevention Logic)
-            // Remove any old timer for this UUID before setting a new one
-            stopBackupTimer(uuid)
 
-            val showNotificationRunnable = Runnable {
-                if (!isAppInForeground(context)) {
-                    Log.d("CallMessagingService", "Backup timer triggered for: $uuid")
-                    NativeCallManager.handleIncomingPush(context, data)
-                         // 1. Trigger Notification UI immediately
-                   // NativeCallManager.handleIncomingPush(context, data)
-
-                }
-                pendingNotifications.remove(uuid)
-            }
-            
-            pendingNotifications[uuid] = showNotificationRunnable
-            handler.postDelayed(showNotificationRunnable, 18000) 
         }
     }
 
-    private fun showMissedCallNotification(context: Context, data: Map<String, String>, uuid: String) {
+    private fun showMissedCallNotification(
+        context: Context,
+        data: Map<String, String>,
+        uuid: String
+    ) {
         val name = data["name"] ?: "Unknown"
         val callType = data["callType"] ?: "video"
-        val channelId = "missed_calls" 
-        val article = if (callType.startsWith("a", ignoreCase = true)) "an" else "a"
-        val appName = context.applicationInfo.loadLabel(context.packageManager).toString()
-        val capitalizedAppName = appName.replaceFirstChar { it.uppercase() }
+        val channelId = "missed_calls"
 
-        val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        val notificationManager =
+            context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
 
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            val channel = NotificationChannel(channelId, "Missed Calls", NotificationManager.IMPORTANCE_HIGH)
+            val channel = NotificationChannel(
+                channelId,
+                "Missed Calls",
+                NotificationManager.IMPORTANCE_DEFAULT
+            ).apply { description = "Missed call notifications" }
             notificationManager.createNotificationChannel(channel)
         }
 
-        val launchIntent = context.packageManager.getLaunchIntentForPackage(context.packageName)
-        val pendingFlags = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
-        } else {
-            PendingIntent.FLAG_UPDATE_CURRENT
-        }
-        val contentIntent = PendingIntent.getActivity(context, uuid.hashCode(), launchIntent, pendingFlags)
+        val iconResId =
+            context.resources.getIdentifier("ic_missed_call", "drawable", context.packageName)
+                .takeIf { it != 0 } ?: android.R.drawable.sym_call_missed
+        val appName = context.applicationInfo.loadLabel(context.packageManager).toString()
 
-        var iconResId = context.resources.getIdentifier("ic_missed_call", "drawable", context.packageName)
-        if (iconResId == 0) iconResId = android.R.drawable.sym_call_missed
+        val launchIntent = context.packageManager.getLaunchIntentForPackage(context.packageName)
+        launchIntent?.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
+        val pendingIntent = PendingIntent.getActivity(
+            context,
+            uuid.hashCode(),
+            launchIntent,
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S)
+                PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+            else
+                PendingIntent.FLAG_UPDATE_CURRENT
+        )
 
         val builder = NotificationCompat.Builder(context, channelId)
             .setSmallIcon(iconResId)
-            .setContentTitle("$capitalizedAppName missed call")
-            .setContentText("You missed $article $callType call from $name")
+            .setContentTitle("$appName • Missed $callType call")
+            .setContentText("You missed a call from $name")
             .setPriority(NotificationCompat.PRIORITY_HIGH)
             .setAutoCancel(true)
-            .setContentIntent(contentIntent)
-            .setCategory(NotificationCompat.CATEGORY_MISSED_CALL) 
+            .setCategory(NotificationCompat.CATEGORY_MISSED_CALL)
+            .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
+            .setContentIntent(pendingIntent)
 
         notificationManager.notify(uuid.hashCode(), builder.build())
     }
-}
+
+    private fun isAppInForeground(context: Context): Boolean {
+        val activityManager =
+            context.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
+        val appProcesses = activityManager.runningAppProcesses ?: return false
+        val packageName = context.packageName
+        return appProcesses.any {
+            it.importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND &&
+            it.processName == packageName
+        }
+    }
+}

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

@@ -7,23 +7,32 @@ import com.facebook.react.modules.core.DeviceEventManagerModule
 
 class CallModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
 
-    init {
+    init { 
         instance = this
+        notifyReady()
     }
 
     override fun getName() = "CallModule"
 
     @ReactMethod
     fun getInitialCallData(promise: Promise) {
-        val data = pendingCallDataMap?.let { map ->
-            val writableMap = Arguments.createMap()
-            map.forEach { (key, value) ->
-                writableMap.putString(key, value)
-            }
-            writableMap
+        val writableMap = Arguments.createMap()
+
+        pendingCallDataMap?.let { map ->
+            val eventMap = Arguments.createMap()
+            map.forEach { (key, value) -> eventMap.putString(key, value) }
+            writableMap.putMap("default", eventMap)
+            pendingCallDataMap = null
         }
-        promise.resolve(data)
-        pendingCallDataMap = null
+
+        pendingEvents.forEach { (eventName, data) ->
+            val eventMap = Arguments.createMap()
+            data.forEach { (key, value) -> eventMap.putString(key, value) }
+            writableMap.putMap(eventName, eventMap)
+        }
+        pendingEvents.clear()
+
+        promise.resolve(writableMap)
     }
 
     @ReactMethod
@@ -34,7 +43,6 @@ class CallModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                 "name" to name,
                 "callType" to callType
             )
-            // Use reactApplicationContext safely here
             NativeCallManager.handleIncomingPush(reactApplicationContext, data)
             promise.resolve(true)
         } catch (e: Exception) {
@@ -42,13 +50,47 @@ class CallModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
         }
     }
 
+    /**
+     * Combined Validity Check: 
+     * Used by Headless Task to see if it should proceed with the UI.
+     */
+    @ReactMethod
+    fun checkCallValidity(uuid: String, promise: Promise) {
+        val isValid = CallState.shouldProceed(uuid)
+        val isCanceled = CallState.isCanceled(uuid)
+        
+        val map = Arguments.createMap().apply {
+            putBoolean("isValid", isValid)
+            putBoolean("isCanceled", isCanceled)
+        }
+        promise.resolve(map)
+    }
+
+    /**
+     * General Status Check:
+     * Useful for checking if the UI is still relevant.
+     */
+    @ReactMethod
+    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)
+        }
+        promise.resolve(map)
+    }
+
     @ReactMethod
     fun endNativeCall(uuid: String) {
         NativeCallManager.stopRingtone()
+        CallState.clear(uuid)
         pendingCallDataMap = null
         
         val notificationManager = reactApplicationContext.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-        notificationManager.cancel(uuid.hashCode())
+        notificationManager.cancel(101)
     }
 
     @ReactMethod
@@ -62,17 +104,47 @@ class CallModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
     companion object {
         private var instance: CallModule? = null
         private var pendingCallDataMap: Map<String, String>? = null
+        private var pendingEvents: MutableMap<String, Map<String, String>> = mutableMapOf()
+        private val onReadyCallbacks = mutableListOf<() -> Unit>()
 
-        // This is the static gate accessible from AcceptCallActivity
         @JvmStatic
+        fun isReady(): Boolean {
+            val reactContext = instance?.reactApplicationContext
+            return reactContext != null && reactContext.hasActiveCatalystInstance()
+        }
+
+        @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 registerOnReadyCallback(callback: () -> Unit) {
+            if (isReady()) {
+                callback()
+            } else {
+                onReadyCallbacks.add(callback)
+            }
+        }
+
+        fun notifyReady() {
+            onReadyCallbacks.forEach { it() }
+            onReadyCallbacks.clear()
+        }
+
+        @JvmStatic
+        fun setPendingEvent(eventName: String, data: Map<String, String>) {
+            pendingEvents[eventName] = data
         }
 
         @JvmStatic
         fun sendEventToJS(eventName: String, params: Any?) {
             val reactContext = instance?.reactApplicationContext
-
             val bridgeData = when (params) {
                 is Map<*, *> -> {
                     val map = Arguments.createMap()
@@ -84,16 +156,13 @@ class CallModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                 else -> null
             }
 
-            // If app is alive, send via Bridge
-            if (reactContext != null && reactContext.hasActiveCatalystInstance()) {
+            if (isReady()) {
                 reactContext
-                    .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                    ?.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
                     ?.emit(eventName, bridgeData)
-            } 
-            // If app is in killed state, save for polling
-            else if (eventName == "onCallAccepted" && params is Map<*, *>) {
+            } else if (params is Map<*, *>) {
                 @Suppress("UNCHECKED_CAST")
-                setPendingCallData(params as Map<String, String>)
+                setPendingEvent(eventName, params as Map<String, String>)
             }
         }
     }

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

@@ -0,0 +1,54 @@
+package com.rnsnativecall
+
+object CallState {
+    @Volatile private var currentUuid: String? = null
+    @Volatile private var canceledUuids = mutableSetOf<String>()
+
+    @Synchronized
+    fun isBusy(): Boolean = currentUuid != null
+
+    @Synchronized
+    fun setCurrent(uuid: String): Boolean {
+        if (currentUuid == null) {
+            currentUuid = uuid
+            return true
+        }
+        return currentUuid == uuid
+    }
+
+    fun getCurrent(): String? = currentUuid
+
+    @Synchronized
+    fun markCanceled(uuid: String) {
+        canceledUuids.add(uuid)
+        if (currentUuid == uuid) {
+            currentUuid = null
+        }
+    }
+
+    // ✅ Fixes the "Unresolved reference 'isCanceled'" error
+    @Synchronized
+    fun isCanceled(uuid: String?): Boolean {
+        if (uuid == null) return false
+        return canceledUuids.contains(uuid)
+    }
+
+    @Synchronized
+    fun clear(uuid: String?) {
+        if (uuid == null) return
+        if (currentUuid == uuid) currentUuid = null
+        canceledUuids.remove(uuid)
+    }
+
+    @Synchronized
+    fun shouldProceed(uuid: String?): Boolean {
+        if (uuid == null) return false
+        return (currentUuid == uuid) && !canceledUuids.contains(uuid)
+    }
+
+    @Synchronized
+    fun clearAll() {
+        currentUuid = null
+        canceledUuids.clear()
+    }
+}

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

@@ -6,25 +6,23 @@ import android.app.PendingIntent
 import android.content.Context
 import android.content.Intent
 import android.os.Build
-import android.os.Bundle
 import androidx.core.app.NotificationCompat
 import android.media.Ringtone
 import android.media.RingtoneManager
 import android.graphics.Color
-import androidx.core.app.Person
-import androidx.core.graphics.drawable.IconCompat
 
 object NativeCallManager {
 
     private var ringtone: Ringtone? = null
-    const val CALL_CHANNEL_ID = "CALL_CHANNEL_ID"
+    const val channelId = "CALL_CHANNEL_ID"
 
     fun handleIncomingPush(context: Context, data: Map<String, String>) {
         val uuid = data["callUuid"] ?: return
         stopRingtone()
-        
-        val name = data["name"] ?: "Someone"
+
+        val name = data["name"] ?: "Incoming Call"
         val callType = data["callType"] ?: "audio"
+        val notificationId = uuid.hashCode()
 
         val pendingFlags = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
             PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_MUTABLE
@@ -32,94 +30,136 @@ object NativeCallManager {
             PendingIntent.FLAG_UPDATE_CURRENT
         }
 
-        // Prepare Common Bundle
-        val extras = Bundle().apply {
-            data.forEach { (k, v) -> putString(k, v) }
-            putString("EXTRA_CALL_UUID", uuid)
-        }
+        val noOpIntent = PendingIntent.getActivity(
+            context,
+            notificationId + 1,
+            Intent(), 
+            pendingFlags
+        )
 
-        // 1. UI Intent (When tapping the notification body)
         val intentToActivity = Intent(context, AcceptCallActivity::class.java).apply {
-            action = "ACTION_SHOW_UI_$uuid"
-            putExtras(extras)
-            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
+            this.action = "ACTION_SHOW_UI_$uuid"
+            data.forEach { (key, value) -> this.putExtra(key, value) }
+            this.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
         }
+
         val fullScreenPendingIntent = PendingIntent.getActivity(
-            context, uuid.hashCode(), intentToActivity, pendingFlags
+            context,
+            notificationId,
+            intentToActivity,
+            pendingFlags
         )
 
-        // 2. Reject Intent
         val rejectIntent = Intent(context, CallActionReceiver::class.java).apply {
-            action = "ACTION_REJECT_$uuid"
-            putExtras(extras)
+            this.action = "ACTION_REJECT_$uuid"
+            this.putExtra("EXTRA_CALL_UUID", uuid)
+            data.forEach { (key, value) -> this.putExtra(key, value) }
         }
-        val rejectPendingIntent = PendingIntent.getBroadcast(
-            context, uuid.hashCode() + 1, rejectIntent, pendingFlags
-        )
 
-        // 3. Answer Intent
-        val answerIntent = Intent(context, CallActionReceiver::class.java).apply {
-            action = "ACTION_ACCEPT_$uuid"
-            putExtras(extras)
-        }
-        val answerPendingIntent = PendingIntent.getBroadcast(
-            context, uuid.hashCode() + 2, answerIntent, pendingFlags
+        val rejectPendingIntent = PendingIntent.getBroadcast(
+            context,
+            notificationId,
+            rejectIntent,
+            pendingFlags
         )
 
         val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
 
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            val channel = NotificationChannel(CALL_CHANNEL_ID, "Incoming Call", NotificationManager.IMPORTANCE_HIGH).apply {
+            val channel = NotificationChannel(
+                channelId,
+                "Incoming Calls",
+                NotificationManager.IMPORTANCE_HIGH // NotificationManager.IMPORTANCE_HIGH
+            ).apply {
+                enableVibration(true)
+                vibrationPattern = longArrayOf(0, 500, 500, 500)
+                lightColor = Color.GREEN
                 setBypassDnd(true)
                 lockscreenVisibility = NotificationCompat.VISIBILITY_PUBLIC
-                enableVibration(true)
-                setSound(null, null) 
+                setSound(null, null)
             }
             notificationManager.createNotificationChannel(channel)
         }
 
-        val builder = NotificationCompat.Builder(context, CALL_CHANNEL_ID)
+        val builder = NotificationCompat.Builder(context, channelId)
             .setSmallIcon(context.applicationInfo.icon)
             .setContentTitle("Incoming $callType call")
             .setContentText(name)
-            .setPriority(NotificationCompat.PRIORITY_MAX)
-            .setCategory(NotificationCompat.CATEGORY_CALL)
-            .setOngoing(true) 
+            .setPriority(NotificationCompat.PRIORITY_MAX) // PRIORITY_HIGH
+            .setCategory(NotificationCompat.CATEGORY_CALL) // CATEGORY_CALL
+            .setOngoing(true)
             .setAutoCancel(false)
-            .setFullScreenIntent(fullScreenPendingIntent, true) // Essential for waking screen
-            .setColor(Color.parseColor("#28a745"))
-            .setColorized(true)
-            // ADDING ACTIONS MANUALLY TO CONTROL ORDER
-            // First Action added = Leftmost button
-            .addAction(0, "Answer", answerPendingIntent) 
+            .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
+            .setFullScreenIntent(fullScreenPendingIntent, true)
+            .setContentIntent(noOpIntent)
+            .addAction(0, "Answer", fullScreenPendingIntent)
             .addAction(0, "Decline", rejectPendingIntent)
 
+        notificationManager.notify(notificationId, builder.build())
 
-
-            
-        notificationManager.notify(uuid.hashCode(), builder.build())
-
-        // Start Ringtone
         try {
             val ringtoneUri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE)
             ringtone = RingtoneManager.getRingtone(context, ringtoneUri)
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) ringtone?.isLooping = true
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+                ringtone?.isLooping = true
+            }
             ringtone?.play()
-        } catch (e: Exception) { e.printStackTrace() }
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
     }
 
     fun stopRingtone() {
         try {
             ringtone?.let { if (it.isPlaying) it.stop() }
             ringtone = null
-        } catch (e: Exception) { e.printStackTrace() }
+        } catch (e: Exception) {
+            ringtone = null
+        }
     }
 
+fun connecting(context: Context, uuid: String, name: String, callType: String) {
+    val notificationId = uuid.hashCode()
+    val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+
+    val builder = NotificationCompat.Builder(context, channelId)
+        .setSmallIcon(context.applicationInfo.icon)
+        .setContentTitle("Incoming $callType call")
+        .setContentText("Connecting…") // ✅ show connecting text
+        .setSubText("Connecting…") // status line
+        .setPriority(NotificationCompat.PRIORITY_MAX)
+        .setCategory(NotificationCompat.CATEGORY_CALL)
+        .setOngoing(true)
+        .setAutoCancel(false)
+        .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
+        .setProgress(0, 0, true) // ✅ system activity indicator (indeterminate progress bar)
+
+    notificationManager.notify(notificationId, builder.build())
+}
+
+fun aborting(context: Context, uuid: String, name: String, callType: String) {
+    val notificationId = uuid.hashCode()
+    val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+
+    val builder = NotificationCompat.Builder(context, channelId)
+        .setSmallIcon(context.applicationInfo.icon)
+        .setContentTitle("Incoming $callType call")
+        .setContentText("Aborting…") // ✅ show aborting text
+        .setSubText("Aborting…") // status line
+        .setPriority(NotificationCompat.PRIORITY_MAX)
+        .setCategory(NotificationCompat.CATEGORY_CALL)
+        .setOngoing(true)
+        .setAutoCancel(false)
+        .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
+        .setProgress(0, 0, true) // ✅ indeterminate progress indicator
+
+    notificationManager.notify(notificationId, builder.build())
+}
+
+
     fun dismissIncomingCall(context: Context, uuid: String?) {
         stopRingtone()
         val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-        if (uuid != null) {
-            notificationManager.cancel(uuid.hashCode())
-        }
+        if (uuid != null) notificationManager.cancel(uuid.hashCode())
     }
 }