rns-nativecall 1.2.5 → 1.2.7

package/README.md

@@ -127,10 +127,8 @@ export default function App() {
 }
 ```
 ---
-### 📖 API Reference
-# rns-nativecall API Reference
+## 📖 rns-nativecall API Reference
 
-## API Reference
 
 ### Core Methods
 | Method | Platform | Description |
@@ -138,8 +136,8 @@ export default function App() {
 | **registerHeadlessTask(callback)** | All | Registers the background task. `eventType` is 'INCOMING_CALL', 'BUSY', or 'ABORTED_CALL'. |
 | **displayCall(uuid, name, type)** | All | Launches full-screen Activity (Android) or reports to CallKit (iOS). |
 | **destroyNativeCallUI(uuid)** | All | Stops ringtone/Activity (Android) or ends CallKit session (iOS). |
-| **showMissedCall(uuid, name, type)** | Android | Posts a persistent notification in the device tray for missed calls. |
 | **subscribe(onAccept, onReject, onFailed)** | All | Listens for Answer/Decline actions and system-level bridge errors. |
+| **showMissedCall(uuid, name, type)** | Android | Posts a persistent notification in the device tray for missed calls. |
 
 ### Data & State Management
 | Method | Platform | Description |

package/android/build.gradle

@@ -55,16 +55,15 @@ repositories {
 }
 
 dependencies {
-    // Use 'provided' or 'implementation' depending on how you want to link RN
-    // For most modules, we use implementation but let the app provide the actual binary
     implementation "com.facebook.react:react-native:+"
     
     implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
     implementation "com.google.firebase:firebase-messaging:23.4.0"
     implementation "androidx.appcompat:appcompat:1.6.1"
-    implementation "androidx.core:core-ktx:1.10.1"
+
     implementation "com.google.android.material:material:1.9.0"
-    
+    implementation "androidx.core:core-ktx:1.12.0"
+
     // Glide for profile pictures
     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/NativeCallManager.kt

@@ -1,21 +1,44 @@
 package com.rnsnativecall
 
 import android.app.*
+import android.app.Notification
+import android.app.Notification.Style
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
 import android.content.Context
 import android.content.Intent
+import android.graphics.*
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.graphics.Canvas
 import android.graphics.Color
+import android.graphics.Matrix
+import android.graphics.Paint
+import android.graphics.PorterDuff
+import android.graphics.PorterDuffXfermode
+import android.graphics.drawable.BitmapDrawable
+import android.graphics.drawable.Drawable
 import android.media.AudioAttributes
 import android.media.RingtoneManager
 import android.os.Build
 import android.os.Handler
 import android.os.Looper
+import android.os.Vibrator
+import android.util.DisplayMetrics
+import android.widget.RemoteViews
+import androidx.annotation.DrawableRes
 import androidx.core.app.NotificationCompat
+import androidx.core.app.NotificationManagerCompat
 import androidx.core.app.Person
 import androidx.core.content.ContextCompat
+import androidx.core.content.pm.ShortcutInfoCompat
+import androidx.core.content.pm.ShortcutManagerCompat
+import androidx.core.graphics.drawable.IconCompat
 
 object NativeCallManager {
-    const val channelId = "CALL_CHANNEL_URGENT_V2"
-    private const val MISSED_CHANNEL_ID = "missed_calls"
+    const val channelId = "CALL_CHANNEL_1yURGENT_Io"
+    private const val MISSED_CHANNEL_ID = "missed_hcall_190"
 
     private var currentCallData: Map<String, String>? = null
 
@@ -25,8 +48,6 @@ object NativeCallManager {
 
     fun getCurrentCallData(): Map<String, String>? = currentCallData
 
-    // --- REUSABLE HELPERS ---
-
     private fun getPendingIntentFlags(): Int =
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
             PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
@@ -39,6 +60,36 @@ object NativeCallManager {
         return if (colorId != 0) ContextCompat.getColor(context, colorId) else Color.parseColor("#ffffff")
     }
 
+    private fun getBridgeColor(context: Context): Int = Color.parseColor("#ffffffff")
+
+    private fun getCircularIconWithBackground(
+        context: Context,
+        iconId: Int,
+    ): IconCompat {
+        val iconDrawable = ContextCompat.getDrawable(context, iconId)
+        val backgroundColor = getResourceColor(context)
+
+        val size = 128 // Standard size for notification icons
+        val bitmap = Bitmap.createBitmap(size, size, Bitmap.Config.ARGB_8888)
+        val canvas = Canvas(bitmap)
+
+        val paint =
+            Paint().apply {
+                color = backgroundColor
+                isAntiAlias = true
+            }
+
+        // Draw background circle
+        canvas.drawCircle(size / 2f, size / 2f, size / 2f, paint)
+
+        // Draw the icon on top (padding it slightly so it doesn't touch the edges)
+        val padding = size / 4
+        iconDrawable?.setBounds(padding, padding, size - padding, size - padding)
+        iconDrawable?.draw(canvas)
+
+        return IconCompat.createWithBitmap(bitmap)
+    }
+
     private fun createCallIntent(
         context: Context,
         targetClass: Class<*>,
@@ -54,7 +105,33 @@ object NativeCallManager {
 
     private fun getNotificationManager(context: Context) = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
 
-    // --- MAIN LOGIC ---
+    private fun getInteractionPendingIntent(
+        context: Context,
+        uuid: String,
+    ): PendingIntent {
+        // Dynamically get the main activity of the host app
+        val packageName = context.packageName
+        val launchIntent = context.packageManager.getLaunchIntentForPackage(packageName)
+
+        val intent =
+            if (launchIntent != null) {
+                launchIntent.apply {
+                    action = "ACTION_CALL_INTERACTION" // Custom action to handle in JS/Java
+                    putExtra("EXTRA_CALL_UUID", uuid)
+                    addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
+                }
+            } else {
+                // Fallback if launch intent is null (rare)
+                Intent()
+            }
+
+        return PendingIntent.getActivity(
+            context,
+            uuid.hashCode(),
+            intent,
+            getPendingIntentFlags() or PendingIntent.FLAG_UPDATE_CURRENT,
+        )
+    }
 
     fun handleIncomingPush(
         context: Context,
@@ -68,6 +145,7 @@ object NativeCallManager {
             val notificationId = uuid.hashCode()
             val flags = getPendingIntentFlags()
 
+            val vibrationPattern = longArrayOf(0, 1000, 500, 1000, 500, 1000)
             // 1. Setup Intents using helper
             val overlayIntent =
                 createCallIntent(context, NotificationOverlayActivity::class.java, null, uuid, data).apply {
@@ -98,6 +176,7 @@ object NativeCallManager {
                         lockscreenVisibility = Notification.VISIBILITY_PUBLIC
                         enableVibration(true)
                         setBypassDnd(true)
+                        setVibrationPattern(longArrayOf(0, 1000, 500, 1000))
                         setSound(
                             RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE),
                             AudioAttributes
@@ -136,13 +215,14 @@ object NativeCallManager {
                 NotificationCompat
                     .Builder(context, channelId)
                     .setSmallIcon(iconId)
-                    .setContentTitle("Incoming $callType Call from $name")
-                    .setContentText("Incoming $callType Call")
-                    .setSubText("Incoming $callType Call")
+                    .setContentTitle("Incoming $callType call from $name")
+                    .setContentText("Incoming $callType call")
+                    .setSubText("Incoming $callType call")
                     .setColor(getResourceColor(context))
                     .setPriority(NotificationCompat.PRIORITY_MAX)
                     .setCategory(NotificationCompat.CATEGORY_CALL)
                     .setOngoing(true)
+                    .setVibrate(vibrationPattern) // Add this line
                     .setFullScreenIntent(fullScreenPI, true)
                     .setStyle(incomingCallStyle)
                     .setForegroundServiceBehavior(NotificationCompat.FOREGROUND_SERVICE_IMMEDIATE)
@@ -166,38 +246,172 @@ object NativeCallManager {
         val name = data["name"] ?: "Unknown"
         val callType = data["callType"] ?: "video"
 
-        // Setup Missed Channel
+        // 1. Setup Channel
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            val channel = NotificationChannel(MISSED_CHANNEL_ID, "Missed Calls", NotificationManager.IMPORTANCE_DEFAULT)
+            val channel =
+                NotificationChannel(
+                    MISSED_CHANNEL_ID,
+                    "Missed Calls",
+                    NotificationManager.IMPORTANCE_LOW,
+                ).apply {
+                    lockscreenVisibility = Notification.VISIBILITY_PUBLIC
+                }
             getNotificationManager(context).createNotificationChannel(channel)
         }
 
-        val iconResId =
-            context.resources
-                .getIdentifier("ic_missed_call", "drawable", context.packageName)
-                .let { if (it != 0) it else android.R.drawable.sym_call_missed }
-
-        val launchIntent =
-            context.packageManager.getLaunchIntentForPackage(context.packageName)?.apply {
-                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
+        // 2. Resolve Icon
+        val iconId =
+            context.resources.getIdentifier("notification_icon", "mipmap", context.packageName).let { mipmapId ->
+                if (mipmapId != 0) {
+                    mipmapId
+                } else {
+                    context.resources.getIdentifier("notification_icon", "drawable", context.packageName).let { drawableId ->
+                        if (drawableId != 0) drawableId else context.applicationInfo.icon
+                    }
+                }
             }
-        val pendingIntent = PendingIntent.getActivity(context, uuid.hashCode(), launchIntent, getPendingIntentFlags())
 
-        val notification =
+        val avatarIcon = getCircularIconWithBackground(context, iconId)
+
+        // 3. Create Person & Link to Shortcut Key
+        val caller =
+            Person
+                .Builder()
+                .setName(name)
+                .setIcon(avatarIcon)
+                .setKey(uuid) // Links person to the shortcut
+                .setImportant(true)
+                .build()
+
+        // 4. Create & Push Dynamic Shortcut (The "Telegram" Magic)
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N_MR1) {
+            val launchIntent =
+                context.packageManager.getLaunchIntentForPackage(context.packageName)?.apply {
+                    action = Intent.ACTION_VIEW
+                    putExtra("conversation_id", uuid)
+                } ?: Intent()
+
+            val shortcut =
+                ShortcutInfoCompat
+                    .Builder(context, uuid)
+                    .setShortLabel(name)
+                    .setIcon(avatarIcon)
+                    .setIntent(launchIntent)
+                    .setPerson(caller)
+                    .setLongLived(true)
+                    .build()
+
+            ShortcutManagerCompat.pushDynamicShortcut(context, shortcut)
+        }
+
+        // 5. Build Action & Notification
+        val openAppIntent = getInteractionPendingIntent(context, uuid)
+        val openAppAction =
+            NotificationCompat.Action
+                .Builder(
+                    android.R.drawable.ic_menu_view,
+                    "Open App",
+                    openAppIntent,
+                ).build()
+
+        val messagingStyle =
+            NotificationCompat
+                .MessagingStyle(caller)
+                .addMessage("Missed $callType call", System.currentTimeMillis(), caller)
+
+        val builder =
             NotificationCompat
                 .Builder(context, MISSED_CHANNEL_ID)
-                .setSmallIcon(iconResId)
-                .setContentTitle(context.applicationInfo.loadLabel(context.packageManager).toString())
-                .setContentText("You missed a $callType call from $name")
-                .setPriority(NotificationCompat.PRIORITY_HIGH)
-                .setColor(getResourceColor(context))
-                .setAutoCancel(true)
+                .setSmallIcon(android.R.drawable.sym_call_missed)
+                .setStyle(messagingStyle)
+                .setShortcutId(uuid)
                 .setCategory(NotificationCompat.CATEGORY_MISSED_CALL)
-                .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
-                .setContentIntent(pendingIntent)
+                .setOngoing(false)
+                .setAutoCancel(true)
+                .setColor(getBridgeColor(context))
+                .setContentIntent(openAppIntent)
+                // .addAction(openAppAction) later for future use
+                .setPriority(NotificationCompat.PRIORITY_HIGH)
+
+        getNotificationManager(context).notify(uuid.hashCode() + 10000, builder.build())
+    }
+
+    fun showOnGoingCall(
+        context: Context,
+        data: Map<String, String>,
+    ) {
+        val uuid = data["callUuid"] ?: return
+        val name = data["name"] ?: "Unknown"
+        val callType = data["callType"] ?: "video"
+
+        // 1. Setup the Channel
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val channel =
+                NotificationChannel(
+                    MISSED_CHANNEL_ID,
+                    "Active Calls",
+                    NotificationManager.IMPORTANCE_LOW,
+                ).apply {
+                    lockscreenVisibility = Notification.VISIBILITY_PUBLIC
+                }
+            getNotificationManager(context).createNotificationChannel(channel)
+        }
+
+        val openAppIntent = getInteractionPendingIntent(context, uuid)
+
+        // 2. The Person - No Icon means Android will show Initials
+        val caller =
+            Person
+                .Builder()
+                .setName(name)
+                .setImportant(true)
                 .build()
 
-        getNotificationManager(context).notify(uuid.hashCode() + 10000, notification)
+        // 3. Intents for CallStyle
+        val hangUpIntent =
+            Intent(context, CallActionReceiver::class.java).apply {
+                action = "ACTION_HANG_UP"
+                putExtra("EXTRA_UUID", uuid)
+            }
+        val hangUpPendingIntent =
+            PendingIntent.getBroadcast(
+                context,
+                uuid.hashCode(),
+                hangUpIntent,
+                getPendingIntentFlags(),
+            )
+
+        val callStyle = NotificationCompat.CallStyle.forOngoingCall(caller, hangUpPendingIntent)
+
+        // 4. Custom Action Button
+        val openAppAction =
+            NotificationCompat.Action
+                .Builder(
+                    android.R.drawable.ic_menu_view,
+                    "Open App",
+                    openAppIntent,
+                ).build()
+
+        // 5. Build Notification
+        val builder =
+            NotificationCompat
+                .Builder(context, MISSED_CHANNEL_ID)
+                // Use system icon for the status bar
+                .setSmallIcon(android.R.drawable.stat_sys_phone_call)
+                .setStyle(callStyle)
+                .setCategory(NotificationCompat.CATEGORY_CALL)
+                .setOngoing(true)
+                .setAutoCancel(false)
+                .addPerson(caller)
+                .addAction(openAppAction)
+                .setPriority(NotificationCompat.PRIORITY_LOW)
+                // Sets the circular background of the Small Icon in the drawer to White
+                .setColor(getBridgeColor(context))
+                .setContentTitle(name)
+                .setContentText("Ongoing $callType call")
+                .setFullScreenIntent(openAppIntent, true)
+
+        getNotificationManager(context).notify(uuid.hashCode(), builder.build())
     }
 
     fun refreshNotificationOnly(

package/package.json

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