rns-nativecall 0.7.9 → 0.8.1

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

@@ -1,77 +1,28 @@
 package com.rnsnativecall
 
 import android.app.Activity
-import android.app.NotificationManager
-import android.content.Context
 import android.content.Intent
 import android.os.Bundle
 import android.view.WindowManager
-import android.app.KeyguardManager
+import android.os.Build
 
 class AcceptCallActivity : Activity() {
-
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
 
-        window.addFlags(
-            WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED or
-            WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON or
-            WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON
-        )
-
-        val keyguardManager = getSystemService(Context.KEYGUARD_SERVICE) as KeyguardManager
-        keyguardManager.requestDismissKeyguard(this, null)
-
-        // Check: Did the user actually press "Answer" or did the system auto-launch?
-    // If the action is null or doesn't match your Answer action, 
-    // it means the system is just "preparing" the activity.
-    if (intent.action?.startsWith("ACTION_ANSWER") != true) {
-        // If it's just an auto-launch, we don't fire the JS event!
-        // We can either finish() or show a tiny "Swipe to Answer" UI.
-        return 
-    }
-        processCallIntent(intent)
-    }
-
-    private fun processCallIntent(intent: Intent) {
-        NativeCallManager.stopRingtone()
-
-        val extras = intent.extras
-        val uuid = extras?.getString("callUuid")
-
-        val notificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-        uuid?.let { notificationManager.cancel(it.hashCode()) }
-
-        // ✅ WE STOP SENDING THE JS EVENT HERE.
-        // Instead, we pass the intent to MainActivity with a specific ACTION.
-        openMainApp(extras)
-        finish()
-    }
-
-    private fun openMainApp(extras: Bundle?) {
-        try {
-            // Get the actual MainActivity class name (e.g., com.yourapp.MainActivity)
-            val mainActivityClassName = "${packageName}.MainActivity"
-            
-            val intent = Intent().apply {
-                setClassName(packageName, mainActivityClassName)
-                action = "com.rnsnativecall.ACTION_ANSWER"
-                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
-                
-                // Ensure extras are carried over
-                extras?.let { putExtras(it) }
-            }
-            
-            startActivity(intent)
-        } catch (e: Exception) {
-            // Fallback: If explicit mapping fails, try the launch intent but force the action
-            val launchIntent = packageManager.getLaunchIntentForPackage(packageName)
-            launchIntent?.apply {
-                action = "com.rnsnativecall.ACTION_ANSWER"
-                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
-                extras?.let { putExtras(it) }
-                startActivity(this)
+        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)
+                putExtras(intent.extras ?: Bundle())
+                putExtra("navigatingToCall", true)
             }
+            startActivity(launchIntent)
         }
+
+        finish()
+        overridePendingTransition(0, 0)
     }
 }

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

@@ -4,49 +4,70 @@ import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
 import android.app.NotificationManager
-import android.app.KeyguardManager
+import android.os.Bundle
 
 class CallActionReceiver : BroadcastReceiver() {
     override fun onReceive(context: Context, intent: Intent) {
+        // Stop sound immediately
         NativeCallManager.stopRingtone()
 
         val uuid = intent.getStringExtra("EXTRA_CALL_UUID") ?: return
         val action = intent.action ?: ""
+        val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
 
-        val notificationManager =
-            context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-
-        val dataMap = mutableMapOf<String, String>()
+        // 1. Reconstruct the full data map from Intent Extras
+        val fullDataMap = mutableMapOf<String, String>()
         intent.extras?.keySet()?.forEach { key ->
-            intent.extras?.get(key)?.let { dataMap[key] = it.toString() }
+            intent.extras?.get(key)?.let { fullDataMap[key] = it.toString() }
         }
 
-        val name = intent.extras?.getString("name") ?: "Someone"
-        val callType = intent.extras?.getString("callType") ?: "audio"
-
-        val keyguardManager = context.getSystemService(Context.KEYGUARD_SERVICE) as KeyguardManager
+        val name = fullDataMap["name"] ?: "Someone"
+        val callType = fullDataMap["callType"] ?: "audio"
 
-        if (action.contains("ACTION_REJECT")) {
+        // --- HANDLE REJECT ---
+        if (action == "ACTION_REJECT") {
             if (CallModule.isReady()) {
-                CallModule.sendEventToJS("onCallRejected", mapOf("callUuid" to uuid))
+                CallModule.sendEventToJS("onCallRejected", fullDataMap)
                 notificationManager.cancel(uuid.hashCode())
+                CallForegroundService.stop(context)
             } else {
-                // Queue pending event
-                CallModule.setPendingCallData("onCallRejected_pending", mapOf("callUuid" to uuid))
-                // Update notification pill to "Aborting…" state
+                CallModule.setPendingCallData("onCallRejected_pending", fullDataMap)
                 NativeCallManager.aborting(context, uuid, name, callType)
+            }
+        }
+
+        // --- HANDLE ANSWER ---
+        if (action == "ACTION_ANSWER") {
+            // Dismiss the "Incoming" pill immediately
+            notificationManager.cancel(uuid.hashCode())
 
-                // Register callback to auto‑open app once RN is ready
-                CallModule.registerOnReadyCallback {
-                    val launchIntent = context.packageManager.getLaunchIntentForPackage(context.packageName)
-                    launchIntent?.apply {
-                        addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
-                        putExtras(intent.extras ?: android.os.Bundle())
-                        putExtra("navigatingToCall", true)
-                        context.startActivity(this)
-                    }
-                }
+            if (CallModule.isReady()) {
+                // Inform JS with full payload
+                CallModule.sendEventToJS("onCallAccepted", fullDataMap)
+                CallForegroundService.stop(context)
+                
+                // Open the app
+                launchApp(context, intent.extras)
+            } else {
+                // Cold start: Queue full payload and show connecting
+                CallModule.setPendingCallData("onCallAccepted_pending", fullDataMap)
+                NativeCallManager.connecting(context, uuid, name, callType)
+                
+                launchApp(context, intent.extras)
             }
         }
     }
+
+
+private fun launchApp(context: Context, extras: Bundle?) {
+    val intent = Intent(context, AcceptCallActivity::class.java).apply {
+        addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or 
+                 Intent.FLAG_ACTIVITY_SINGLE_TOP or 
+                 Intent.FLAG_ACTIVITY_CLEAR_TOP)
+        
+        if (extras != null) putExtras(extras)
+    }
+    context.startActivity(intent)
 }
+
+}

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

@@ -1,20 +1,23 @@
 package com.rnsnativecall
 
 import android.app.*
+import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
+import android.content.IntentFilter
 import android.content.pm.ServiceInfo
 import android.os.Build
 import android.os.Bundle
 import android.os.IBinder
 import androidx.core.app.NotificationCompat
 import com.facebook.react.HeadlessJsTaskService
-
-import android.os.Handler // Added
-import android.os.Looper  // Added
+import android.os.Handler
+import android.os.Looper
 
 class CallForegroundService : Service() {
 
+    private var unlockReceiver: UnlockReceiver? = null // Store reference for unregistering
+
     companion object {
         private const val NOTIFICATION_ID = 101
         private const val CHANNEL_ID = "incoming_call_service"
@@ -25,6 +28,23 @@ class CallForegroundService : Service() {
         }
     }
 
+    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) {
+            // Android 13+ requires the RECEIVER_EXPORTED flag for system broadcasts
+            registerReceiver(unlockReceiver, filter, Context.RECEIVER_EXPORTED)
+        } else {
+            registerReceiver(unlockReceiver, filter)
+        }
+    }
+
     override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
         val data = intent?.extras
         val name = data?.getString("name") ?: "Someone"
@@ -33,14 +53,13 @@ class CallForegroundService : Service() {
 
         val notification = NotificationCompat.Builder(this, CHANNEL_ID)
             .setContentTitle(name)
-            .setContentText("Connecting...")
+            .setContentText("Incoming Call...")
             .setSmallIcon(applicationInfo.icon)
             .setCategory(NotificationCompat.CATEGORY_CALL)
             .setPriority(NotificationCompat.PRIORITY_HIGH) 
             .setOngoing(true)
             .build()
 
-        // --- ANDROID 14 FIX START ---
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
             startForeground(
                 NOTIFICATION_ID, 
@@ -50,11 +69,9 @@ class CallForegroundService : Service() {
         } else {
             startForeground(NOTIFICATION_ID, notification)
         }
-        // --- ANDROID 14 FIX END ---
 
         // Launch the Headless Task
         val headlessIntent = Intent(this, CallHeadlessTask::class.java).apply {
-            // Safe bundle copy
             val bundle = Bundle()
             data?.let { b ->
                 for (key in b.keySet()) {
@@ -67,38 +84,44 @@ class CallForegroundService : Service() {
         try {
             this.startService(headlessIntent)
             HeadlessJsTaskService.acquireWakeLockNow(this)
-        } catch (e: Exception) {
-            e.printStackTrace()
-        }
+        } catch (e: Exception) { e.printStackTrace() }
 
+        // Auto-stop after 30s
+        Handler(Looper.getMainLooper()).postDelayed({
+            try { stopSelf() } catch (e: Exception) {}
+        }, 30000)
 
-        // Automatically stop this service if JS doesn't stop it within 30 seconds
-Handler(Looper.getMainLooper()).postDelayed({
-    try {
-        stopSelf()
-    } catch (e: Exception) {
-        // Service might already be stopped
-    }
-}, 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_HIGH
-        ).apply {
-            description = "Handles incoming call connection state"
-            // Optional: makes the "Connecting" notification silent 
-            // so it doesn't double-beep with the actual ringtone
-            setSound(null, null) 
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val channel = NotificationChannel(
+                CHANNEL_ID,
+                "Call Service",
+                NotificationManager.IMPORTANCE_LOW
+            ).apply {
+                description = "Handles incoming call connection state"
+                setSound(null, null) 
+                enableVibration(false)
+                setBypassDnd(true)
+                lockscreenVisibility = NotificationCompat.VISIBILITY_PUBLIC
+            }
+            val manager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+            manager.createNotificationChannel(channel)
         }
-        val manager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-        manager.createNotificationChannel(channel)
     }
-}
 
     override fun onBind(intent: Intent?): IBinder? = null
 }

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

@@ -34,7 +34,6 @@ class CallMessagingService : FirebaseMessagingService() {
         CallState.clear(uuid, context) 
     }
     
-    // Dismiss the "Connecting..." or "Incoming Call" UI
     NativeCallManager.dismissIncomingCall(context, uuid)
     showMissedCallNotification(context, data, uuid)
     return

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

@@ -5,6 +5,9 @@ import android.content.Context
 import com.facebook.react.bridge.*
 import com.facebook.react.modules.core.DeviceEventManagerModule
 import android.content.Intent
+import android.os.Build
+import android.provider.Settings
+import android.net.Uri
 
 class CallModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
 
@@ -51,6 +54,29 @@ class CallModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
         }
     }
     
+    // Inside your CallModule class
+    @ReactMethod
+    fun checkOverlayPermission(promise: Promise) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            promise.resolve(Settings.canDrawOverlays(reactApplicationContext))
+        } else {
+            promise.resolve(true)
+        }
+    }
+
+     @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: 
@@ -108,11 +134,6 @@ class CallModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
         notificationManager.cancel(101)
     }
 
-    @ReactMethod
-    fun checkTelecomPermissions(promise: Promise) {
-        promise.resolve(true)
-    }
-
     @ReactMethod fun addListener(eventName: String) {}
     @ReactMethod fun removeListeners(count: Int) {}
 

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

@@ -10,85 +10,89 @@ import androidx.core.app.NotificationCompat
 import android.media.Ringtone
 import android.media.RingtoneManager
 import android.graphics.Color
-
 import android.app.KeyguardManager
 
-import com.rnsnativecall.CallMessagingService
-
 object NativeCallManager {
 
     private var ringtone: Ringtone? = null
     const val channelId = "CALL_CHANNEL_ID"
 
+    private var currentCallData: Map<String, String>? = null
+
+    fun getCurrentCallData(): Map<String, String>? = currentCallData
+
     fun handleIncomingPush(context: Context, data: Map<String, String>) {
         val uuid = data["callUuid"] ?: return
+        this.currentCallData = data
         stopRingtone()
 
         val name = data["name"] ?: "Incoming Call"
         val callType = data["callType"] ?: "audio"
         val notificationId = uuid.hashCode()
 
- 
-
-
-        // --- LOCK SCREEN GATEKEEPER ---
-        val keyguardManager = context.getSystemService(Context.KEYGUARD_SERVICE) as KeyguardManager
-        if (keyguardManager.isKeyguardLocked) {
-             // Device is locked? We bounce it!
-             CallState.markCanceled(uuid, context) 
-             showMissedCallNotification(context, data, uuid)
-             return // 🛑 Flow stops here
-        }
-
-
-
         val pendingFlags = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
             PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_MUTABLE
         } else {
             PendingIntent.FLAG_UPDATE_CURRENT
         }
 
-        val noOpIntent = PendingIntent.getActivity(
-            context,
-            notificationId + 1,
-            Intent(), 
-            pendingFlags
-        )
-
-        val intentToActivity = Intent(context, AcceptCallActivity::class.java).apply {
-            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)
+        // Dummy intent for content click
+        val noOpIntent = PendingIntent.getActivity(context, notificationId + 3, Intent(), pendingFlags)
+
+        // 1. Define the flags properly (DO NOT MIX THEM)
+val mutableFlags = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+    PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_MUTABLE
+} else {
+    PendingIntent.FLAG_UPDATE_CURRENT
+}
+
+val immutableFlags = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+    PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+} else {
+    PendingIntent.FLAG_UPDATE_CURRENT
+}
+
+// 2. Setup the Overlay Intent
+val overlayIntent = Intent(context, NotificationOverlayActivity::class.java).apply { 
+    this.putExtra("EXTRA_CALL_UUID", uuid)
+    data.forEach { (k, v) -> this.putExtra(k, v) }
+    // No User Action flag prevents the intent from triggering an auto-dismiss of notifications
+    addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_NO_USER_ACTION)
+}
+
+// 3. Create the Full Screen PendingIntent (Use IMMUTABLE)
+val fullScreenPendingIntent = PendingIntent.getActivity(
+    context, 
+    notificationId, 
+    overlayIntent, 
+    immutableFlags // <--- Use the immutable version here
+)
+
+
+
+        // --- ANSWER ACTION ---
+        val answerIntent = Intent(context, CallActionReceiver::class.java).apply {
+            this.action = "ACTION_ANSWER"
+            this.putExtra("EXTRA_CALL_UUID", uuid)
+            
+            data.forEach { (key, value) -> this.putExtra(key, value) } // Pass full data
         }
 
-        val fullScreenPendingIntent = PendingIntent.getActivity(
-            context,
-            notificationId,
-            intentToActivity,
-            pendingFlags
-        )
+        val answerPendingIntent = PendingIntent.getBroadcast(context, notificationId + 1, answerIntent, mutableFlags)
 
+        // --- REJECT ACTION ---
         val rejectIntent = Intent(context, CallActionReceiver::class.java).apply {
-            this.action = "ACTION_REJECT_$uuid"
+            this.action = "ACTION_REJECT"
             this.putExtra("EXTRA_CALL_UUID", uuid)
-            data.forEach { (key, value) -> this.putExtra(key, value) }
+            data.forEach { (key, value) -> this.putExtra(key, value) } // Pass full data
         }
-
-        val rejectPendingIntent = PendingIntent.getBroadcast(
-            context,
-            notificationId,
-            rejectIntent,
-            pendingFlags
-        )
+        
+        val rejectPendingIntent = PendingIntent.getBroadcast(context, notificationId + 2, rejectIntent, mutableFlags)
 
         val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
 
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            val channel = NotificationChannel(
-                channelId,
-                "Incoming Calls",
-                NotificationManager.IMPORTANCE_HIGH // NotificationManager.IMPORTANCE_HIGH
-            ).apply {
+            val channel = NotificationChannel(channelId, "Incoming Calls", NotificationManager.IMPORTANCE_HIGH).apply {
                 enableVibration(true)
                 vibrationPattern = longArrayOf(0, 500, 500, 500)
                 lightColor = Color.GREEN
@@ -99,83 +103,70 @@ object NativeCallManager {
             notificationManager.createNotificationChannel(channel)
         }
 
+        val keyguardManager = context.getSystemService(Context.KEYGUARD_SERVICE) as KeyguardManager
+        val isLocked = keyguardManager.isKeyguardLocked
+
+
         val builder = NotificationCompat.Builder(context, channelId)
             .setSmallIcon(context.applicationInfo.icon)
             .setContentTitle("Incoming $callType call")
             .setContentText(name)
-            .setPriority(NotificationCompat.PRIORITY_MAX) // PRIORITY_HIGH
-            .setCategory(NotificationCompat.CATEGORY_CALL) // CATEGORY_CALL
+            .setPriority(NotificationCompat.PRIORITY_MAX)
+            .setCategory(NotificationCompat.CATEGORY_CALL)
             .setOngoing(true)
             .setAutoCancel(false)
             .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
-            .setFullScreenIntent(fullScreenPendingIntent, true)
             .setContentIntent(noOpIntent)
-            .addAction(0, "Answer", fullScreenPendingIntent)
+            .addAction(0, "Answer", answerPendingIntent)
             .addAction(0, "Decline", rejectPendingIntent)
+            .setDefaults(NotificationCompat.DEFAULT_ALL)
+       
+              builder.setFullScreenIntent(fullScreenPendingIntent, true)
+   
 
         notificationManager.notify(notificationId, builder.build())
 
         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) {
-            ringtone = null
-        }
+        } 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 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("Incoming $callType call")
+            .setContentText("Connecting…")
+            .setPriority(NotificationCompat.PRIORITY_MAX)
+            .setOngoing(true)
+            .setProgress(0, 0, true)
+        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("Incoming $callType call")
+            .setContentText("Aborting…")
+            .setPriority(NotificationCompat.PRIORITY_MAX)
+            .setOngoing(true)
+            .setProgress(0, 0, true)
+        notificationManager.notify(uuid.hashCode(), builder.build())
+    }
 
     fun dismissIncomingCall(context: Context, uuid: String?) {
+        this.currentCallData = null
         stopRingtone()
         val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
         if (uuid != null) notificationManager.cancel(uuid.hashCode())