rns-nativecall 0.2.3 → 0.2.6

package/android/build.gradle

@@ -1,34 +1,22 @@
-buildscript {
-    // Check if kotlin version is defined in the root project, otherwise default
-    ext.kotlin_version = project.hasProperty('kotlinVersion') ? project.kotlinVersion : '1.8.10'
-
-    repositories {
-        google()
-        mavenCentral()
-    }
-
-    dependencies {
-        classpath "com.android.tools.build:gradle:7.4.2"
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-    }
-}
-
-apply plugin: 'com.android.library'
-apply plugin: 'kotlin-android'
-
-// Helper function to find the react-native node_module
-def safeExtGet(prop, fallback) {
-    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
-}
-
 android {
-    // This MUST match your package name in your .kt files
+    // 1. MATCH NAMESPACE: Ensure this matches the package in your .kt files
     namespace "com.rnsnativecall"
+    
+    // 2. TARGET SDK: Android 13 (API 33) is the standard for modern RN apps
+    // This allows you to use the POST_NOTIFICATIONS permission needed for Android 13+
     compileSdkVersion safeExtGet('compileSdkVersion', 33)
 
     defaultConfig {
         minSdkVersion safeExtGet('minSdkVersion', 21)
         targetSdkVersion safeExtGet('targetSdkVersion', 33)
+        
+        // Ensure your library can handle vector icons if you use them in notifications
+        vectorDrawables.useSupportLibrary = true
+    }
+
+    // 3. KOTLIN OPTIONS: Essential for smooth bridge communication
+    kotlinOptions {
+        jvmTarget = '1.8'
     }
 
     lintOptions {
@@ -36,27 +24,20 @@ android {
     }
 }
 
-repositories {
-    mavenCentral()
-    google()
-}
-
 dependencies {
-    // Essential for React Native Native Modules
     implementation "com.facebook.react:react-native:+" 
-    
-    // Kotlin Standard Library
     implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
     
-    // Firebase for FCM
+    // Firebase - Use a stable version that supports Android 13+
     implementation "com.google.firebase:firebase-messaging:23.4.0"
 
-    // UI & Design (Crucial for the "Pill" Activity and Notifications)
-    implementation "com.google.android.material:material:1.9.0"
+    // UI & Design
     implementation "androidx.appcompat:appcompat:1.6.1"
-    implementation "androidx.core:core-ktx:1.10.1"
+    implementation "androidx.core:core-ktx:1.10.1" // Required for NotificationCompat
+    implementation "com.google.android.material:material:1.9.0"
 
-    // Image Loading (To load the profile picture URL)
+    // 4. Glide for Profile Pictures
+    // If you plan to show the caller's face in the notification
     implementation "com.github.bumptech.glide:glide:4.15.1"
     annotationProcessor "com.github.bumptech.glide:compiler:4.15.1"
 }

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

@@ -10,13 +10,12 @@ class AcceptCallActivity : Activity() {
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         NativeCallManager.stopRingtone()
+
         // 1. CLEAR THE NOTIFICATION
-        // Use the same ID (101) used in NativeCallManager
         val notificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
         notificationManager.cancel(101)
 
         // 2. EXTRACT DATA SAFELY
-        // We iterate through all extras and convert them to Strings for the JS Map
         val dataMap = mutableMapOf<String, String>()
         val extras = intent.extras
         extras?.keySet()?.forEach { key ->
@@ -26,29 +25,26 @@ class AcceptCallActivity : Activity() {
             }
         }
 
-        // 3. EMIT EVENT TO REACT NATIVE
-        // This handles the case where the app is already in the background/foreground
+        // --- THE COLD START FIX ---
+        // 3. STORE DATA FOR JS POLLING
+        // We save this in a static variable inside CallModule so getInitialCallData() can find it
+        CallModule.setPendingCallData(dataMap)
+
+        // 4. EMIT EVENT TO REACT NATIVE
+        // This works if the app is already running
         CallModule.sendEventToJS("onCallAccepted", dataMap)
 
-        // 4. LAUNCH OR BRING MAIN APP TO FOREGROUND
+        // 5. LAUNCH OR BRING MAIN APP TO FOREGROUND
         val launchIntent = packageManager.getLaunchIntentForPackage(packageName)
         if (launchIntent != null) {
             launchIntent.apply {
-                // FLAG_ACTIVITY_SINGLE_TOP: Updates the app if it's already open
-                // FLAG_ACTIVITY_NEW_TASK: Required when starting from a non-activity context
                 addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
-                
-                // Copy all call data to the launch intent
                 putExtras(extras ?: Bundle())
-                
-                // Helper flag for your React Native logic
                 putExtra("navigatingToCall", true)
             }
             startActivity(launchIntent)
         }
 
-        // 5. FINISH TRAMPOLINE
-        // This ensures this invisible activity doesn't stay in the "Recent Apps" list
         finish()
     }
 }

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

@@ -16,29 +16,33 @@ class CallActionReceiver : BroadcastReceiver() {
         notificationManager.cancel(101)
 
         if (intent.action == "ACTION_ACCEPT") {
-            NativeCallManager.stopRingtone()
             // 2. Prepare the data for React Native
             val dataMap = mutableMapOf<String, String>()
             intent.extras?.keySet()?.forEach { key ->
-                intent.getStringExtra(key)?.let { dataMap[key] = it }
+                // Using get(key).toString() is safer than getString(key) 
+                // because some extras might be Ints or Booleans
+                intent.extras?.get(key)?.let { dataMap[key] = it.toString() }
             }
 
-            // 3. Send the event to JS if the app is already running in background
+            // --- THE COLD START FIX ---
+            // Store data in the "Holding Gate" inside CallModule
+            CallModule.setPendingCallData(dataMap)
+
+            // 3. Send event (works if app is already active)
             CallModule.sendEventToJS("onCallAccepted", dataMap)
 
             // 4. Bring the app to foreground
             val launchIntent = context.packageManager.getLaunchIntentForPackage(context.packageName)
             launchIntent?.apply {
                 addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
-                // Forward the extras so the App can read them on startup/resume
                 putExtras(intent.extras ?: Bundle())
                 putExtra("navigatingToCall", true)
             }
             context.startActivity(launchIntent)
-        } else {
-            NativeCallManager.stopRingtone()
+            
+        } else if (intent.action == "ACTION_REJECT") {
             // Logic for Reject
-            CallModule.sendEventToJS("onCallRejected", mapOf("callUUID" to uuid))
+            CallModule.sendEventToJS("onCallRejected", mapOf("callUuid" to (uuid ?: "")))
         }
     }
 }

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

@@ -8,27 +8,19 @@ import com.google.firebase.messaging.RemoteMessage
 class CallMessagingService : FirebaseMessagingService() {
 
     override fun onMessageReceived(remoteMessage: RemoteMessage) {
-        if (isAppInForeground(applicationContext)) {
-            // 1. App is OPEN: Don't show the system pill.
-            // Just send the data to your React Native listeners.
-            CallModule.sendEventToJS("onCallReceived", remoteMessage.data)
-        } else {
-            // 2. App is CLOSED/BACKGROUND: Show the sticky system pill.
-            NativeCallManager.handleIncomingPush(applicationContext, remoteMessage.data)
-        }
-    }
-
-    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
+        val data = remoteMessage.data
         
-        for (appProcess in appProcesses) {
-            if (appProcess.importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND && 
-                appProcess.processName == packageName) {
-                return true
-            }
+        // Ensure this is actually a call offer before proceeding
+        if (data["type"] == "offer" || data.containsKey("callUuid")) {
+            
+            // ALWAYS trigger the native logic. 
+            // The NativeCallManager should decide if it needs to show a Notification 
+            // or just play a sound. This ensures the "Ringtone" starts natively 
+            // which is more reliable than JS audio.
+            NativeCallManager.handleIncomingPush(applicationContext, data)
+            
+            // Still notify JS so it can update the UI or pre-load the call screen
+            CallModule.sendEventToJS("onCallReceived", data)
         }
-        return false
     }
 }

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

@@ -4,8 +4,6 @@ import android.app.NotificationManager
 import android.content.ComponentName
 import android.content.Context
 import android.content.Intent
-import android.net.Uri
-import android.os.Bundle
 import android.telecom.DisconnectCause
 import android.telecom.PhoneAccount
 import android.telecom.PhoneAccountHandle
@@ -23,28 +21,21 @@ class CallModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
 
     override fun getName() = "CallModule"
 
-    private fun getPhoneAccountHandle(): PhoneAccountHandle {
-        val componentName = ComponentName(reactApplicationContext, MyConnectionService::class.java)
-        return PhoneAccountHandle(componentName, "${reactApplicationContext.packageName}.voip")
-    }
-
-    private fun registerPhoneAccount() {
-        val telecomManager = reactApplicationContext.getSystemService(Context.TELECOM_SERVICE) as TelecomManager
-        val phoneAccountHandle = getPhoneAccountHandle()
-        val appName = reactApplicationContext.applicationInfo.loadLabel(reactApplicationContext.packageManager).toString()
-
-        val capabilities = PhoneAccount.CAPABILITY_VIDEO_CALLING or
-                PhoneAccount.CAPABILITY_SUPPORTS_VIDEO_CALLING or
-                PhoneAccount.CAPABILITY_SELF_MANAGED
+    // ... getPhoneAccountHandle and registerPhoneAccount remain the same ...
 
-        val phoneAccount = PhoneAccount.builder(phoneAccountHandle, appName)
-            .setCapabilities(capabilities)
-            .setShortDescription(appName)
-            .addSupportedUriScheme("sip")
-            .addSupportedUriScheme("tel")
-            .build()
-
-        telecomManager.registerPhoneAccount(phoneAccount)
+    @ReactMethod
+    fun getInitialCallData(promise: Promise) {
+        // Convert our stored simple Map into a WritableMap for JS
+        val data = pendingCallDataMap?.let { map ->
+            val writableMap = Arguments.createMap()
+            map.forEach { (key, value) ->
+                writableMap.putString(key, value)
+            }
+            writableMap
+        }
+        
+        promise.resolve(data)
+        pendingCallDataMap = null // Clear after consumption
     }
 
     @ReactMethod
@@ -65,6 +56,8 @@ class CallModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
     @ReactMethod
     fun endNativeCall(uuid: String) {
         NativeCallManager.stopRingtone()
+        pendingCallDataMap = null // Clear any pending data
+        
         val notificationManager = reactApplicationContext.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
         notificationManager.cancel(101)
 
@@ -76,45 +69,23 @@ class CallModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
         }
     }
 
-    @ReactMethod
-    fun checkTelecomPermissions(promise: Promise) {
-        val telecomManager = reactApplicationContext.getSystemService(Context.TELECOM_SERVICE) as TelecomManager
-        val phoneAccountHandle = getPhoneAccountHandle()
-        val appName = reactApplicationContext.applicationInfo.loadLabel(reactApplicationContext.packageManager).toString()
-
-        val account = telecomManager.getPhoneAccount(phoneAccountHandle)
-        if (account != null && account.isEnabled) {
-            promise.resolve(true)
-        } else {
-            try {
-                Toast.makeText(reactApplicationContext, "Tap 'Active calling accounts' and then enable $appName", Toast.LENGTH_LONG).show()
-                val intent = Intent(TelecomManager.ACTION_CHANGE_PHONE_ACCOUNTS)
-                intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-                reactApplicationContext.startActivity(intent)
-                promise.resolve(false)
-            } catch (e: Exception) {
-                promise.reject("PERMISSION_ERROR", e.message)
-            }
-        }
-    }
-
-    @ReactMethod
-    fun getInitialCallData(promise: Promise) {
-        promise.resolve(pendingCallData)
-        pendingCallData = null // Clear after consumption
-    }
-
-    @ReactMethod fun addListener(eventName: String) {}
-    @ReactMethod fun removeListeners(count: Int) {}
+    // ... checkTelecomPermissions remains the same ...
 
     companion object {
         private var instance: CallModule? = null
-        private var pendingCallData: WritableMap? = null
+        // Use a standard Map to store data so we don't depend on React Context being alive
+        private var pendingCallDataMap: Map<String, String>? = null
+
+        @JvmStatic
+        fun setPendingCallData(data: Map<String, String>) {
+            pendingCallDataMap = data
+        }
 
         @JvmStatic
         fun sendEventToJS(eventName: String, params: Any?) {
             val reactContext = instance?.reactApplicationContext
 
+            // Convert params to WritableMap
             val bridgeData = when (params) {
                 is Map<*, *> -> {
                     val map = Arguments.createMap()
@@ -123,9 +94,6 @@ class CallModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                     }
                     map
                 }
-                is String -> {
-                    Arguments.createMap().apply { putString("callUuid", params) }
-                }
                 else -> null
             }
 
@@ -133,11 +101,9 @@ class CallModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
                 reactContext
                     .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
                     ?.emit(eventName, bridgeData)
-            } else {
-                // If app is dead/cold-starting, cache the accept event
-                if (eventName == "onCallAccepted") {
-                    pendingCallData = bridgeData
-                }
+            } else if (eventName == "onCallAccepted" && params is Map<*, *>) {
+                // FALLBACK: Store data for polling if JS isn't ready
+                setPendingCallData(params as Map<String, String>)
             }
         }
     }

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

@@ -1,38 +1,34 @@
 package com.rnsnativecall
 
+import android.app.*
 import android.content.Context
 import android.content.Intent
 import android.media.AudioAttributes
 import android.media.MediaPlayer
 import android.media.RingtoneManager
-import android.telecom.Connection
-import android.telecom.DisconnectCause
-
-class MyCallConnection(
-    private val context: Context,
-    private val callUUID: String?,
-    private val playRing: Boolean,
-    private val allData: Map<String, String>,
-    private val onAcceptCallback: (Map<String, String>) -> Unit,
-    private val onRejectCallback: (Map<String, String>) -> Unit
-) : Connection() {
+import android.os.Build
+import androidx.core.app.NotificationCompat
 
+object NativeCallManager {
     private var mediaPlayer: MediaPlayer? = null
+    private const val CHANNEL_ID = "incoming_calls"
+    private const val NOTIFICATION_ID = 101
 
-    init {
-        connectionProperties = PROPERTY_SELF_MANAGED
-        audioModeIsVoip = true
-        if (playRing) startRingtone()
+    fun handleIncomingPush(context: Context, data: Map<String, String>) {
+        startRingtone(context)
+        showIncomingCallNotification(context, data)
     }
 
-    private fun startRingtone() {
+    private fun startRingtone(context: Context) {
+        if (mediaPlayer != null) return
         try {
             val uri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE)
             mediaPlayer = MediaPlayer().apply {
                 setDataSource(context, uri)
                 setAudioAttributes(AudioAttributes.Builder()
                     .setUsage(AudioAttributes.USAGE_NOTIFICATION_RINGTONE)
-                    .setContentType(AudioAttributes.CONTENT_TYPE_MUSIC).build())
+                    .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
+                    .build())
                 isLooping = true
                 prepare()
                 start()
@@ -40,46 +36,58 @@ class MyCallConnection(
         } catch (e: Exception) { e.printStackTrace() }
     }
 
-    private fun stopRingtone() {
+    fun stopRingtone() {
         mediaPlayer?.stop()
         mediaPlayer?.release()
         mediaPlayer = null
     }
 
-    private fun cleanUp() {
-        stopRingtone()
-        callUUID?.let { MyConnectionService.removeConnection(it) }
-    }
+    private fun showIncomingCallNotification(context: Context, data: Map<String, String>) {
+        val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
 
-    override fun onAnswer() {
-        stopRingtone()
-        val launchIntent = context.packageManager.getLaunchIntentForPackage(context.packageName)
-        launchIntent?.apply {
-            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
-            context.startActivity(this)
+        // Create Channel for Android O+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val channel = NotificationChannel(CHANNEL_ID, "Incoming Calls", NotificationManager.IMPORTANCE_HIGH).apply {
+                lockscreenVisibility = Notification.VISIBILITY_PUBLIC
+                enableVibration(true)
+                setSound(null, null) // We handle sound manually via MediaPlayer
+            }
+            notificationManager.createNotificationChannel(channel)
         }
 
-        onAcceptCallback(allData)
+        // 1. Full Screen Intent (To wake up the screen)
+        val fullScreenIntent = Intent(context, AcceptCallActivity::class.java).apply {
+            data.forEach { (k, v) -> putExtra(k, v) }
+            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_NO_USER_ACTION)
+        }
+        val fullScreenPendingIntent = PendingIntent.getActivity(context, 0, fullScreenIntent, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE)
 
-        // IMPORTANT: KEEP THIS AS IT IS
-        setDisconnected(DisconnectCause(DisconnectCause.CANCELED))
-        cleanUp()
-        destroy()
-    }
+        // 2. Answer Action
+        val answerIntent = Intent(context, CallActionReceiver::class.java).apply {
+            action = "ACTION_ACCEPT"
+            data.forEach { (k, v) -> putExtra(k, v) }
+        }
+        val answerPendingIntent = PendingIntent.getBroadcast(context, 1, answerIntent, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE)
 
-    override fun onReject() {
-        stopRingtone()
-        setDisconnected(DisconnectCause(DisconnectCause.REJECTED))
-        cleanUp()
-        destroy()
-        onRejectCallback(allData)
-    }
+        // 3. Reject Action
+        val rejectIntent = Intent(context, CallActionReceiver::class.java).apply {
+            action = "ACTION_REJECT"
+            data.forEach { (k, v) -> putExtra(k, v) }
+        }
+        val rejectPendingIntent = PendingIntent.getBroadcast(context, 2, rejectIntent, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE)
+
+        val builder = NotificationCompat.Builder(context, CHANNEL_ID)
+            .setSmallIcon(context.applicationInfo.icon)
+            .setContentTitle("Incoming Call")
+            .setContentText(data["name"] ?: "Unknown Caller")
+            .setPriority(NotificationCompat.PRIORITY_MAX)
+            .setCategory(NotificationCompat.CATEGORY_CALL)
+            .setAutoCancel(true)
+            .setOngoing(true)
+            .setFullScreenIntent(fullScreenPendingIntent, true)
+            .addAction(0, "Answer", answerPendingIntent)
+            .addAction(0, "Decline", rejectPendingIntent)
 
-    override fun onDisconnect() {
-        stopRingtone()
-        setDisconnected(DisconnectCause(DisconnectCause.LOCAL))
-        cleanUp()
-        destroy()
-        onRejectCallback(allData)
+        notificationManager.notify(NOTIFICATION_ID, builder.build())
     }
 }

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

@@ -1,61 +1,101 @@
 package com.rnsnativecall
 
-import android.net.Uri
-import android.telecom.Connection
-import android.telecom.ConnectionRequest
-import android.telecom.ConnectionService
-import android.telecom.PhoneAccountHandle
-import android.telecom.TelecomManager
-import java.util.concurrent.ConcurrentHashMap
-
-class MyConnectionService : ConnectionService() {
-
-    companion object {
-        private val activeConnections = ConcurrentHashMap<String, MyCallConnection>()
-        fun getConnection(uuid: String) = activeConnections[uuid]
-        fun addConnection(uuid: String, connection: MyCallConnection) { activeConnections[uuid] = connection }
-        fun removeConnection(uuid: String) { activeConnections.remove(uuid) }
+import android.app.*
+import android.content.Context
+import android.content.Intent
+import android.media.AudioAttributes
+import android.media.MediaPlayer
+import android.media.RingtoneManager
+import android.os.Build
+import androidx.core.app.NotificationCompat
+
+object NativeCallManager {
+    private var mediaPlayer: MediaPlayer? = null
+    private const val CHANNEL_ID = "incoming_calls"
+    private const val NOTIFICATION_ID = 101
+
+    fun handleIncomingPush(context: Context, data: Map<String, String>) {
+        startRingtone(context)
+        showNotification(context, data)
     }
 
-    override fun onCreateIncomingConnection(
-        connectionManagerPhoneAccount: PhoneAccountHandle?,
-        request: ConnectionRequest?
-    ): Connection {
-        val extras = request?.extras
-        val callUUID = extras?.getString("EXTRA_CALL_UUID")
-        val playRing = extras?.getBoolean("EXTRA_PLAY_RING", true) ?: true
-        
-        // Convert Bundle to Map to send to JS
-        val extrasMap = mutableMapOf<String, String>()
-        extras?.keySet()?.forEach { key ->
-            val value = extras.get(key)
-            if (value is String) extrasMap[key] = value
-        }
+    private fun startRingtone(context: Context) {
+        if (mediaPlayer != null) return
+        try {
+            val uri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE)
+            mediaPlayer = MediaPlayer().apply {
+                setDataSource(context, uri)
+                setAudioAttributes(AudioAttributes.Builder()
+                    .setUsage(AudioAttributes.USAGE_NOTIFICATION_RINGTONE)
+                    .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
+                    .build())
+                isLooping = true
+                prepare()
+                start()
+            }
+        } catch (e: Exception) { e.printStackTrace() }
+    }
 
-        val actualPersonName = extras?.getString("EXTRA_CALLER_NAME") ?: "Someone"
-        val appLabel = extras?.getString(TelecomManager.EXTRA_CALL_SUBJECT) ?: "Incoming Call"
+    fun stopRingtone() {
+        mediaPlayer?.stop()
+        mediaPlayer?.release()
+        mediaPlayer = null
+    }
+
+    private fun showNotification(context: Context, data: Map<String, String>) {
+        val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
 
-        val connection = MyCallConnection(
-            context = applicationContext,
-            callUUID = callUUID,
-            playRing = playRing,
-            allData = extrasMap,
-            onAcceptCallback = { dataMap -> CallModule.sendEventToJS("onCallAccepted", dataMap) },
-            onRejectCallback = { dataMap -> CallModule.sendEventToJS("onCallRejected", dataMap) }
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val channel = NotificationChannel(CHANNEL_ID, "Calls", NotificationManager.IMPORTANCE_HIGH).apply {
+                description = "Incoming call notifications"
+                setSound(null, null) 
+                enableVibration(true)
+            }
+            notificationManager.createNotificationChannel(channel)
+        }
+
+        // 1. Full Screen Intent (Wakes up screen & goes to AcceptCallActivity)
+        val fullScreenIntent = Intent(context, AcceptCallActivity::class.java).apply {
+            data.forEach { (k, v) -> putExtra(k, v) }
+            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+        }
+        val fullScreenPendingIntent = PendingIntent.getActivity(
+            context, 0, fullScreenIntent, 
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
         )
 
-        connection.setCallerDisplayName(actualPersonName, TelecomManager.PRESENTATION_ALLOWED)
-        val labelUri = Uri.fromParts("tel", appLabel, null)
-        connection.setAddress(labelUri, TelecomManager.PRESENTATION_ALLOWED)
-        
-        connection.setInitializing()
-        connection.setRinging()
+        // 2. Answer Button
+        val answerIntent = Intent(context, CallActionReceiver::class.java).apply {
+            action = "ACTION_ACCEPT"
+            data.forEach { (k, v) -> putExtra(k, v) }
+        }
+        val answerPendingIntent = PendingIntent.getBroadcast(
+            context, 1, answerIntent, 
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+        )
 
-        callUUID?.let {
-            addConnection(it, connection)
-            CallModule.sendEventToJS("onCallDisplayed", extrasMap)
+        // 3. Reject Button
+        val rejectIntent = Intent(context, CallActionReceiver::class.java).apply {
+            action = "ACTION_REJECT"
+            data.forEach { (k, v) -> putExtra(k, v) }
         }
+        val rejectPendingIntent = PendingIntent.getBroadcast(
+            context, 2, rejectIntent, 
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+        )
+
+        val builder = NotificationCompat.Builder(context, CHANNEL_ID)
+            .setSmallIcon(android.R.drawable.ic_menu_call) // Replace with your app icon
+            .setContentTitle("Incoming Call")
+            .setContentText(data["name"] ?: "Raiidr User")
+            .setPriority(NotificationCompat.PRIORITY_MAX)
+            .setCategory(NotificationCompat.CATEGORY_CALL)
+            .setFullScreenIntent(fullScreenPendingIntent, true)
+            .setOngoing(true)
+            .setAutoCancel(true)
+            .addAction(0, "Answer", answerPendingIntent)
+            .addAction(0, "Decline", rejectPendingIntent)
 
-        return connection
+        notificationManager.notify(NOTIFICATION_ID, builder.build())
     }
 }

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

@@ -9,62 +9,57 @@ import android.os.Build
 import androidx.core.app.NotificationCompat
 import android.media.Ringtone
 import android.media.RingtoneManager
+import android.graphics.Color
 
 object NativeCallManager {
 
-private var ringtone: Ringtone? = null
+    private var ringtone: Ringtone? = null
+    private const val NOTIFICATION_ID = 101
 
     fun handleIncomingPush(context: Context, data: Map<String, String>) {
         val uuid = data["callUuid"] ?: return
         stopRingtone()
+        
         val name = data["name"] ?: "Incoming Call"
         val callType = data["callType"] ?: "audio"
 
-        // Use MUTABLE flag to ensure extras are properly passed on Android 12+
         val pendingFlags = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
             PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_MUTABLE
         } else {
             PendingIntent.FLAG_UPDATE_CURRENT
         }
 
-        // 1. DUMMY INTENT: Keeps the notification "Sticky" (Persistent)
-        val dummyIntent = PendingIntent.getActivity(
-            context, 
-            0, 
-            Intent(), 
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) PendingIntent.FLAG_IMMUTABLE else 0
-        )
-
-        // 2. Accept Action - Use unique action and requestCode
-        val acceptIntent = Intent(context, AcceptCallActivity::class.java).apply {
-            // Unique action string prevents intent caching issues
-            action = "ACTION_ACCEPT_$uuid" 
-            putExtra("EXTRA_CALL_UUID", uuid)
-            // Flatten the map into the intent extras
+        // 1. IMPROVED INTENT: Direct to AcceptCallActivity
+        // This is better than a dummy intent because it allows the OS to 
+        // launch your "Accept" logic immediately if the phone is locked.
+        val intentToActivity = Intent(context, AcceptCallActivity::class.java).apply {
+            action = "ACTION_SHOW_UI_$uuid"
             data.forEach { (key, value) -> putExtra(key, value) }
-            flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
+            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
         }
 
-        val acceptPendingIntent = PendingIntent.getActivity(
+        val fullScreenPendingIntent = PendingIntent.getActivity(
             context, 
-            uuid.hashCode(), // Unique RequestCode
-            acceptIntent, 
+            uuid.hashCode(), 
+            intentToActivity, 
             pendingFlags
         )
 
-        // 3. Reject Action - Use unique action and requestCode
+        // 2. Reject Action - Still goes to BroadcastReceiver
         val rejectIntent = Intent(context, CallActionReceiver::class.java).apply {
             action = "ACTION_REJECT_$uuid"
             putExtra("EXTRA_CALL_UUID", uuid)
+            // Pass all data so onReject can find the UUID
+            data.forEach { (key, value) -> putExtra(key, value) }
         }
         val rejectPendingIntent = PendingIntent.getBroadcast(
             context, 
-            uuid.hashCode() + 1, // Unique RequestCode
+            uuid.hashCode() + 1, 
             rejectIntent, 
             pendingFlags
         )
 
-        // 4. Setup Channel
+        // 3. Setup Channel with high priority
         val channelId = "CALL_CHANNEL_ID"
         val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
 
@@ -72,13 +67,17 @@ private var ringtone: Ringtone? = null
             val channel = NotificationChannel(channelId, "Incoming Calls", NotificationManager.IMPORTANCE_HIGH).apply {
                 description = "Shows incoming call notifications"
                 enableVibration(true)
+                vibrationPattern = longArrayOf(0, 500, 500, 500)
+                lightColor = Color.GREEN
                 setBypassDnd(true)
                 lockscreenVisibility = NotificationCompat.VISIBILITY_PUBLIC
+                // On Android O+, sound should be set on the channel
+                setSound(null, null) 
             }
             notificationManager.createNotificationChannel(channel)
         }
 
-        // 5. Build the Notification
+        // 4. Build the Notification
         val builder = NotificationCompat.Builder(context, channelId)
             .setSmallIcon(context.applicationInfo.icon)
             .setContentTitle("Incoming $callType call")
@@ -89,24 +88,31 @@ private var ringtone: Ringtone? = null
             .setAutoCancel(false)
             .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
             
-            // This hack keeps the Heads-Up "Pill" visible until action is taken
-            .setFullScreenIntent(dummyIntent, true) 
+            // This is the key for the "Pill" / Heads-up display
+            .setFullScreenIntent(fullScreenPendingIntent, true) 
             
-            .addAction(0, "Answer", acceptPendingIntent)
+            .addAction(0, "Answer", fullScreenPendingIntent) // Same intent as fullScreen
             .addAction(0, "Decline", rejectPendingIntent)
 
-        notificationManager.notify(101, builder.build())
+        notificationManager.notify(NOTIFICATION_ID, builder.build())
 
+        // 5. Ringtone with looping logic attempt
         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 // Android 9+ supports looping natively
+            }
             ringtone?.play()
         } catch (e: Exception) {
             e.printStackTrace()
         }
     }
+
     fun stopRingtone() {
-        ringtone?.stop()
+        if (ringtone?.isPlaying == true) {
+            ringtone?.stop()
+        }
         ringtone = null
     }
 }

package/index.d.ts

@@ -32,6 +32,8 @@ export interface CallHandlerType {
      */
     destroyNativeCallUI(uuid: string): void;
 
+
+    getInitialCallData(): Promise<CallData | null>;
     /**
      * Subscribe to call events. Automatically checks for cold-start data 
      * if the app was opened via the Answer button.

package/index.js

@@ -1,50 +1,16 @@
 import {
     NativeModules,
     NativeEventEmitter,
-    PermissionsAndroid,
-    Platform,
 } from 'react-native';
 
 const { CallModule } = NativeModules;
 
-if (!CallModule && __DEV__) {
-    console.warn(
-        "rns-nativecall: NativeModule.CallModule is undefined. " +
-        "Make sure you have rebuilt your native project."
-    );
-}
-
 const callEventEmitter = CallModule ? new NativeEventEmitter(CallModule) : null;
 
-const REQUIRED_PERMISSIONS = Platform.OS === 'android' ? [
-    PermissionsAndroid.PERMISSIONS.READ_PHONE_NUMBERS,
-    PermissionsAndroid.PERMISSIONS.CALL_PHONE,
-] : [];
-
-export async function ensureAndroidPermissions() {
-    if (Platform.OS !== 'android') return true;
-    try {
-        const result = await PermissionsAndroid.requestMultiple(REQUIRED_PERMISSIONS);
-        const isAccountEnabled = await CallModule.checkTelecomPermissions();
-        if (!isAccountEnabled) return false;
-        return Object.values(result).every(status => status === PermissionsAndroid.RESULTS.GRANTED);
-    } catch (e) {
-        return false;
-    }
-}
-
 export const CallHandler = {
     displayCall: async (uuid, name, callType = "audio") => {
         if (!CallModule) return false;
-        try {
-            return await CallModule.displayIncomingCall(
-                uuid.toLowerCase().trim(),
-                name,
-                callType
-            );
-        } catch (e) {
-            return false;
-        }
+        return await CallModule.displayIncomingCall(uuid.toLowerCase().trim(), name, callType);
     },
 
     destroyNativeCallUI: (uuid) => {
@@ -54,34 +20,30 @@ export const CallHandler = {
     },
 
     /**
-     * Subscribes to call events and checks for initial cold-start data.
+     * Manually check for cold-start data (App killed -> Answered).
+     * Call this in your App.js useEffect.
      */
+    getInitialCallData: async () => {
+        if (!CallModule?.getInitialCallData) return null;
+        return await CallModule.getInitialCallData();
+    },
+
     subscribe: (onAccept, onReject, onFailed) => {
         if (!callEventEmitter) return () => { };
 
         const subs = [
-            callEventEmitter.addListener('onCallAccepted', (data) => {
-                onAccept(data);
-            }),
-            callEventEmitter.addListener('onCallRejected', (data) => {
-                onReject(data);
-            }),
+            callEventEmitter.addListener('onCallAccepted', (data) => onAccept(data)),
+            callEventEmitter.addListener('onCallRejected', (data) => onReject(data)),
         ];
 
         if (onFailed) {
             subs.push(callEventEmitter.addListener('onCallFailed', onFailed));
         }
 
-        // --- COLD START LOGIC ---
-        // If the app was killed and opened via the Answer button, 
-        // the event might have fired before this listener was ready.
-        if (Platform.OS === 'android' && CallModule.getInitialCallData) {
-            CallModule.getInitialCallData().then((data) => {
-                if (data) {
-                    onAccept(data);
-                }
-            });
-        }
+        // Auto-check on subscribe for convenience
+        CallHandler.getInitialCallData().then((data) => {
+            if (data) onAccept(data);
+        });
 
         return () => subs.forEach(s => s.remove());
     }

package/ios/CallModule.m

@@ -1,4 +1,9 @@
 #import "CallModule.h"
+#import <AVFoundation/AVFoundation.h>
+
+@interface CallModule ()
+@property (nonatomic, strong) NSString *pendingCallUuid;
+@end
 
 @implementation CallModule
 
@@ -44,7 +49,6 @@ RCT_EXPORT_METHOD(displayIncomingCall:(NSString *)uuidString
     
     self.currentCallUUID = uuid;
 
-    // 1. CONFIGURE AUDIO SESSION (Pre-warm)
     AVAudioSession *session = [AVAudioSession sharedInstance];
     [session setCategory:AVAudioSessionCategoryPlayAndRecord 
                     mode:AVAudioSessionModeVoiceChat 
@@ -73,10 +77,16 @@ RCT_EXPORT_METHOD(endNativeCall:(NSString *)uuidString)
                           endedAtDate:[NSDate date] 
                                reason:CXCallEndedReasonRemoteEnded];
     self.currentCallUUID = nil;
+    self.pendingCallUuid = nil;
 }
 
 RCT_EXPORT_METHOD(getInitialCallData:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
-    resolve([NSNull null]);
+    if (self.pendingCallUuid) {
+        resolve(@{@"callUuid": self.pendingCallUuid});
+        self.pendingCallUuid = nil; 
+    } else {
+        resolve([NSNull null]);
+    }
 }
 
 RCT_EXPORT_METHOD(checkTelecomPermissions:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
@@ -86,26 +96,40 @@ RCT_EXPORT_METHOD(checkTelecomPermissions:(RCTPromiseResolveBlock)resolve reject
 // MARK: - CXProviderDelegate
 
 - (void)provider:(CXProvider *)provider performAnswerCallAction:(CXAnswerCallAction *)action {
-    // 1. Activate Audio Session
-    // This transition tells iOS the app is now the active audio owner, which triggers the foregrounding
-    [[AVAudioSession sharedInstance] setActive:YES error:nil];
-    
-    // 2. Fulfill the action
+    AVAudioSession *session = [AVAudioSession sharedInstance];
+    [session setCategory:AVAudioSessionCategoryPlayAndRecord 
+                    mode:AVAudioSessionModeVoiceChat 
+                 options:AVAudioSessionCategoryOptionAllowBluetooth | AVAudioSessionCategoryOptionDefaultToSpeaker 
+                   error:nil];
+    [session setActive:YES error:nil];
+
     [action fulfill];
-    
-    // 3. Notify JavaScript
-    // Once JS receives this, the navigationRef in App.js handles the UI transition
-    [self sendEventWithName:@"onCallAccepted" body:@{@"callUuid": [action.callUUID.UUIDString lowercaseString]}];
+
+    NSString *uuidStr = [action.callUUID.UUIDString lowercaseString];
+    self.pendingCallUuid = uuidStr;
+
+    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.5 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
+        // NUDGE: Force the window to become visible. 
+        // This helps transition from "Ghost Mode" to "Active UI" once the user unlocks.
+        dispatch_async(dispatch_get_main_queue(), ^{
+            [[[UIApplication sharedApplication] keyWindow] makeKeyAndVisible];
+        });
+        
+        [self sendEventWithName:@"onCallAccepted" body:@{@"callUuid": uuidStr}];
+    });
 }
 
 - (void)provider:(CXProvider *)provider performEndCallAction:(CXEndCallAction *)action {
     [action fulfill];
     self.currentCallUUID = nil;
+    self.pendingCallUuid = nil;
     [self sendEventWithName:@"onCallRejected" body:@{@"callUuid": [action.callUUID.UUIDString lowercaseString]}];
 }
 
 - (void)providerDidReset:(CXProvider *)provider {
     [[AVAudioSession sharedInstance] setActive:NO error:nil];
+    self.currentCallUUID = nil;
+    self.pendingCallUuid = nil;
 }
 
 @end

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "rns-nativecall",
-    "version": "0.2.3",
+    "version": "0.2.6",
     "description": "RNS nativecall component with native Android/iOS for handling native call ui, when app is not open or open.",
     "main": "index.js",
     "types": "index.d.ts",

package/withNativeCallVoip.js

@@ -34,15 +34,15 @@ function withAndroidConfig(config) {
         const manifest = config.modResults;
         const application = manifest.manifest.application[0];
 
-        // Permissions
+        // 1. Updated Permissions for Custom Notifications & Android 13/14
         const permissions = [
-            'android.permission.READ_PHONE_NUMBERS',
-            'android.permission.CALL_PHONE',
-            'android.permission.MANAGE_OWN_CALLS',
             'android.permission.USE_FULL_SCREEN_INTENT',
             'android.permission.VIBRATE',
             'android.permission.FOREGROUND_SERVICE',
-            'android.permission.FOREGROUND_SERVICE_PHONE_CALL'
+            'android.permission.FOREGROUND_SERVICE_PHONE_CALL', // Required for Android 14
+            'android.permission.POST_NOTIFICATIONS',            // Required for Android 13+
+            'android.permission.WAKE_LOCK',                     // Helps wake the screen
+            'android.permission.DISABLE_KEYGUARD'               // Allows showing over lockscreen
         ];
 
         manifest.manifest['uses-permission'] = manifest.manifest['uses-permission'] || [];
@@ -52,46 +52,47 @@ function withAndroidConfig(config) {
             }
         });
 
-        // Activities
+        // 2. AcceptCallActivity - The "Pill" UI handler
+        // Added showWhenLocked and turnScreenOn for the "Gate" logic
         application.activity = application.activity || [];
+        const acceptActivityName = 'com.rnsnativecall.AcceptCallActivity';
+
+        // Remove old entry if exists to avoid duplicates
+        application.activity = application.activity.filter(a => a.$['android:name'] !== acceptActivityName);
+
+        application.activity.push({
+            $: {
+                'android:name': acceptActivityName,
+                'android:theme': '@android:style/Theme.Translucent.NoTitleBar',
+                'android:excludeFromRecents': 'true',
+                'android:noHistory': 'true',
+                'android:exported': 'false',
+                'android:launchMode': 'singleInstance',
+                'android:showWhenLocked': 'true',  // CRUCIAL: Show over lockscreen
+                'android:turnScreenOn': 'true'     // CRUCIAL: Wake device
+            }
+        });
 
-        // Ensure MainActivity is singleTask
-        const mainActivity = application.activity.find(a => a.$['android:name'] === '.MainActivity');
-        if (mainActivity) {
-            mainActivity.$['android:launchMode'] = 'singleTask';
-        }
-
-        // AcceptCallActivity (The Trampoline - Must remain in Manifest)
-        if (!application.activity.some(a => a.$['android:name'] === 'com.rnsnativecall.AcceptCallActivity')) {
-            application.activity.push({
-                $: {
-                    'android:name': 'com.rnsnativecall.AcceptCallActivity',
-                    'android:theme': '@android:style/Theme.Translucent.NoTitleBar',
-                    'android:excludeFromRecents': 'true',
-                    'android:noHistory': 'true',
-                    'android:exported': 'false',
-                    'android:launchMode': 'singleInstance'
-                }
-            });
-        }
-
-        // Services
+        // 3. Updated Services
         application.service = application.service || [];
+        // Removed MyConnectionService as you are no longer using Telecom
         const services = [
-            { name: 'com.rnsnativecall.MyConnectionService', permission: 'android.permission.BIND_CONNECTION_SERVICE', action: 'android.telecom.ConnectionService' },
             { name: 'com.rnsnativecall.CallMessagingService', action: 'com.google.firebase.MESSAGING_EVENT' }
         ];
 
         services.forEach(svc => {
             if (!application.service.some(s => s.$['android:name'] === svc.name)) {
                 application.service.push({
-                    $: { 'android:name': svc.name, 'android:exported': 'true', 'android:permission': svc.permission },
+                    $: {
+                        'android:name': svc.name,
+                        'android:exported': 'false' // Firebase services should usually be false unless needed
+                    },
                     'intent-filter': [{ action: [{ $: { 'android:name': svc.action } }] }]
                 });
             }
         });
 
-        // Receivers
+        // 4. Receivers (Answer/Reject Buttons)
         application.receiver = application.receiver || [];
         if (!application.receiver.some(r => r.$['android:name'] === 'com.rnsnativecall.CallActionReceiver')) {
             application.receiver.push({