rns-nativecall 0.7.9 → 0.8.0

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

@@ -1,77 +1,28 @@
 package com.rnsnativecall
 
 import android.app.Activity
-import android.app.NotificationManager
-import android.content.Context
 import android.content.Intent
 import android.os.Bundle
 import android.view.WindowManager
-import android.app.KeyguardManager
+import android.os.Build
 
 class AcceptCallActivity : Activity() {
-
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
 
-        window.addFlags(
-            WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED or
-            WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON or
-            WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON
-        )
-
-        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)
-    }
-
-    private fun processCallIntent(intent: Intent) {
-        NativeCallManager.stopRingtone()
-
-        val extras = intent.extras
-        val uuid = extras?.getString("callUuid")
-
-        val notificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-        uuid?.let { notificationManager.cancel(it.hashCode()) }
-
-        // ✅ 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?) {
-        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)
+        val launchIntent = packageManager.getLaunchIntentForPackage(packageName)
+        if (launchIntent != null) {
+            launchIntent.apply {
+                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or 
+                         Intent.FLAG_ACTIVITY_SINGLE_TOP or 
+                         Intent.FLAG_ACTIVITY_REORDER_TO_FRONT)
+                putExtras(intent.extras ?: Bundle())
+                putExtra("navigatingToCall", true)
             }
+            startActivity(launchIntent)
         }
+
+        finish()
+        overridePendingTransition(0, 0)
     }
 }

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

@@ -4,49 +4,70 @@ import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
 import android.app.NotificationManager
-import android.app.KeyguardManager
+import android.os.Bundle
 
 class CallActionReceiver : BroadcastReceiver() {
     override fun onReceive(context: Context, intent: Intent) {
+        // Stop sound immediately
         NativeCallManager.stopRingtone()
 
         val uuid = intent.getStringExtra("EXTRA_CALL_UUID") ?: return
         val action = intent.action ?: ""
+        val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
 
-        val notificationManager =
-            context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-
-        val dataMap = mutableMapOf<String, String>()
+        // 1. Reconstruct the full data map from Intent Extras
+        val fullDataMap = mutableMapOf<String, String>()
         intent.extras?.keySet()?.forEach { key ->
-            intent.extras?.get(key)?.let { dataMap[key] = it.toString() }
+            intent.extras?.get(key)?.let { fullDataMap[key] = it.toString() }
         }
 
-        val name = intent.extras?.getString("name") ?: "Someone"
-        val callType = intent.extras?.getString("callType") ?: "audio"
-
-        val keyguardManager = context.getSystemService(Context.KEYGUARD_SERVICE) as KeyguardManager
+        val name = fullDataMap["name"] ?: "Someone"
+        val callType = fullDataMap["callType"] ?: "audio"
 
-        if (action.contains("ACTION_REJECT")) {
+        // --- HANDLE REJECT ---
+        if (action == "ACTION_REJECT") {
             if (CallModule.isReady()) {
-                CallModule.sendEventToJS("onCallRejected", mapOf("callUuid" to uuid))
+                CallModule.sendEventToJS("onCallRejected", fullDataMap)
                 notificationManager.cancel(uuid.hashCode())
+                CallForegroundService.stop(context)
             } else {
-                // Queue pending event
-                CallModule.setPendingCallData("onCallRejected_pending", mapOf("callUuid" to uuid))
-                // Update notification pill to "Aborting…" state
+                CallModule.setPendingCallData("onCallRejected_pending", fullDataMap)
                 NativeCallManager.aborting(context, uuid, name, callType)
+            }
+        }
+
+        // --- HANDLE ANSWER ---
+        if (action == "ACTION_ANSWER") {
+            // Dismiss the "Incoming" pill immediately
+            notificationManager.cancel(uuid.hashCode())
 
-                // Register callback to auto‑open app once RN is ready
-                CallModule.registerOnReadyCallback {
-                    val launchIntent = context.packageManager.getLaunchIntentForPackage(context.packageName)
-                    launchIntent?.apply {
-                        addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
-                        putExtras(intent.extras ?: android.os.Bundle())
-                        putExtra("navigatingToCall", true)
-                        context.startActivity(this)
-                    }
-                }
+            if (CallModule.isReady()) {
+                // Inform JS with full payload
+                CallModule.sendEventToJS("onCallAccepted", fullDataMap)
+                CallForegroundService.stop(context)
+                
+                // Open the app
+                launchApp(context, intent.extras)
+            } else {
+                // Cold start: Queue full payload and show connecting
+                CallModule.setPendingCallData("onCallAccepted_pending", fullDataMap)
+                NativeCallManager.connecting(context, uuid, name, callType)
+                
+                launchApp(context, intent.extras)
             }
         }
     }
+
+
+private fun launchApp(context: Context, extras: Bundle?) {
+    val intent = Intent(context, AcceptCallActivity::class.java).apply {
+        addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or 
+                 Intent.FLAG_ACTIVITY_SINGLE_TOP or 
+                 Intent.FLAG_ACTIVITY_CLEAR_TOP)
+        
+        if (extras != null) putExtras(extras)
+    }
+    context.startActivity(intent)
 }
+
+}

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

@@ -1,20 +1,23 @@
 package com.rnsnativecall
 
 import android.app.*
+import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
+import android.content.IntentFilter
 import android.content.pm.ServiceInfo
 import android.os.Build
 import android.os.Bundle
 import android.os.IBinder
 import androidx.core.app.NotificationCompat
 import com.facebook.react.HeadlessJsTaskService
-
-import android.os.Handler // Added
-import android.os.Looper  // Added
+import android.os.Handler
+import android.os.Looper
 
 class CallForegroundService : Service() {
 
+    private var unlockReceiver: UnlockReceiver? = null // Store reference for unregistering
+
     companion object {
         private const val NOTIFICATION_ID = 101
         private const val CHANNEL_ID = "incoming_call_service"
@@ -25,6 +28,23 @@ class CallForegroundService : Service() {
         }
     }
 
+    override fun onCreate() {
+        super.onCreate()
+        
+        // --- DYNAMIC REGISTRATION FIX ---
+        // Registering here makes the system allow the USER_PRESENT broadcast
+        // because the app is already in the Foreground (via this service).
+        unlockReceiver = UnlockReceiver()
+        val filter = IntentFilter(Intent.ACTION_USER_PRESENT)
+        
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            // Android 13+ requires the RECEIVER_EXPORTED flag for system broadcasts
+            registerReceiver(unlockReceiver, filter, Context.RECEIVER_EXPORTED)
+        } else {
+            registerReceiver(unlockReceiver, filter)
+        }
+    }
+
     override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
         val data = intent?.extras
         val name = data?.getString("name") ?: "Someone"
@@ -33,14 +53,13 @@ class CallForegroundService : Service() {
 
         val notification = NotificationCompat.Builder(this, CHANNEL_ID)
             .setContentTitle(name)
-            .setContentText("Connecting...")
+            .setContentText("Incoming Call...")
             .setSmallIcon(applicationInfo.icon)
             .setCategory(NotificationCompat.CATEGORY_CALL)
             .setPriority(NotificationCompat.PRIORITY_HIGH) 
             .setOngoing(true)
             .build()
 
-        // --- ANDROID 14 FIX START ---
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
             startForeground(
                 NOTIFICATION_ID, 
@@ -50,11 +69,9 @@ class CallForegroundService : Service() {
         } else {
             startForeground(NOTIFICATION_ID, notification)
         }
-        // --- ANDROID 14 FIX END ---
 
         // Launch the Headless Task
         val headlessIntent = Intent(this, CallHeadlessTask::class.java).apply {
-            // Safe bundle copy
             val bundle = Bundle()
             data?.let { b ->
                 for (key in b.keySet()) {
@@ -67,38 +84,44 @@ class CallForegroundService : Service() {
         try {
             this.startService(headlessIntent)
             HeadlessJsTaskService.acquireWakeLockNow(this)
-        } catch (e: Exception) {
-            e.printStackTrace()
-        }
+        } catch (e: Exception) { e.printStackTrace() }
 
+        // Auto-stop after 30s
+        Handler(Looper.getMainLooper()).postDelayed({
+            try { stopSelf() } catch (e: Exception) {}
+        }, 30000)
 
-        // Automatically stop this service if JS doesn't stop it within 30 seconds
-Handler(Looper.getMainLooper()).postDelayed({
-    try {
-        stopSelf()
-    } catch (e: Exception) {
-        // Service might already be stopped
-    }
-}, 30000)
         return START_NOT_STICKY
     }
 
+    override fun onDestroy() {
+        // --- CLEANUP ---
+        // Unregister to prevent memory leaks once the call ends or service stops
+        try {
+            unlockReceiver?.let { unregisterReceiver(it) }
+        } catch (e: Exception) { e.printStackTrace() }
+        
+        try { stopForeground(true) } catch (_: Exception) {}
+        super.onDestroy()
+    }
+
     private fun createNotificationChannel() {
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-        val channel = NotificationChannel(
-            CHANNEL_ID,
-            "Call Service",
-            NotificationManager.IMPORTANCE_HIGH
-        ).apply {
-            description = "Handles incoming call connection state"
-            // Optional: makes the "Connecting" notification silent 
-            // so it doesn't double-beep with the actual ringtone
-            setSound(null, null) 
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val channel = NotificationChannel(
+                CHANNEL_ID,
+                "Call Service",
+                NotificationManager.IMPORTANCE_LOW
+            ).apply {
+                description = "Handles incoming call connection state"
+                setSound(null, null) 
+                enableVibration(false)
+                setBypassDnd(true)
+                lockscreenVisibility = NotificationCompat.VISIBILITY_PUBLIC
+            }
+            val manager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+            manager.createNotificationChannel(channel)
         }
-        val manager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-        manager.createNotificationChannel(channel)
     }
-}
 
     override fun onBind(intent: Intent?): IBinder? = null
 }

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

@@ -34,7 +34,6 @@ class CallMessagingService : FirebaseMessagingService() {
         CallState.clear(uuid, context) 
     }
     
-    // Dismiss the "Connecting..." or "Incoming Call" UI
     NativeCallManager.dismissIncomingCall(context, uuid)
     showMissedCallNotification(context, data, uuid)
     return

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

@@ -5,6 +5,9 @@ import android.content.Context
 import com.facebook.react.bridge.*
 import com.facebook.react.modules.core.DeviceEventManagerModule
 import android.content.Intent
+import android.os.Build
+import android.provider.Settings
+import android.net.Uri
 
 class CallModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
 
@@ -51,6 +54,29 @@ class CallModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
         }
     }
     
+    // Inside your CallModule class
+    @ReactMethod
+    fun checkOverlayPermission(promise: Promise) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            promise.resolve(Settings.canDrawOverlays(reactApplicationContext))
+        } else {
+            promise.resolve(true)
+        }
+    }
+
+     @ReactMethod
+     fun requestOverlayPermission() {
+         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+             if (!Settings.canDrawOverlays(reactApplicationContext)) {
+                 val intent = Intent(
+                     Settings.ACTION_MANAGE_OVERLAY_PERMISSION,
+                     Uri.parse("package:${reactApplicationContext.packageName}")
+                 )
+                 intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                 reactApplicationContext.startActivity(intent)
+          }
+         }
+     }
 
     /**
      * Combined Validity Check: 
@@ -108,11 +134,6 @@ class CallModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMo
         notificationManager.cancel(101)
     }
 
-    @ReactMethod
-    fun checkTelecomPermissions(promise: Promise) {
-        promise.resolve(true)
-    }
-
     @ReactMethod fun addListener(eventName: String) {}
     @ReactMethod fun removeListeners(count: Int) {}
 

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

@@ -10,85 +10,89 @@ import androidx.core.app.NotificationCompat
 import android.media.Ringtone
 import android.media.RingtoneManager
 import android.graphics.Color
-
 import android.app.KeyguardManager
 
-import com.rnsnativecall.CallMessagingService
-
 object NativeCallManager {
 
     private var ringtone: Ringtone? = null
     const val channelId = "CALL_CHANNEL_ID"
 
+    private var currentCallData: Map<String, String>? = null
+
+    fun getCurrentCallData(): Map<String, String>? = currentCallData
+
     fun handleIncomingPush(context: Context, data: Map<String, String>) {
         val uuid = data["callUuid"] ?: return
+        this.currentCallData = data
         stopRingtone()
 
         val name = data["name"] ?: "Incoming Call"
         val callType = data["callType"] ?: "audio"
         val notificationId = uuid.hashCode()
 
- 
-
-
-        // --- LOCK SCREEN GATEKEEPER ---
-        val keyguardManager = context.getSystemService(Context.KEYGUARD_SERVICE) as KeyguardManager
-        if (keyguardManager.isKeyguardLocked) {
-             // Device is locked? We bounce it!
-             CallState.markCanceled(uuid, context) 
-             showMissedCallNotification(context, data, uuid)
-             return // 🛑 Flow stops here
-        }
-
-
-
         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)
+        // Dummy intent for content click
+        val noOpIntent = PendingIntent.getActivity(context, notificationId + 3, Intent(), pendingFlags)
+
+        // 1. Define the flags properly (DO NOT MIX THEM)
+val mutableFlags = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+    PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_MUTABLE
+} else {
+    PendingIntent.FLAG_UPDATE_CURRENT
+}
+
+val immutableFlags = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+    PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+} else {
+    PendingIntent.FLAG_UPDATE_CURRENT
+}
+
+// 2. Setup the Overlay Intent
+val overlayIntent = Intent(context, NotificationOverlayActivity::class.java).apply { 
+    this.putExtra("EXTRA_CALL_UUID", uuid)
+    data.forEach { (k, v) -> this.putExtra(k, v) }
+    // No User Action flag prevents the intent from triggering an auto-dismiss of notifications
+    addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_NO_USER_ACTION)
+}
+
+// 3. Create the Full Screen PendingIntent (Use IMMUTABLE)
+val fullScreenPendingIntent = PendingIntent.getActivity(
+    context, 
+    notificationId, 
+    overlayIntent, 
+    immutableFlags // <--- Use the immutable version here
+)
+
+
+
+        // --- ANSWER ACTION ---
+        val answerIntent = Intent(context, CallActionReceiver::class.java).apply {
+            this.action = "ACTION_ANSWER"
+            this.putExtra("EXTRA_CALL_UUID", uuid)
+            
+            data.forEach { (key, value) -> this.putExtra(key, value) } // Pass full data
         }
 
-        val fullScreenPendingIntent = PendingIntent.getActivity(
-            context,
-            notificationId,
-            intentToActivity,
-            pendingFlags
-        )
+        val answerPendingIntent = PendingIntent.getBroadcast(context, notificationId + 1, answerIntent, mutableFlags)
 
+        // --- REJECT ACTION ---
         val rejectIntent = Intent(context, CallActionReceiver::class.java).apply {
-            this.action = "ACTION_REJECT_$uuid"
+            this.action = "ACTION_REJECT"
             this.putExtra("EXTRA_CALL_UUID", uuid)
-            data.forEach { (key, value) -> this.putExtra(key, value) }
+            data.forEach { (key, value) -> this.putExtra(key, value) } // Pass full data
         }
-
-        val rejectPendingIntent = PendingIntent.getBroadcast(
-            context,
-            notificationId,
-            rejectIntent,
-            pendingFlags
-        )
+        
+        val rejectPendingIntent = PendingIntent.getBroadcast(context, notificationId + 2, rejectIntent, mutableFlags)
 
         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 {
+            val channel = NotificationChannel(channelId, "Incoming Calls", NotificationManager.IMPORTANCE_HIGH).apply {
                 enableVibration(true)
                 vibrationPattern = longArrayOf(0, 500, 500, 500)
                 lightColor = Color.GREEN
@@ -99,83 +103,70 @@ object NativeCallManager {
             notificationManager.createNotificationChannel(channel)
         }
 
+        val keyguardManager = context.getSystemService(Context.KEYGUARD_SERVICE) as KeyguardManager
+        val isLocked = keyguardManager.isKeyguardLocked
+
+
         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, "Answer", answerPendingIntent)
             .addAction(0, "Decline", rejectPendingIntent)
+            .setDefaults(NotificationCompat.DEFAULT_ALL)
+       
+              builder.setFullScreenIntent(fullScreenPendingIntent, true)
+   
 
         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
-            }
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) ringtone?.isLooping = true
             ringtone?.play()
-        } catch (e: Exception) {
-            e.printStackTrace()
-        }
+        } catch (e: Exception) { e.printStackTrace() }
     }
 
     fun stopRingtone() {
         try {
             ringtone?.let { if (it.isPlaying) it.stop() }
             ringtone = null
-        } catch (e: Exception) {
-            ringtone = null
-        }
+        } catch (e: Exception) { ringtone = null }
     }
 
-fun connecting(context: Context, uuid: String, name: String, callType: String) {
-    val notificationId = uuid.hashCode()
-    val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-
-    val builder = NotificationCompat.Builder(context, channelId)
-        .setSmallIcon(context.applicationInfo.icon)
-        .setContentTitle("Incoming $callType call")
-        .setContentText("Connecting…") // ✅ show connecting text
-        .setSubText("Connecting…") // status line
-        .setPriority(NotificationCompat.PRIORITY_MAX)
-        .setCategory(NotificationCompat.CATEGORY_CALL)
-        .setOngoing(true)
-        .setAutoCancel(false)
-        .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
-        .setProgress(0, 0, true) // ✅ system activity indicator (indeterminate progress bar)
-
-    notificationManager.notify(notificationId, builder.build())
-}
-
-fun aborting(context: Context, uuid: String, name: String, callType: String) {
-    val notificationId = uuid.hashCode()
-    val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-
-    val builder = NotificationCompat.Builder(context, channelId)
-        .setSmallIcon(context.applicationInfo.icon)
-        .setContentTitle("Incoming $callType call")
-        .setContentText("Aborting…") // ✅ show aborting text
-        .setSubText("Aborting…") // status line
-        .setPriority(NotificationCompat.PRIORITY_MAX)
-        .setCategory(NotificationCompat.CATEGORY_CALL)
-        .setOngoing(true)
-        .setAutoCancel(false)
-        .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
-        .setProgress(0, 0, true) // ✅ indeterminate progress indicator
-
-    notificationManager.notify(notificationId, builder.build())
-}
+    fun connecting(context: Context, uuid: String, name: String, callType: String) {
+        val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        val builder = NotificationCompat.Builder(context, channelId)
+            .setSmallIcon(context.applicationInfo.icon)
+            .setContentTitle("Incoming $callType call")
+            .setContentText("Connecting…")
+            .setPriority(NotificationCompat.PRIORITY_MAX)
+            .setOngoing(true)
+            .setProgress(0, 0, true)
+        notificationManager.notify(uuid.hashCode(), builder.build())
+    }
 
+    fun aborting(context: Context, uuid: String, name: String, callType: String) {
+        val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        val builder = NotificationCompat.Builder(context, channelId)
+            .setSmallIcon(context.applicationInfo.icon)
+            .setContentTitle("Incoming $callType call")
+            .setContentText("Aborting…")
+            .setPriority(NotificationCompat.PRIORITY_MAX)
+            .setOngoing(true)
+            .setProgress(0, 0, true)
+        notificationManager.notify(uuid.hashCode(), builder.build())
+    }
 
     fun dismissIncomingCall(context: Context, uuid: String?) {
+        this.currentCallData = null
         stopRingtone()
         val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
         if (uuid != null) notificationManager.cancel(uuid.hashCode())

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

@@ -0,0 +1,26 @@
+package com.rnsnativecall
+
+import android.app.Activity
+import android.os.Build
+import android.os.Bundle
+import android.view.WindowManager
+
+class NotificationOverlayActivity : Activity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        // These flags allow the notification pill to show over the lockscreen
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O_MR1) {
+            setShowWhenLocked(true)
+            setTurnScreenOn(true)
+        } else {
+            @Suppress("DEPRECATION")
+            window.addFlags(
+                WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED or
+                WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON or
+                WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON
+            )
+        }
+        finish()
+    }
+}

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

@@ -0,0 +1,22 @@
+package com.rnsnativecall
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+
+class UnlockReceiver : BroadcastReceiver() {
+    override fun onReceive(context: Context, intent: Intent) {
+        android.util.Log.d("UnlockReceiver", "Device Unlocked! Action: ${intent.action}")
+        
+        if (intent.action == Intent.ACTION_USER_PRESENT) {
+            val activeData = NativeCallManager.getCurrentCallData()
+            
+            if (activeData != null) {
+                android.util.Log.d("UnlockReceiver", "Re-triggering call for: ${activeData["name"]}")
+                NativeCallManager.handleIncomingPush(context, activeData)
+            } else {
+                android.util.Log.d("UnlockReceiver", "No active call data found to re-trigger.")
+            }
+        }
+    }
+}

package/android/src/main/res/drawable/circle_background.xml

@@ -0,0 +1,4 @@
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+    android:shape="oval">
+    <solid android:color="#333333" />
+</shape>

package/android/src/main/res/drawable/ic_call_answer_white.xml

@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <path
+        android:fillColor="#FFFFFF"
+        android:pathData="M20,15.5c-1.25,0 -2.45,-0.2 -3.57,-0.57a1.02,1.02 0,0 0,-1.02 0.24l-2.2,2.2a15.05,15.05 0,0 1,-6.59 -6.59l2.2,-2.2a1.02,1.02 0,0 0,0.24 -1.02A11.36,11.36 0,0 1,8.5 4c0,-0.55 -0.45,-1 -1,-1H4c-0.55,0 -1,0.45 -1,1c0,9.39 7.61,17 17,17c0.55,0 1,-0.45 1,-1v-3.5c0,-0.55 -0.45,-1 -1,-1z" />
+</vector>

package/android/src/main/res/drawable/ic_call_end_white.xml

@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <path
+        android:fillColor="#FFFFFF"
+        android:pathData="M12,9c-1.6,0 -3.15,0.25 -4.6,0.72v3.1c0,0.39 -0.23,0.74 -0.56,0.9 -0.98,0.49 -1.65,1.45 -1.65,2.58c0,1.65 1.34,3 3,3h2v-3H8.1c0.01,-0.99 0.87,-1.8 1.85,-1.8c0.51,0 1,-0.21 1.35,-0.56l1.8,-1.8C13.04,9.3 12.55,9 12,9z" />
+</vector>

package/android/src/main/res/layout/activity_incoming_call.xml

@@ -0,0 +1,139 @@
+<?xml version="1.0" encoding="utf-8"?>
+<androidx.constraintlayout.widget.ConstraintLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:background="#212121">
+
+    <!-- Profile Section -->
+    <ImageView
+        android:id="@+id/profileImage"
+        android:layout_width="200dp"
+        android:layout_height="200dp"
+        android:scaleType="centerCrop"
+        android:background="@drawable/circle_background"
+        app:layout_constraintTop_toTopOf="parent"
+        app:layout_constraintStart_toStartOf="parent"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:layout_constraintBottom_toTopOf="@id/usernameText"
+        app:layout_constraintVertical_chainStyle="packed"
+        app:layout_constraintVertical_bias="0.35"
+        tools:src="@drawable/ic_profile_placeholder" />
+
+    <!-- Optional: Blur effect for discreet mode (apply programmatically) -->
+    <!-- You can use RenderScript or BlurView library for real blur -->
+
+    <TextView
+        android:id="@+id/usernameText"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:text="John Doe"
+        android:textColor="#FFFFFF"
+        android:textSize="32sp"
+        android:fontFamily="sans-serif-medium"
+        android:layout_marginTop="20dp"
+        app:layout_constraintTop_toBottomOf="@id/profileImage"
+        app:layout_constraintStart_toStartOf="parent"
+        app:layout_constraintEnd_toEndOf="parent"
+        tools:text="John Doe" />
+
+    <TextView
+        android:id="@+id/callStatusText"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:text="Incoming Video Call..."
+        android:textColor="#FFFFFF"
+        android:textSize="18sp"
+        android:alpha="0.8"
+        android:layout_marginTop="10dp"
+        app:layout_constraintTop_toBottomOf="@id/usernameText"
+        app:layout_constraintStart_toStartOf="parent"
+        app:layout_constraintEnd_toEndOf="parent" />
+
+    <!-- Action Buttons Container -->
+    <LinearLayout
+        android:id="@+id/buttonContainer"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:orientation="horizontal"
+        android:gravity="center"
+        android:paddingBottom="100dp"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintStart_toStartOf="parent"
+        app:layout_constraintEnd_toEndOf="parent">
+
+        <!-- Decline Button -->
+        <LinearLayout
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:orientation="vertical"
+            android:gravity="center"
+            android:layout_marginEnd="60dp">
+
+            <androidx.cardview.widget.CardView
+                android:layout_width="70dp"
+                android:layout_height="70dp"
+                app:cardCornerRadius="35dp"
+                app:cardElevation="8dp"
+                app:cardBackgroundColor="#FF3B30">
+
+                <ImageView
+                    android:layout_width="match_parent"
+                    android:layout_height="match_parent"
+                    android:src="@drawable/ic_call_end_white"
+                    android:padding="18dp"
+                    android:tint="#FFFFFF" />
+
+            </androidx.cardview.widget.CardView>
+
+            <TextView
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:text="Decline"
+                android:textColor="#FFFFFF"
+                android:textSize="16sp"
+                android:fontFamily="sans-serif-medium"
+                android:layout_marginTop="10dp" />
+
+        </LinearLayout>
+
+        <!-- Accept Button -->
+        <LinearLayout
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:orientation="vertical"
+            android:gravity="center"
+            android:layout_marginStart="60dp">
+
+            <androidx.cardview.widget.CardView
+                android:layout_width="70dp"
+                android:layout_height="70dp"
+                app:cardCornerRadius="35dp"
+                app:cardElevation="8dp"
+                app:cardBackgroundColor="#4CD964">
+
+                <ImageView
+                    android:layout_width="match_parent"
+                    android:layout_height="match_parent"
+                    android:src="@drawable/ic_call_answer_white"
+                    android:padding="18dp"
+                    android:tint="#FFFFFF" />
+
+            </androidx.cardview.widget.CardView>
+
+            <TextView
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:text="Accept"
+                android:textColor="#FFFFFF"
+                android:textSize="16sp"
+                android:fontFamily="sans-serif-medium"
+                android:layout_marginTop="10dp" />
+
+        </LinearLayout>
+
+    </LinearLayout>
+
+</androidx.constraintlayout.widget.ConstraintLayout>

package/index.d.ts

@@ -78,6 +78,10 @@ export interface CallHandlerType {
      */
     checkCallStatus(uuid: string): Promise<CallStatus>;
 
+    requestOverlayPermission(): Promise<boolean>;
+
+    checkOverlayPermission(): Promise<boolean>;
+
     /**
      * Forcefully dismisses the native call UI, stops the ringtone, and clears state.
      * Use this when the call is hung up or timed out.

package/index.js

@@ -47,6 +47,16 @@ export const CallHandler = {
     },
     // ------------------------------------
 
+    requestOverlayPermission: async () => {
+        if (!CallModule?.requestOverlayPermission) return false;
+        return await CallModule.requestOverlayPermission();
+    },
+
+    checkOverlayPermission: async () => {
+        if (!CallModule?.checkOverlayPermission) return false;
+        return await CallModule.checkOverlayPermission();
+    },
+
     displayCall: async (uuid, name, callType = "audio") => {
         if (!CallModule) return false;
         return await CallModule.displayIncomingCall(uuid.toLowerCase().trim(), name, callType);

package/package.json

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

package/withNativeCallVoip.js

@@ -5,35 +5,54 @@ function withMainActivityDataFix(config) {
     return withMainActivity(config, (config) => {
         let contents = config.modResults.contents;
 
-        // Ensure Intent import for Kotlin
-        if (!contents.includes('import android.content.Intent')) {
-            contents = contents.replace(/package .*/, (match) => `${match}\n\nimport android.content.Intent`);
-        }
+        const imports = [
+            'import android.content.Intent',
+            'import android.os.Bundle',
+            'import android.view.WindowManager',
+            'import android.os.Build'
+        ];
 
-        const onNewIntentCode = `
-  override fun onNewIntent(intent: Intent) {
-    super.onNewIntent(intent)
-    setIntent(intent)
-  }
-`;
+        // Add imports if they don't exist
+        imports.forEach(imp => {
+            if (!contents.includes(imp)) {
+                contents = contents.replace(/package .*/, (match) => `${match}\n${imp}`);
+            }
+        });
 
         const onCreateCode = `
   override fun onCreate(savedInstanceState: Bundle?) {
     super.onCreate(savedInstanceState)
-    
-    // If background wake from FCM, move to back to let LockScreen UI show
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O_MR1) {
+        setShowWhenLocked(false)
+        setTurnScreenOn(true)
+    } else {
+        window.addFlags(
+            WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED or
+            WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON or
+            WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON
+        )
+    }
     if (intent.getBooleanExtra("background_wake", false)) {
         moveTaskToBack(true)
     }
-  }
-`;
-        if (!contents.includes('override fun onNewIntent')) {
-            const lastBraceIndex = contents.lastIndexOf('}');
-            contents = contents.slice(0, lastBraceIndex) + onNewIntentCode + contents.slice(lastBraceIndex);
-        }
+  }`;
+
+        const onNewIntentCode = `
+  override fun onNewIntent(intent: Intent) {
+    super.onNewIntent(intent)
+    setIntent(intent)
+  }`;
+
+        // Use a more flexible regex for the class definition
+        const classRegex = /class MainActivity\s*:\s*ReactActivity\(\)\s*\{/;
+
         if (!contents.includes('override fun onCreate')) {
-            const lastBraceIndex = contents.lastIndexOf('}');
-            contents = contents.slice(0, lastBraceIndex) + onCreateCode + contents.slice(lastBraceIndex);
+            contents = contents.replace(classRegex, (match) => `${match}${onCreateCode}`);
+        }
+
+        if (!contents.includes('override fun onNewIntent')) {
+            // Re-run match check because contents might have changed from onCreate injection
+            contents = contents.replace(classRegex, (match) => `${match}${onNewIntentCode}`);
         }
 
         config.modResults.contents = contents;
@@ -47,79 +66,115 @@ function withAndroidConfig(config) {
         const manifest = config.modResults;
         const application = manifest.manifest.application[0];
 
-        // Comprehensive list for VoIP & Foreground Services
+        // Ensure MainActivity flags
+        const mainActivity = application.activity.find((a) => a.$['android:name'] === '.MainActivity');
+        if (mainActivity) {
+            mainActivity.$['android:launchMode'] = 'singleTop';
+            mainActivity.$['android:showWhenLocked'] = 'false';
+            mainActivity.$['android:turnScreenOn'] = 'true';
+        }
+
         const permissions = [
             'android.permission.USE_FULL_SCREEN_INTENT',
             'android.permission.VIBRATE',
             'android.permission.FOREGROUND_SERVICE',
             'android.permission.FOREGROUND_SERVICE_PHONE_CALL',
             'android.permission.POST_NOTIFICATIONS',
-            'android.permission.SYSTEM_ALERT_WINDOW',
             'android.permission.WAKE_LOCK',
             'android.permission.DISABLE_KEYGUARD',
-            'android.permission.MANAGE_OWN_CALLS'
+            'android.permission.SYSTEM_ALERT_WINDOW'
         ];
 
+        // Initialize permissions array if missing
         manifest.manifest['uses-permission'] = manifest.manifest['uses-permission'] || [];
+
         permissions.forEach((perm) => {
             if (!manifest.manifest['uses-permission'].some((p) => p.$['android:name'] === perm)) {
                 manifest.manifest['uses-permission'].push({ $: { 'android:name': perm } });
             }
         });
 
+        // Initialize components if missing
+        application.service = application.service || [];
         application.activity = application.activity || [];
-        // AcceptCallActivity registration
-        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',
-                    'android:showWhenLocked': 'true',
-                    'android:turnScreenOn': 'true'
-                }
-            });
-        }
+        application.receiver = application.receiver || [];
 
-        application.service = application.service || [];
+        // 1. Services
+        const services = [
+            { name: 'com.rnsnativecall.CallMessagingService', exported: 'false', filter: 'com.google.firebase.MESSAGING_EVENT' },
+            { name: 'com.rnsnativecall.CallForegroundService', type: 'phoneCall' },
+            { name: 'com.rnsnativecall.CallHeadlessTask' }
+        ];
 
-        // 1. Firebase Messaging Service
-        const firebaseServiceName = 'com.rnsnativecall.CallMessagingService';
-        if (!application.service.some(s => s.$['android:name'] === firebaseServiceName)) {
-            application.service.push({
-                $: { 'android:name': firebaseServiceName, 'android:exported': 'false' },
-                'intent-filter': [{ action: [{ $: { 'android:name': 'com.google.firebase.MESSAGING_EVENT' } }] }]
-            });
-        }
+        services.forEach(svc => {
+            if (!application.service.some(s => s.$['android:name'] === svc.name)) {
+                const entry = { $: { 'android:name': svc.name, 'android:exported': svc.exported || 'false' } };
+                if (svc.type) entry.$['android:foregroundServiceType'] = svc.type;
+                if (svc.filter) {
+                    entry['intent-filter'] = [{ action: [{ $: { 'android:name': svc.filter } }] }];
+                }
+                application.service.push(entry);
+            }
+        });
 
-        // 2. Headless Task Service
-        const headlessServiceName = 'com.rnsnativecall.CallHeadlessTask';
-        if (!application.service.some(s => s.$['android:name'] === headlessServiceName)) {
-            application.service.push({
-                $: { 'android:name': headlessServiceName, 'android:exported': 'false' }
-            });
-        }
+        // 2. Activities (Trampoline & Overlay)
+        const activities = [
+            {
+                name: 'com.rnsnativecall.AcceptCallActivity',
+                theme: '@android:style/Theme.Translucent.NoTitleBar',
+                launchMode: 'singleInstance'
+            },
+            {
+                name: 'com.rnsnativecall.NotificationOverlayActivity',
+                theme: '@android:style/Theme.NoTitleBar.Fullscreen',
+                launchMode: 'singleInstance'
+            }
+        ];
+
+        activities.forEach(act => {
+            if (!application.activity.some(a => a.$['android:name'] === act.name)) {
+                application.activity.push({
+                    $: {
+                        'android:name': act.name,
+                        'android:theme': act.theme,
+                        'android:exported': 'false',
+                        'android:showWhenLocked': 'true',
+                        'android:turnScreenOn': 'true',
+                        'android:excludeFromRecents': 'true',
+                        'android:noHistory': 'true',
+                        'android:launchMode': act.launchMode
+                    }
+                });
+            }
+        });
 
-        // 3. Foreground Service (The "Connecting..." spinner)
-        const foregroundServiceName = 'com.rnsnativecall.CallForegroundService';
-        if (!application.service.some(s => s.$['android:name'] === foregroundServiceName)) {
-            application.service.push({
+        // 3. Receiver
+        if (!application.receiver.some(r => r.$['android:name'] === 'com.rnsnativecall.CallActionReceiver')) {
+            application.receiver.push({
                 $: {
-                    'android:name': foregroundServiceName,
-                    'android:foregroundServiceType': 'phoneCall',
+                    'android:name': 'com.rnsnativecall.CallActionReceiver',
                     'android:exported': 'false'
                 }
             });
         }
 
-        application.receiver = application.receiver || [];
-        const receiverName = 'com.rnsnativecall.CallActionReceiver';
-        if (!application.receiver.some(r => r.$['android:name'] === receiverName)) {
+        // ADD THIS: UnlockReceiver with USER_PRESENT filter
+        if (!application.receiver.some(r => r.$['android:name'] === 'com.rnsnativecall.UnlockReceiver')) {
             application.receiver.push({
-                $: { 'android:name': receiverName, 'android:exported': 'false' }
+                $: {
+                    'android:name': 'com.rnsnativecall.UnlockReceiver',
+                    'android:exported': 'true',
+                    'android:enabled': 'true',
+                    'android:directBootAware': 'true', // Helps bypass some background restrictions
+                },
+                'intent-filter': [
+                    {
+                        $: { 'android:priority': '1000' },
+                        action: [
+                            { $: { 'android:name': 'android.intent.action.USER_PRESENT' } }
+                        ]
+                    }
+                ]
             });
         }
 
@@ -132,13 +187,20 @@ function withIosConfig(config) {
     return withInfoPlist(config, (config) => {
         const infoPlist = config.modResults;
         if (!infoPlist.UIBackgroundModes) infoPlist.UIBackgroundModes = [];
-        ['voip', 'audio'].forEach(mode => {
-            if (!infoPlist.UIBackgroundModes.includes(mode)) infoPlist.UIBackgroundModes.push(mode);
+
+        ['voip', 'audio', 'remote-notification'].forEach(mode => {
+            if (!infoPlist.UIBackgroundModes.includes(mode)) {
+                infoPlist.UIBackgroundModes.push(mode);
+            }
         });
         return config;
     });
 }
 
 module.exports = (config) => {
-    return withPlugins(config, [withAndroidConfig, withMainActivityDataFix, withIosConfig]);
-};
+    return withPlugins(config, [
+        withAndroidConfig,
+        withMainActivityDataFix,
+        withIosConfig
+    ]);
+};  

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

@@ -1,55 +0,0 @@
-package com.rnsnativecall
-
-import android.app.Activity
-import android.app.KeyguardManager
-import android.content.Context
-import android.content.Intent
-import android.os.Build
-import android.os.Bundle
-import android.view.WindowManager
-
-class UnlockPromptActivity : Activity() {
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-
-        // Ensure this activity shows over the lockscreen to trigger the prompt
-        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
-            )
-        }
-
-        val km = getSystemService(Context.KEYGUARD_SERVICE) as KeyguardManager
-        
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            km.requestDismissKeyguard(this, object : KeyguardManager.KeyguardDismissCallback() {
-                override fun onDismissSucceeded() {
-                    super.onDismissSucceeded()
-                    // Unlock successful, launch the main app
-                    val launchIntent = packageManager.getLaunchIntentForPackage(packageName)
-                    startActivity(launchIntent)
-                    finish()
-                }
-
-                override fun onDismissCancelled() {
-                    super.onDismissCancelled()
-                    finish()
-                }
-
-                override fun onDismissError() {
-                    super.onDismissError()
-                    finish()
-                }
-            })
-        } else {
-            // Fallback for older Android versions
-            val launchIntent = packageManager.getLaunchIntentForPackage(packageName)
-            startActivity(launchIntent)
-            finish()
-        }
-    }
-}