rns-nativecall 0.4.3 → 0.4.5

package/android/build.gradle

@@ -68,4 +68,7 @@ dependencies {
     // Glide for profile pictures
     implementation "com.github.bumptech.glide:glide:4.15.1"
     annotationProcessor "com.github.bumptech.glide:compiler:4.15.1"
+    
+    implementation "androidx.core:core-ktx:1.12.0"
+    implementation "androidx.appcompat:appcompat:1.6.1"
 }

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

@@ -25,8 +25,7 @@ class CallHeadlessTask : HeadlessJsTaskService() {
         }
 
         val notification: Notification = NotificationCompat.Builder(this, channelId)
-            .setContentTitle("Incoming Call")
-            .setSmallIcon(android.R.drawable.sym_call_incoming)
+            .setContentTitle("incoming...")
             .setPriority(NotificationCompat.PRIORITY_LOW)
             .build()
 

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

@@ -15,6 +15,8 @@ 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 {
@@ -60,6 +62,13 @@ class CallMessagingService : FirebaseMessagingService() {
                 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
+
             // 4. Backup Timer
             val showNotificationRunnable = Runnable {
                 if (!isAppInForeground(context)) {

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

@@ -1,114 +1,115 @@
 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
 
 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
-        stopRingtone()
-        
-        val name = data["name"] ?: "Incoming Call"
-        val callType = data["callType"] ?: "audio"
+        val name = data["name"] ?: "Unknown Caller"
+        val handle = data["handle"] ?: ""
 
-        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 notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+
+        // 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)
         }
 
+        // 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.
         val intentToActivity = Intent(context, AcceptCallActivity::class.java).apply {
-            action = "ACTION_SHOW_UI_$uuid"
-            data.forEach { (key, value) -> putExtra(key, value) }
-            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
+            action = "ACTION_SHOW_INCOMING_$uuid"
+            data.forEach { (k, v) -> putExtra(k, v) }
         }
+        val fullScreenPendingIntent = PendingIntent.getActivity(context, uuid.hashCode(), intentToActivity, flags)
+
+        // 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)
+        }
+        val answerPendingIntent = PendingIntent.getActivity(context, uuid.hashCode() + 1, launchIntent, flags)
 
-        val fullScreenPendingIntent = PendingIntent.getActivity(context, uuid.hashCode(), intentToActivity, pendingFlags)
-
+        // C. Decline Intent
         val rejectIntent = Intent(context, CallActionReceiver::class.java).apply {
-            action = "ACTION_REJECT_$uuid"
-            putExtra("EXTRA_CALL_UUID", uuid)
-            data.forEach { (key, value) -> putExtra(key, value) }
+            action = "ACTION_REJECT_CALL"
+            putExtra("callUuid", uuid)
         }
+        val rejectPendingIntent = PendingIntent.getBroadcast(context, uuid.hashCode() + 2, rejectIntent, flags)
 
-        
-        val rejectPendingIntent = PendingIntent.getBroadcast(context, uuid.hashCode() + 1, rejectIntent, pendingFlags)
-
-        val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-
-        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) //can be removed
-                setSound(null, null) 
-            }
-            notificationManager.createNotificationChannel(channel)
-        }
+        // 3. Build Notification using CallStyle (Android 12+) or Custom (Older)
+        val person = Person.Builder()
+            .setName(name)
+            .setKey(uuid)
+            .build()
 
         val builder = NotificationCompat.Builder(context, CALL_CHANNEL_ID)
             .setSmallIcon(context.applicationInfo.icon)
-            .setContentTitle("Incoming $callType call")
-            .setContentText(name)
-
-            .setPriority(NotificationCompat.PRIORITY_HIGH) //old was PRIORITY_MAX
+            .setPriority(NotificationCompat.PRIORITY_MAX)
             .setCategory(NotificationCompat.CATEGORY_CALL)
-            .setOngoing(true) 
             .setAutoCancel(false)
-            
-            .setFullScreenIntent(fullScreenPendingIntent, false) //can be true
-            .addAction(0, "Answer", fullScreenPendingIntent)
-            .addAction(0, "Decline", rejectPendingIntent)
+            .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)
+            )
+        } 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())
-
-        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 {
-        // 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())
-        } else {
-            // Fallback: If for some reason uuid is null, cancel everything 
-            // (Optional: only if you want a safety net)
-            // notificationManager.cancelAll() 
-        }
+    fun dismissIncomingCall(context: Context, uuid: String?) {
+         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.3",
+    "version": "0.4.5",
     "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

@@ -20,14 +20,16 @@ function withMainActivityDataFix(config) {
 
         // FIXED: Corrected Kotlin bitwise OR syntax and logic check
         const wakeLogic = `super.onCreate(savedInstanceState)
-    if (intent?.getBooleanExtra("navigatingToCall", false) == true) {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O_MR1) {
-            setShowWhenLocked(true)
-            setTurnScreenOn(true)
-        } else {
-            window.addFlags(WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED or WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON)
-        }
-    }`;
+    // if (intent?.getBooleanExtra("navigatingToCall", false) == true) {
+    //     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O_MR1) {
+    //         setShowWhenLocked(true)
+    //         setTurnScreenOn(true)
+    //     } else {
+    //         window.addFlags(WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED or WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON)
+    //     }
+    // }
+        
+    `;
 
         if (!contents.includes('setShowWhenLocked')) {
             contents = contents.replace(/super\.onCreate\(.*\)/, wakeLogic);
@@ -54,13 +56,6 @@ function withAndroidConfig(config) {
         const androidManifest = config.modResults.manifest;
         const mainApplication = androidManifest.application[0];
 
-        // 1. MainActivity flags
-        const mainActivity = mainApplication.activity.find(a => a.$["android:name"] === ".MainActivity");
-        if (mainActivity) {
-            mainActivity.$["android:showWhenLocked"] = "true";
-            mainActivity.$["android:turnScreenOn"] = "true";
-        }
-
         // 2. Permissions
         const permissions = [
             'android.permission.USE_FULL_SCREEN_INTENT',
@@ -90,8 +85,8 @@ function withAndroidConfig(config) {
                     'android:name': 'com.rnsnativecall.AcceptCallActivity',
                     'android:theme': '@android:style/Theme.Translucent.NoTitleBar',
                     'android:exported': 'false',
-                    'android:showWhenLocked': 'true',
-                    'android:turnScreenOn': 'true'
+                    'android:showWhenLocked': 'false',
+                    'android:turnScreenOn': 'false'
                 }
             });
         }