@qusaieilouti99/call-manager 0.1.16 → 0.1.17

package/android/src/main/java/com/qusaieilouti99/callmanager/CallActivity.kt

@@ -2,9 +2,8 @@ package com.qusaieilouti99.callmanager
 
 import android.app.Activity
 import android.content.Intent
-import android.graphics.Color
 import android.os.Bundle
-import android.view.View
+import android.view.WindowManager
 import android.widget.Button
 import android.widget.ImageView
 import android.widget.TextView
@@ -13,34 +12,39 @@ class CallActivity : Activity() {
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         window.addFlags(
-            android.view.WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED or
-            android.view.WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON or
-            android.view.WindowManager.LayoutParams.FLAG_DISMISS_KEYGUARD
+            WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED or
+            WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON or
+            WindowManager.LayoutParams.FLAG_DISMISS_KEYGUARD
         )
         setContentView(R.layout.activity_call)
 
+        // Cancel the notification as soon as CallActivity is shown
+        CallEngine.cancelIncomingCallUI(this)
+
         val callerName = intent.getStringExtra("callerName") ?: "Unknown"
-        val avatarView = findViewById<ImageView>(R.id.avatar)
         val nameView = findViewById<TextView>(R.id.caller_name)
         val answerBtn = findViewById<Button>(R.id.answer_btn)
         val declineBtn = findViewById<Button>(R.id.decline_btn)
 
         nameView.text = callerName
-        // Optionally set avatarView image
 
         answerBtn.setOnClickListener {
-            // Start MainActivity (React Native) using launch intent
-            val launchIntent = packageManager.getLaunchIntentForPackage(packageName)
-            launchIntent?.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
-            launchIntent?.putExtra("incomingCall", true)
-            startActivity(launchIntent)
+            CallEngine.bringAppToForeground(this)
             finish()
         }
 
         declineBtn.setOnClickListener {
-            // Stop ringtone, cancel notification, finish
-            CallNotificationHelper(this).cancelIncomingCallNotification()
+            CallEngine.cancelIncomingCallUI(this)
+            CallEngine.stopForegroundService(this)
+            CallEngine.disconnectTelecomCall(this, intent.getStringExtra("callId") ?: "")
             finish()
         }
     }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        CallEngine.cancelIncomingCallUI(this)
+        CallEngine.stopForegroundService(this)
+        CallEngine.disconnectTelecomCall(this, intent.getStringExtra("callId") ?: "")
+    }
 }

package/android/src/main/java/com/qusaieilouti99/callmanager/CallEngine.kt

@@ -0,0 +1,195 @@
+package com.qusaieilouti99.callmanager
+
+import android.app.*
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.media.AudioAttributes
+import android.media.RingtoneManager
+import android.os.Build
+import android.os.Bundle
+import android.telecom.PhoneAccount
+import android.telecom.PhoneAccountHandle
+import android.telecom.TelecomManager
+import android.util.Log
+import android.app.Person
+
+object CallEngine {
+    private const val TAG = "CallEngine"
+    private const val PHONE_ACCOUNT_ID = "com.qusaieilouti99.callmanager.SELF_MANAGED"
+    private const val NOTIF_CHANNEL_ID = "incoming_call_channel"
+    private const val NOTIF_ID = 2001
+    private const val FOREGROUND_CHANNEL_ID = "call_foreground_channel"
+    private const val FOREGROUND_NOTIF_ID = 1001
+
+    private var ringtone: android.media.Ringtone? = null
+
+    // --- Public API ---
+
+    fun reportIncomingCall(context: Context, callId: String, callData: String) {
+        Log.d(TAG, "reportIncomingCall: $callId, $callData")
+        val callerName = try {
+            val json = org.json.JSONObject(callData)
+            json.optString("name", "Unknown")
+        } catch (e: Exception) { "Unknown" }
+
+        showIncomingCallUI(context, callId, callerName)
+        registerPhoneAccount(context)
+        val telecomManager = context.getSystemService(Context.TELECOM_SERVICE) as TelecomManager
+        val phoneAccountHandle = getPhoneAccountHandle(context)
+        val extras = Bundle().apply { putString(MyConnectionService.EXTRA_CALL_DATA, callData) }
+        try {
+            telecomManager.addNewIncomingCall(phoneAccountHandle, extras)
+            startForegroundService(context)
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to report incoming call: ${e.message}")
+        }
+    }
+
+    fun showIncomingCallUI(context: Context, callId: String, callerName: String) {
+        createNotificationChannel(context)
+        val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+
+        // PendingIntents
+        val answerIntent = Intent(context, CallNotificationActionReceiver::class.java).apply {
+            action = "com.qusaieilouti99.callmanager.ANSWER_CALL"
+            putExtra("callId", callId)
+        }
+        val answerPendingIntent = PendingIntent.getBroadcast(context, 0, answerIntent, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE)
+
+        val declineIntent = Intent(context, CallNotificationActionReceiver::class.java).apply {
+            action = "com.qusaieilouti99.callmanager.DECLINE_CALL"
+            putExtra("callId", callId)
+        }
+        val declinePendingIntent = PendingIntent.getBroadcast(context, 1, declineIntent, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE)
+
+        val fullScreenIntent = Intent(context, CallActivity::class.java).apply {
+            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
+            putExtra("callId", callId)
+            putExtra("callerName", callerName)
+        }
+        val fullScreenPendingIntent = PendingIntent.getActivity(context, 2, fullScreenIntent, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE)
+
+        val notification: Notification = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            val person = Person.Builder().setName(callerName).setImportant(true).build()
+            Notification.Builder(context, NOTIF_CHANNEL_ID)
+                .setSmallIcon(android.R.drawable.sym_call_incoming)
+                .setStyle(Notification.CallStyle.forIncomingCall(person, declinePendingIntent, answerPendingIntent))
+                .setFullScreenIntent(fullScreenPendingIntent, true)
+                .setOngoing(true)
+                .setAutoCancel(false)
+                .build()
+        } else {
+            Notification.Builder(context, NOTIF_CHANNEL_ID)
+                .setSmallIcon(android.R.drawable.sym_call_incoming)
+                .setContentTitle("Incoming Call")
+                .setContentText(callerName)
+                .setPriority(Notification.PRIORITY_HIGH)
+                .setCategory(Notification.CATEGORY_CALL)
+                .setFullScreenIntent(fullScreenPendingIntent, true)
+                .addAction(android.R.drawable.sym_action_call, "Answer", answerPendingIntent)
+                .addAction(android.R.drawable.ic_menu_close_clear_cancel, "Decline", declinePendingIntent)
+                .setOngoing(true)
+                .setAutoCancel(false)
+                .build()
+        }
+
+        notificationManager.notify(NOTIF_ID, notification)
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) playRingtone(context)
+    }
+
+    fun cancelIncomingCallUI(context: Context) {
+        val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        notificationManager.cancel(NOTIF_ID)
+        stopRingtone()
+    }
+
+    fun startForegroundService(context: Context) {
+        val intent = Intent(context, CallForegroundService::class.java)
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) context.startForegroundService(intent)
+        else context.startService(intent)
+    }
+
+    fun stopForegroundService(context: Context) {
+        val intent = Intent(context, CallForegroundService::class.java)
+        context.stopService(intent)
+    }
+
+    fun disconnectTelecomCall(context: Context, callId: String) {
+        // You can extend this to track and disconnect specific calls if needed.
+        Log.d(TAG, "disconnectTelecomCall called for callId=$callId")
+    }
+
+    fun bringAppToForeground(context: Context) {
+        val packageName = context.packageName
+        val launchIntent = context.packageManager.getLaunchIntentForPackage(packageName)
+        launchIntent?.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
+        context.startActivity(launchIntent)
+        Log.d(TAG, "App brought to foreground via launchIntent")
+    }
+
+    // --- Private helpers ---
+
+    private fun playRingtone(context: Context) {
+        try {
+            Log.d(TAG, "Playing ringtone")
+            val uri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE)
+            ringtone = RingtoneManager.getRingtone(context, uri)
+            ringtone?.audioAttributes = AudioAttributes.Builder()
+                .setUsage(AudioAttributes.USAGE_NOTIFICATION_RINGTONE)
+                .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
+                .build()
+            ringtone?.play()
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to play ringtone: ${e.message}")
+        }
+    }
+
+    private fun stopRingtone() {
+        try { ringtone?.stop() } catch (_: Exception) {}
+        ringtone = null
+    }
+
+    private fun createNotificationChannel(context: Context) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val channel = NotificationChannel(
+                NOTIF_CHANNEL_ID,
+                "Incoming Call Channel",
+                NotificationManager.IMPORTANCE_HIGH
+            )
+            channel.description = "Notifications for incoming calls"
+            channel.enableLights(true)
+            channel.lightColor = Color.GREEN
+            channel.enableVibration(true)
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) {
+                channel.setSound(
+                    RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE),
+                    AudioAttributes.Builder()
+                        .setUsage(AudioAttributes.USAGE_NOTIFICATION_RINGTONE)
+                        .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
+                        .build()
+                )
+            }
+            val manager = context.getSystemService(NotificationManager::class.java)
+            manager.createNotificationChannel(channel)
+        }
+    }
+
+    private fun registerPhoneAccount(context: Context) {
+        val telecomManager = context.getSystemService(Context.TELECOM_SERVICE) as TelecomManager
+        val phoneAccountHandle = getPhoneAccountHandle(context)
+        if (telecomManager.getPhoneAccount(phoneAccountHandle) == null) {
+            val phoneAccount = PhoneAccount.builder(phoneAccountHandle, "PingMe Call")
+                .setCapabilities(PhoneAccount.CAPABILITY_SELF_MANAGED)
+                .build()
+            telecomManager.registerPhoneAccount(phoneAccount)
+        }
+    }
+
+    private fun getPhoneAccountHandle(context: Context): PhoneAccountHandle {
+        return PhoneAccountHandle(
+            ComponentName(context, MyConnectionService::class.java),
+            PHONE_ACCOUNT_ID
+        )
+    }
+}

package/android/src/main/java/com/qusaieilouti99/callmanager/CallForegroundService.kt

@@ -53,4 +53,11 @@ class CallForegroundService : Service() {
             manager.createNotificationChannel(channel)
         }
     }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        // Clean up everything when the foreground service is stopped
+        CallEngine.cancelIncomingCallUI(this)
+        CallEngine.disconnectTelecomCall(this, "")
+    }
 }

package/android/src/main/java/com/qusaieilouti99/callmanager/CallManagerModule.kt

@@ -1,10 +1,6 @@
 package com.qusaieilouti99.callmanager
 
 import android.util.Log
-import android.app.ActivityManager
-import android.content.Context
-import android.content.Intent
-import android.os.Build
 import com.facebook.react.bridge.*
 import com.facebook.react.turbomodule.core.interfaces.TurboModule
 import com.facebook.react.module.annotations.ReactModule
@@ -18,73 +14,45 @@ class CallManagerModule(reactContext: ReactApplicationContext) :
         const val TAG = "CallManagerModule"
     }
 
-    private var currentCallId: String? = null
     private var eventHandler: Callback? = null
 
     override fun getName(): String = NAME
 
-    // Register JS event handler
     override fun setEventHandler(callback: Callback) {
         Log.d(TAG, "setEventHandler called, registering JS callback")
         eventHandler = callback
     }
 
-    // Helper to emit events to JS
     fun emitEvent(event: String, callData: String) {
         Log.d(TAG, "emitEvent: event=$event, callData=$callData")
         eventHandler?.invoke(event, callData)
     }
 
-    // 1. Report incoming call (for JS, not used by NotificationService anymore)
     override fun reportIncomingCall(callId: String, callData: String) {
         Log.d(TAG, "reportIncomingCall called from JS with callId=$callId, callData=$callData")
-        // Optionally, you can call CallNativeHelper here if you want to trigger from JS
-        CallNativeHelper.reportIncomingCall(reactApplicationContext, callId, callData)
+        CallEngine.reportIncomingCall(reactApplicationContext, callId, callData)
     }
 
-    // 2. End call
     override fun endCall(callId: String) {
         Log.d(TAG, "endCall called with callId=$callId")
-        val context = reactApplicationContext
-        val intent = Intent(context, CallForegroundService::class.java)
-        val stopped = context.stopService(intent)
-        Log.d(TAG, "CallForegroundService stopped: $stopped")
+        CallEngine.cancelIncomingCallUI(reactApplicationContext)
+        CallEngine.stopForegroundService(reactApplicationContext)
+        CallEngine.disconnectTelecomCall(reactApplicationContext, callId)
     }
 
-    // 3. Answer call
     override fun answerCall(callId: String) {
         Log.d(TAG, "answerCall called with callId=$callId")
-        bringAppToForeground()
+        CallEngine.bringAppToForeground(reactApplicationContext)
     }
 
-    // 4. Silence ringtone
     override fun silenceRingtone() {
         Log.d(TAG, "silenceRingtone called")
-        // TODO: Implement ringtone silencing logic if you play a custom ringtone
+        CallEngine.cancelIncomingCallUI(reactApplicationContext)
     }
 
-    // 5. Reject current and answer new
     override fun rejectCurrentAndAnswerNew(callId: String, callData: String) {
         Log.d(TAG, "rejectCurrentAndAnswerNew called with callId=$callId, callData=$callData")
-        endCall(currentCallId ?: "")
-        CallNativeHelper.reportIncomingCall(reactApplicationContext, callId, callData)
-    }
-
-    // --- Bring App to Foreground ---
-
-    private fun bringAppToForeground() {
-        val context = reactApplicationContext
-        val packageName = context.packageName
-        val activityManager = context.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
-        val tasks = activityManager.appTasks
-        Log.d(TAG, "bringAppToForeground called. tasks.isNullOrEmpty()=${tasks.isNullOrEmpty()}")
-        if (tasks.isNullOrEmpty()) {
-            val launchIntent = context.packageManager.getLaunchIntentForPackage(packageName)
-            launchIntent?.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-            context.startActivity(launchIntent)
-            Log.d(TAG, "App brought to foreground via launchIntent")
-        } else {
-            Log.d(TAG, "App already in foreground or has tasks")
-        }
+        endCall(callId)
+        CallEngine.reportIncomingCall(reactApplicationContext, callId, callData)
     }
 }

package/android/src/main/java/com/qusaieilouti99/callmanager/CallNotificationActionReceiver.kt

@@ -7,37 +7,20 @@ import android.util.Log
 
 class CallNotificationActionReceiver : BroadcastReceiver() {
     override fun onReceive(context: Context, intent: Intent) {
-
         val callId = intent.getStringExtra("callId") ?: return
         Log.d("CallNotificationActionReceiver", "onReceive called with action=${intent.action}, callId=$callId")
-        val action = intent.action
-
-        val app = context.applicationContext as? com.facebook.react.ReactApplication
-        val reactInstanceManager = app?.reactNativeHost?.reactInstanceManager
-        val reactContext = reactInstanceManager?.currentReactContext
-        val module = reactContext?.getNativeModule(CallManagerModule::class.java)
-
-        when (action) {
+        when (intent.action) {
             "com.qusaieilouti99.callmanager.ANSWER_CALL" -> {
                 Log.d("CallNotificationActionReceiver", "Answer action received")
-                bringAppToForeground(context)
+                CallEngine.bringAppToForeground(context)
             }
             "com.qusaieilouti99.callmanager.DECLINE_CALL" -> {
                 Log.d("CallNotificationActionReceiver", "Decline action received")
-                module?.endCall(callId)
+                CallEngine.cancelIncomingCallUI(context)
+                CallEngine.stopForegroundService(context)
+                CallEngine.disconnectTelecomCall(context, callId)
             }
         }
-
-        // Cancel notification and stop ringtone
-        CallNotificationHelper(context).cancelIncomingCallNotification()
-    }
-
-    private fun bringAppToForeground(context: Context) {
-        val packageName = context.packageName
-        val launchIntent = context.packageManager.getLaunchIntentForPackage(packageName)
-        launchIntent?.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
-        launchIntent?.putExtra("incomingCall", true)
-        context.startActivity(launchIntent)
-        Log.d("CallNotificationActionReceiver", "Bringing app to foreground for incoming call")
+        CallEngine.cancelIncomingCallUI(context)
     }
 }

package/android/src/main/java/com/qusaieilouti99/callmanager/MyConnection.kt

@@ -25,6 +25,8 @@ class MyConnection(
                 ?.getNativeModule(CallManagerModule::class.java)
             module?.emitEvent("onCallAnswered", callData)
         }
+        // Bring app to foreground
+        CallEngine.bringAppToForeground(context)
     }
 
     override fun onReject() {
@@ -37,6 +39,10 @@ class MyConnection(
                 ?.getNativeModule(CallManagerModule::class.java)
             module?.emitEvent("onCallRejected", callData)
         }
+        // Clean up
+        CallEngine.cancelIncomingCallUI(context)
+        CallEngine.stopForegroundService(context)
+        CallEngine.disconnectTelecomCall(context, "")
     }
 
     override fun onDisconnect() {
@@ -49,5 +55,9 @@ class MyConnection(
                 ?.getNativeModule(CallManagerModule::class.java)
             module?.emitEvent("onCallEnded", callData)
         }
+        // Clean up
+        CallEngine.cancelIncomingCallUI(context)
+        CallEngine.stopForegroundService(context)
+        CallEngine.disconnectTelecomCall(context, "")
     }
 }

package/android/src/main/java/com/qusaieilouti99/callmanager/MyConnectionService.kt

@@ -18,7 +18,6 @@ class MyConnectionService : ConnectionService() {
         request: ConnectionRequest
     ): Connection {
         Log.d(TAG, "onCreateIncomingConnection: ${request.extras}")
-
         val callData = request.extras?.getString(EXTRA_CALL_DATA) ?: ""
         val connection = MyConnection(applicationContext, callData)
         connection.setRinging()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qusaieilouti99/call-manager",
-  "version": "0.1.16",
+  "version": "0.1.17",
   "description": "call manager",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",

package/android/src/main/java/com/qusaieilouti99/callmanager/CallNativeHelper.kt

@@ -1,61 +0,0 @@
-package com.qusaieilouti99.callmanager
-
-import android.content.ComponentName
-import android.content.Context
-import android.os.Build
-import android.os.Bundle
-import android.telecom.PhoneAccount
-import android.telecom.PhoneAccountHandle
-import android.telecom.TelecomManager
-import android.util.Log
-
-object CallNativeHelper {
-    private const val TAG = "CallNativeHelper"
-    private const val PHONE_ACCOUNT_ID = "com.qusaieilouti99.callmanager.SELF_MANAGED"
-
-    fun reportIncomingCall(context: Context, callId: String, callData: String) {
-        Log.d(TAG, "reportIncomingCall called with callId=$callId, callData=$callData")
-        // Parse caller name from callData (or use a default)
-        val callerName = try {
-            val json = org.json.JSONObject(callData)
-            json.optString("name", "Unknown")
-        } catch (e: Exception) {
-            "Unknown"
-        }
-
-        // Show incoming call notification and play ringtone
-        CallNotificationHelper(context).showIncomingCallNotification(callId, callerName)
-
-        val telecomManager = context.getSystemService(Context.TELECOM_SERVICE) as TelecomManager
-
-        // Register self-managed PhoneAccount if not already registered
-        val phoneAccountHandle = PhoneAccountHandle(
-            ComponentName(context, MyConnectionService::class.java),
-            PHONE_ACCOUNT_ID
-        )
-        if (telecomManager.getPhoneAccount(phoneAccountHandle) == null) {
-            val phoneAccount = PhoneAccount.builder(phoneAccountHandle, "PingMe Call")
-                .setCapabilities(PhoneAccount.CAPABILITY_SELF_MANAGED)
-                .build()
-            telecomManager.registerPhoneAccount(phoneAccount)
-        }
-
-        // Prepare extras
-        val extras = Bundle()
-        extras.putString(MyConnectionService.EXTRA_CALL_DATA, callData)
-
-        // Report the call
-        try {
-            telecomManager.addNewIncomingCall(phoneAccountHandle, extras)
-            // Optionally, start foreground service for ongoing call
-            val intent = android.content.Intent(context, CallForegroundService::class.java)
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-                context.startForegroundService(intent)
-            } else {
-                context.startService(intent)
-            }
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to report incoming call: ${e.message}")
-        }
-    }
-}

package/android/src/main/java/com/qusaieilouti99/callmanager/CallNotificationHelper.kt

@@ -1,147 +0,0 @@
-package com.qusaieilouti99.callmanager
-
-import android.app.Notification
-import android.app.NotificationChannel
-import android.app.NotificationManager
-import android.app.PendingIntent
-import android.app.Person
-import android.content.Context
-import android.content.Intent
-import android.graphics.Color
-import android.media.AudioAttributes
-import android.media.RingtoneManager
-import android.os.Build
-import android.util.Log
-
-class CallNotificationHelper(private val context: Context) {
-
-    companion object {
-        const val CHANNEL_ID = "incoming_call_channel"
-        const val NOTIFICATION_ID = 2001
-    }
-
-    private var ringtone: android.media.Ringtone? = null
-
-    fun showIncomingCallNotification(callId: String, callerName: String) {
-        Log.d("CallNotificationHelper", "Showing incoming call notification for $callerName, callId=$callId")
-        createNotificationChannel()
-
-        // Intent for answer action
-        val answerIntent = Intent(context, CallNotificationActionReceiver::class.java).apply {
-            action = "com.qusaieilouti99.callmanager.ANSWER_CALL"
-            putExtra("callId", callId)
-        }
-        val answerPendingIntent = PendingIntent.getBroadcast(
-            context, 0, answerIntent, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
-        )
-
-        // Intent for decline action
-        val declineIntent = Intent(context, CallNotificationActionReceiver::class.java).apply {
-            action = "com.qusaieilouti99.callmanager.DECLINE_CALL"
-            putExtra("callId", callId)
-        }
-        val declinePendingIntent = PendingIntent.getBroadcast(
-            context, 1, declineIntent, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
-        )
-
-        // Full-screen intent to pop up the native call UI
-        val fullScreenIntent = Intent(context, CallActivity::class.java).apply {
-            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
-            putExtra("callId", callId)
-            putExtra("callerName", callerName)
-        }
-        val fullScreenPendingIntent = PendingIntent.getActivity(
-            context, 2, fullScreenIntent, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
-        )
-
-        val notification: Notification = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-            val person = Person.Builder()
-                .setName(callerName)
-                .setImportant(true)
-                .build()
-
-            Notification.Builder(context, CHANNEL_ID)
-                .setSmallIcon(android.R.drawable.sym_call_incoming) // <-- REQUIRED!
-                .setStyle(
-                    Notification.CallStyle.forIncomingCall(
-                        person,
-                        declinePendingIntent, // <-- Decline goes first!
-                        answerPendingIntent   // <-- Answer goes second!
-                    )
-                )
-                .setFullScreenIntent(fullScreenPendingIntent, true)
-                .setOngoing(true)
-                .setAutoCancel(false)
-                .build()
-        } else {
-            Notification.Builder(context, CHANNEL_ID)
-                .setSmallIcon(android.R.drawable.sym_call_incoming) // <-- REQUIRED!
-                .setContentTitle("Incoming Call")
-                .setContentText(callerName)
-                .setPriority(Notification.PRIORITY_HIGH)
-                .setCategory(Notification.CATEGORY_CALL)
-                .setFullScreenIntent(fullScreenPendingIntent, true)
-                .addAction(android.R.drawable.sym_action_call, "Answer", answerPendingIntent)
-                .addAction(android.R.drawable.ic_menu_close_clear_cancel, "Decline", declinePendingIntent)
-                .setOngoing(true)
-                .setAutoCancel(false)
-                .build()
-        }
-
-        val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-        notificationManager.notify(NOTIFICATION_ID, notification)
-
-        playRingtone()
-    }
-
-    fun cancelIncomingCallNotification() {
-        val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-        notificationManager.cancel(NOTIFICATION_ID)
-        stopRingtone()
-    }
-
-    private fun createNotificationChannel() {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            val channel = NotificationChannel(
-                CHANNEL_ID,
-                "Incoming Call Channel",
-                NotificationManager.IMPORTANCE_HIGH
-            )
-            channel.description = "Notifications for incoming calls"
-            channel.enableLights(true)
-            channel.lightColor = Color.GREEN
-            channel.enableVibration(true)
-            channel.setSound(
-                RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE),
-                AudioAttributes.Builder()
-                    .setUsage(AudioAttributes.USAGE_NOTIFICATION_RINGTONE)
-                    .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
-                    .build()
-            )
-            val manager = context.getSystemService(NotificationManager::class.java)
-            manager.createNotificationChannel(channel)
-        }
-    }
-
-    private fun playRingtone() {
-        try {
-            Log.d("CallNotificationHelper", "Playing ringtone")
-            val uri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE)
-            ringtone = RingtoneManager.getRingtone(context, uri)
-            ringtone?.audioAttributes = AudioAttributes.Builder()
-                .setUsage(AudioAttributes.USAGE_NOTIFICATION_RINGTONE)
-                .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
-                .build()
-            ringtone?.play()
-        } catch (e: Exception) {
-            Log.e("CallNotificationHelper", "Failed to play ringtone: ${e.message}")
-        }
-    }
-
-    fun stopRingtone() {
-        try {
-            ringtone?.stop()
-        } catch (_: Exception) {}
-        ringtone = null
-    }
-}