rns-nativecall 0.4.6 → 0.4.7

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

@@ -15,8 +15,6 @@ import com.google.firebase.messaging.FirebaseMessagingService
 import com.google.firebase.messaging.RemoteMessage
 import com.facebook.react.HeadlessJsTaskService
 
-import android.os.PowerManager
-
 class CallMessagingService : FirebaseMessagingService() {
 
     companion object {
@@ -41,36 +39,33 @@ class CallMessagingService : FirebaseMessagingService() {
         }
         
         if (isAppInForeground(context)) {
+            // When in foreground, we just tell JS to show the in-app UI
             CallModule.sendEventToJS("onCallReceived", data)
         } else {
-            // 1. Prepare Intent
-            val headlessIntent = Intent(context, CallHeadlessTask::class.java).apply {
-                putExtras(Bundle().apply {
-                    data.forEach { (k, v) -> putString(k, v) }
-                })
-            }
+            // 1. Show the Notification IMMEDIATELY
+            // Do not wait for HeadlessJS. Android requires immediate feedback for background starts.
+            NativeCallManager.handleIncomingPush(context, data)
 
-            // 2. Start Service correctly based on SDK
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-                context.startForegroundService(headlessIntent)
-            } else {
-                context.startService(headlessIntent)
-            }
-            
-            // 3. WakeLock
+            // 2. Start HeadlessJS Task to sync Javascript state (WebRTC initialization, etc.)
             try {
+                val headlessIntent = Intent(context, CallHeadlessTask::class.java).apply {
+                    putExtras(Bundle().apply {
+                        data.forEach { (k, v) -> putString(k, v) }
+                    })
+                }
+                
+                // Use a standard startService. If CallHeadlessTask is a HeadlessJsTaskService, 
+                // it handles its own foreground/background lifecycle.
+                context.startService(headlessIntent)
                 HeadlessJsTaskService.acquireWakeLockNow(context)
-            } catch (e: Exception) { e.printStackTrace() }
-
-            val powerManager = context.getSystemService(Context.POWER_SERVICE) as PowerManager
-val wakeLock = powerManager.newWakeLock(
-    PowerManager.FULL_WAKE_LOCK or PowerManager.ACQUIRE_CAUSES_WAKEUP or PowerManager.ON_AFTER_RELEASE, 
-    "NativeCall:IncomingCallWakeLock"
-)
-wakeLock.acquire(3000) // Wake screen for 3 seconds to show notification
+            } catch (e: Exception) { 
+                e.printStackTrace() 
+            }
 
-            // 4. Backup Timer
+            // 3. Backup Safety: Ensure if JS fails, the notification is eventually handled
             val showNotificationRunnable = Runnable {
+                // If the notification was somehow canceled or not showing, re-trigger
+                // (Usually not needed if handleIncomingPush is called above, but kept for your logic)
                 if (!isAppInForeground(context)) {
                     NativeCallManager.handleIncomingPush(context, data)
                 }

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

@@ -1,130 +1,140 @@
-package com.rnsnativecall
-
-import android.app.Notification
 import android.app.NotificationChannel
 import android.app.NotificationManager
 import android.app.PendingIntent
 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 androidx.core.app.NotificationCompat
+import android.media.Ringtone
+import android.media.RingtoneManager
+import android.graphics.Color
 import androidx.core.app.Person
-import android.graphics.drawable.Icon
+import androidx.core.app.NotificationCompat.CallStyle
 
 object NativeCallManager {
 
+    private var ringtone: Ringtone? = null
     const val CALL_CHANNEL_ID = "CALL_CHANNEL_ID"
 
     fun handleIncomingPush(context: Context, data: Map<String, String>) {
         val uuid = data["callUuid"] ?: return
-        val name = data["name"] ?: "Unknown Caller"
-        val handle = data["handle"] ?: ""
         stopRingtone()
-        val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        
+        val name = data["name"] ?: "Someone"
+        val callType = data["callType"] ?: "audio"
 
-        // 1. Create Channel with High Importance (Required for Heads Up)
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            val ringtoneUri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE)
-            val audioAttributes = AudioAttributes.Builder()
-                .setUsage(AudioAttributes.USAGE_NOTIFICATION_RINGTONE)
-                .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
-                .build()
-
-            val channel = NotificationChannel(CALL_CHANNEL_ID, "Incoming Calls", NotificationManager.IMPORTANCE_HIGH).apply {
-                setSound(ringtoneUri, audioAttributes)
-                enableVibration(true)
-                lockscreenVisibility = Notification.VISIBILITY_PUBLIC
-                setBypassDnd(true) // Optional: Break through Do Not Disturb
-            }
-            notificationManager.createNotificationChannel(channel)
+        // Use FLAG_IMMUTABLE for security unless you need to modify the intent in the system
+        val pendingFlags = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_MUTABLE
+        } else {
+            PendingIntent.FLAG_UPDATE_CURRENT
         }
 
-        // 2. Prepare Intents
-        val flags = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) 
-            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE 
-            else PendingIntent.FLAG_UPDATE_CURRENT
-
-        // A. Full Screen Intent (Triggers the Heads-up logic)
-        // We point this to AcceptCallActivity, which has showWhenLocked="false"
-        // Result: System tries to launch, hits the lock restriction, and falls back to showing the Notification Pill.
+        // 1. Full Screen Intent (Opens the UI when phone is locked or heads-up is clicked)
         val intentToActivity = Intent(context, AcceptCallActivity::class.java).apply {
-            action = "ACTION_SHOW_INCOMING_$uuid"
-            data.forEach { (k, v) -> putExtra(k, v) }
+            action = "ACTION_SHOW_UI_$uuid"
+            data.forEach { (key, value) -> putExtra(key, value) }
+            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
         }
-        val fullScreenPendingIntent = PendingIntent.getActivity(context, uuid.hashCode(), intentToActivity, flags)
+        val fullScreenPendingIntent = PendingIntent.getActivity(
+            context, uuid.hashCode(), intentToActivity, pendingFlags
+        )
 
-        // B. Answer Intent
-        // We point this to MainActivity (or a BroadcastReceiver that launches MainActivity)
-        // MainActivity HAS showWhenLocked="true", so it WILL open over the lock screen when tapped.
-        val packageName = context.packageName
-        val launchIntent = context.packageManager.getLaunchIntentForPackage(packageName) ?: return
-        launchIntent.apply {
-             action = "ACTION_ANSWER_CALL"
-             putExtra("callUuid", uuid)
-             data.forEach { (k, v) -> putExtra(k, v) }
-             addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_SINGLE_TOP)
+        // 2. Reject Intent (Broadcast)
+        val rejectIntent = Intent(context, CallActionReceiver::class.java).apply {
+            action = "ACTION_REJECT_$uuid"
+            putExtra("EXTRA_CALL_UUID", uuid)
+            data.forEach { (key, value) -> putExtra(key, value) }
         }
-        val answerPendingIntent = PendingIntent.getActivity(context, uuid.hashCode() + 1, launchIntent, flags)
+        val rejectPendingIntent = PendingIntent.getBroadcast(
+            context, uuid.hashCode() + 1, rejectIntent, pendingFlags
+        )
 
-        // C. Decline Intent
-        val rejectIntent = Intent(context, CallActionReceiver::class.java).apply {
-            action = "ACTION_REJECT_CALL"
-            putExtra("callUuid", uuid)
+        // 3. Answer Intent (Broadcast - Process the logic before opening UI)
+        val answerIntent = Intent(context, CallActionReceiver::class.java).apply {
+            action = "ACTION_ANSWER_$uuid"
+            putExtra("EXTRA_CALL_UUID", uuid)
+            data.forEach { (key, value) -> putExtra(key, value) }
+        }
+        val answerPendingIntent = PendingIntent.getBroadcast(
+            context, uuid.hashCode() + 2, answerIntent, pendingFlags
+        )
+
+        val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+
+        // Create Channel for Android O+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val channel = NotificationChannel(
+                CALL_CHANNEL_ID, 
+                "Incoming Call", 
+                NotificationManager.IMPORTANCE_HIGH
+            ).apply {
+                setBypassDnd(true)
+                lockscreenVisibility = NotificationCompat.VISIBILITY_PUBLIC
+                enableVibration(true) 
+                setSound(null, null) // Sound is handled manually via RingtoneManager
+            }
+            notificationManager.createNotificationChannel(channel)
         }
-        val rejectPendingIntent = PendingIntent.getBroadcast(context, uuid.hashCode() + 2, rejectIntent, flags)
 
-        // 3. Build Notification using CallStyle (Android 12+) or Custom (Older)
-        val person = Person.Builder()
+        // 4. Build the "Person" (Required for CallStyle)
+        val caller = Person.Builder()
             .setName(name)
-            .setKey(uuid)
+            .setImportant(true)
             .build()
 
+        // 5. Create the Notification with CallStyle
         val builder = NotificationCompat.Builder(context, CALL_CHANNEL_ID)
-            .setSmallIcon(context.applicationInfo.icon)
+            .setSmallIcon(context.applicationInfo.icon) // Ensure this is a silhouette icon
+            .setContentTitle("Incoming $callType call")
+            .setContentText(name)
             .setPriority(NotificationCompat.PRIORITY_MAX)
             .setCategory(NotificationCompat.CATEGORY_CALL)
-            .setAutoCancel(false)
             .setOngoing(true)
-            .setColor(Color.parseColor("#00C853"))
-            // Crucial: Set the full screen intent, but let the Manifest block the auto-launch
-            .setFullScreenIntent(fullScreenPendingIntent, true) 
-
-        // Apply Native Call Style (The "Pill")
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-            builder.setStyle(
-                NotificationCompat.CallStyle.forIncomingCall(person, rejectPendingIntent, answerPendingIntent)
+            .setAutoCancel(false)
+            .setFullScreenIntent(fullScreenPendingIntent, true)
+            .setColor(Color.parseColor("#28a745"))
+            .setColorized(true)
+            .setStyle(
+                NotificationCompat.CallStyle.forIncomingCall(
+                    caller,
+                    rejectPendingIntent,
+                    answerPendingIntent
+                )
             )
-        } else {
-            // Fallback for Android 10/11
-            builder.setContentTitle("Incoming Call")
-                   .setContentText(name)
-                   .addAction(android.R.drawable.ic_menu_call, "Answer", answerPendingIntent)
-                   .addAction(android.R.drawable.ic_menu_close_clear_cancel, "Decline", rejectPendingIntent)
-        }
 
         notificationManager.notify(uuid.hashCode(), builder.build())
+
+        // Start Ringtone
+        try {
+            val ringtoneUri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE)
+            ringtone = RingtoneManager.getRingtone(context, ringtoneUri)
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) ringtone?.isLooping = true
+            ringtone?.play()
+        } catch (e: Exception) { 
+            e.printStackTrace() 
+        }
+    }
+
+    fun stopRingtone() {
+        try {
+            ringtone?.let {
+                if (it.isPlaying) {
+                    it.stop()
+                }
+            }
+            ringtone = null
+        } catch (e: Exception) {
+            e.printStackTrace()
+            ringtone = null
+        }
     }
-fun stopRingtone() {
-    try {
-        // Use the safe call operator ?. to only run if ringtone isn't null
-        ringtone?.let {
-            if (it.isPlaying) {
-                it.stop()
-            }
-        }
-        // Always null it out after stopping
-        ringtone = null
-    } catch (e: Exception) {
-        // Prevent the app from crashing if the system Ringtone service is acting up
-        e.printStackTrace()
-        ringtone = null
-    }
+
     fun dismissIncomingCall(context: Context, uuid: String?) {
-         stopRingtone()
-         val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-         if (uuid != null) notificationManager.cancel(uuid.hashCode())
+        stopRingtone()
+        val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        if (uuid != null) {
+            notificationManager.cancel(uuid.hashCode())
+        }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "rns-nativecall",
-    "version": "0.4.6",
+    "version": "0.4.7",
     "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",