rns-nativecall 0.7.2 → 0.7.4

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

@@ -13,7 +13,6 @@ class AcceptCallActivity : Activity() {
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
 
-        // Ensure we show over the lockscreen
         window.addFlags(
             WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED or
             WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON or
@@ -23,6 +22,14 @@ class AcceptCallActivity : Activity() {
         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)
     }
 
@@ -35,30 +42,36 @@ class AcceptCallActivity : Activity() {
         val notificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
         uuid?.let { notificationManager.cancel(it.hashCode()) }
 
-        val dataMap = mutableMapOf<String, String>()
-        extras?.keySet()?.forEach { key ->
-            extras.get(key)?.let { dataMap[key] = it.toString() }
-        }
-
-        // 1. Set the data for JS (Cold start support)
-        CallModule.setPendingCallData("onCallAccepted_pending", dataMap)
-        
-        // 2. Fire event immediately if JS is alive
-        if (CallModule.isReady()) {
-            CallModule.sendEventToJS("onCallAccepted", dataMap)
-        }
-
-        // 3. Bring the Main App to the front
+        // ✅ 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?) {
-        val launchIntent = packageManager.getLaunchIntentForPackage(packageName)
-        launchIntent?.apply {
-            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
-            putExtras(extras ?: Bundle())
-            startActivity(this)
+        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)
+            }
         }
     }
 }

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

@@ -6,17 +6,112 @@ import android.app.PendingIntent
 import android.content.Context
 import android.content.Intent
 import android.os.Build
-import androidx.core.app.NotificationCompat
 import android.media.Ringtone
 import android.media.RingtoneManager
 import android.graphics.Color
 
+import androidx.core.app.Person
+import androidx.core.app.NotificationCompat
+
 object NativeCallManager {
 
     private var ringtone: Ringtone? = null
     const val channelId = "CALL_CHANNEL_ID"
 
-    fun handleIncomingPush(context: Context, data: Map<String, String>) {
+    // 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"
+    //     val notificationId = uuid.hashCode()
+
+    //     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)
+    //     }
+
+    //     val fullScreenPendingIntent = PendingIntent.getActivity(
+    //         context,
+    //         notificationId,
+    //         intentToActivity,
+    //         pendingFlags
+    //     )
+
+    //     val rejectIntent = Intent(context, CallActionReceiver::class.java).apply {
+    //         this.action = "ACTION_REJECT_$uuid"
+    //         this.putExtra("EXTRA_CALL_UUID", uuid)
+    //         data.forEach { (key, value) -> this.putExtra(key, value) }
+    //     }
+
+    //     val rejectPendingIntent = PendingIntent.getBroadcast(
+    //         context,
+    //         notificationId,
+    //         rejectIntent,
+    //         pendingFlags
+    //     )
+
+    //     val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+
+    //     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+    //         val channel = NotificationChannel(
+    //             channelId,
+    //             "Incoming Calls",
+    //             NotificationManager.IMPORTANCE_HIGH // NotificationManager.IMPORTANCE_HIGH
+    //         ).apply {
+    //             enableVibration(true)
+    //             vibrationPattern = longArrayOf(0, 500, 500, 500)
+    //             lightColor = Color.GREEN
+    //             setBypassDnd(true)
+    //             lockscreenVisibility = NotificationCompat.VISIBILITY_PUBLIC
+    //             setSound(null, null)
+    //         }
+    //         notificationManager.createNotificationChannel(channel)
+    //     }
+
+    //     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
+    //         .setOngoing(true)
+    //         .setAutoCancel(false)
+    //         .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
+    //         .setFullScreenIntent(fullScreenPendingIntent, true)
+    //         .setContentIntent(noOpIntent)
+    //         .addAction(0, "Answer", fullScreenPendingIntent)
+    //         .addAction(0, "Decline", rejectPendingIntent)
+
+    //     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
+    //         }
+    //         ringtone?.play()
+    //     } catch (e: Exception) {
+    //         e.printStackTrace()
+    //     }
+    // }
+
+ fun handleIncomingPush(context: Context, data: Map<String, String>) {
         val uuid = data["callUuid"] ?: return
         stopRingtone()
 
@@ -30,24 +125,15 @@ object NativeCallManager {
             PendingIntent.FLAG_UPDATE_CURRENT
         }
 
-        val noOpIntent = PendingIntent.getActivity(
-            context,
-            notificationId + 1,
-            Intent(), 
-            pendingFlags
-        )
-
+        // 1. Setup the Intents
         val intentToActivity = Intent(context, AcceptCallActivity::class.java).apply {
-            this.action = "ACTION_SHOW_UI_$uuid"
+            this.action = "ACTION_ANSWER_$uuid"
             data.forEach { (key, value) -> this.putExtra(key, value) }
             this.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
         }
 
         val fullScreenPendingIntent = PendingIntent.getActivity(
-            context,
-            notificationId,
-            intentToActivity,
-            pendingFlags
+            context, notificationId, intentToActivity, pendingFlags
         )
 
         val rejectIntent = Intent(context, CallActionReceiver::class.java).apply {
@@ -56,47 +142,55 @@ object NativeCallManager {
             data.forEach { (key, value) -> this.putExtra(key, value) }
         }
 
+        // Fix: Define the missing rejectPendingIntent
         val rejectPendingIntent = PendingIntent.getBroadcast(
-            context,
-            notificationId,
-            rejectIntent,
-            pendingFlags
+            context, notificationId, rejectIntent, pendingFlags
         )
 
+        // 2. Create the Person object for CallStyle
+        val caller = Person.Builder()
+            .setName(name)
+            .setImportant(true)
+            .build()
+
         val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
 
+        // 3. Setup Channel
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
             val channel = NotificationChannel(
                 channelId,
                 "Incoming Calls",
-                NotificationManager.IMPORTANCE_HIGH // NotificationManager.IMPORTANCE_HIGH
+                NotificationManager.IMPORTANCE_HIGH
             ).apply {
                 enableVibration(true)
                 vibrationPattern = longArrayOf(0, 500, 500, 500)
                 lightColor = Color.GREEN
                 setBypassDnd(true)
-                lockscreenVisibility = NotificationCompat.VISIBILITY_PUBLIC
                 setSound(null, null)
             }
             notificationManager.createNotificationChannel(channel)
         }
 
+        // 4. Build with CallStyle
         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, "Decline", rejectPendingIntent)
+            .setStyle(
+                NotificationCompat.CallStyle.forIncomingCall(
+                    caller,
+                    rejectPendingIntent, 
+                    fullScreenPendingIntent
+                )
+            )
 
         notificationManager.notify(notificationId, builder.build())
 
+        // 5. Start Ringtone
         try {
             val ringtoneUri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE)
             ringtone = RingtoneManager.getRingtone(context, ringtoneUri)
@@ -109,6 +203,7 @@ object NativeCallManager {
         }
     }
 
+
     fun stopRingtone() {
         try {
             ringtone?.let { if (it.isPlaying) it.stop() }
@@ -156,7 +251,6 @@ fun aborting(context: Context, uuid: String, name: String, callType: String) {
     notificationManager.notify(notificationId, builder.build())
 }
 
-
     fun dismissIncomingCall(context: Context, uuid: String?) {
         stopRingtone()
         val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "rns-nativecall",
-    "version": "0.7.2",
+    "version": "0.7.4",
     "description": "High-performance React Native module for handling native VoIP call UI on Android and iOS.",
     "main": "index.js",
     "types": "index.d.ts",