@capgo/capacitor-stream-call 0.0.56 → 0.0.62

package/android/build.gradle

@@ -75,8 +75,8 @@ dependencies {
     implementation "androidx.compose.material3:material3:1.3.2"
     
     // Stream dependencies
-    implementation("io.getstream:stream-video-android-ui-compose:1.6.1")
-    implementation("io.getstream:stream-video-android-core:1.6.1")
+    implementation("io.getstream:stream-video-android-ui-compose:1.6.3")
+    implementation("io.getstream:stream-video-android-core:1.6.3")
     implementation("io.getstream:stream-android-push:1.3.1")
     implementation("io.getstream:stream-android-push-firebase:1.3.1")
     

package/android/src/main/java/ee/forgr/capacitor/streamcall/CustomNotificationHandler.kt

@@ -13,7 +13,8 @@ import io.getstream.video.android.core.RingingState
 import io.getstream.video.android.core.notifications.DefaultNotificationHandler
 import io.getstream.video.android.core.notifications.NotificationHandler
 import io.getstream.video.android.model.StreamCallId
- 
+import io.getstream.video.android.model.streamCallId
+
 // declare "incoming_calls_custom" as a constant
 const val INCOMING_CALLS_CUSTOM = "incoming_calls_custom"
  
@@ -76,7 +77,7 @@ class CustomNotificationHandler(
             }
             acceptCallIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_SINGLE_TOP)
 
-            Log.d("CustomNotificationHandler", "Constructed Accept Call Intent for PI: action=${acceptCallIntent.action}, cid=${acceptCallIntent.getStringExtra(NotificationHandler.INTENT_EXTRA_CALL_CID)}, package=${acceptCallIntent.getPackage()}, component=${acceptCallIntent.component?.flattenToString()}, flags=${acceptCallIntent.flags}")
+            Log.d("CustomNotificationHandler", "Constructed Accept Call Intent for PI: action=${acceptCallIntent.action}, cid=${acceptCallIntent.streamCallId(NotificationHandler.INTENT_EXTRA_CALL_CID)}, package=${acceptCallIntent.getPackage()}, component=${acceptCallIntent.component?.flattenToString()}, flags=${acceptCallIntent.flags}")
 
             // Create PendingIntent for Accept action using getActivity to launch the app
             val requestCodeAccept = callId.cid.hashCode() + 1 // Unique request code for the PendingIntent with offset to avoid collisions
@@ -150,7 +151,7 @@ class CustomNotificationHandler(
         )
     }
  
-    fun buildNotification(
+    private fun buildNotification(
         fullScreenPendingIntent: PendingIntent,
         acceptCallPendingIntent: PendingIntent,
         rejectCallPendingIntent: PendingIntent,

package/android/src/main/java/ee/forgr/capacitor/streamcall/RingtonePlayer.kt

@@ -31,26 +31,26 @@ class RingtonePlayer(
 
     fun pauseRinging() {
         Log.d("RingtonePlayer", "Pause ringing")
-        try {
-            if (!isStopped) {
-                mediaPlayer?.pause()
-                isPaused = true
-            }
-        } catch (e: Exception) {
-            Log.e("RingtonePlayer", "Error pausing ringtone: ${e.message}")
-        }
+//        try {
+//            if (!isStopped) {
+//                mediaPlayer?.pause()
+//                isPaused = true
+//            }
+//        } catch (e: Exception) {
+//            Log.e("RingtonePlayer", "Error pausing ringtone: ${e.message}")
+//        }
     }
 
     fun resumeRinging() {
         Log.d("RingtonePlayer", "Resume ringing")
-        try {
-            if (!isStopped && isPaused) {
-                mediaPlayer?.start()
-                isPaused = false
-            }
-        } catch (e: Exception) {
-            Log.e("RingtonePlayer", "Error resuming ringtone: ${e.message}")
-        }
+//        try {
+//            if (!isStopped && isPaused) {
+//                mediaPlayer?.start()
+//                isPaused = false
+//            }
+//        } catch (e: Exception) {
+//            Log.e("RingtonePlayer", "Error resuming ringtone: ${e.message}")
+//        }
     }
 
     fun isPaused(): Boolean {
@@ -59,103 +59,103 @@ class RingtonePlayer(
 
     fun startRinging() {
         Log.d("RingtonePlayer", "Start ringing")
-        try {
-            isStopped = false
-            isPaused = false
-            if (mediaPlayer == null) {
-                val uri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE)
-                mediaPlayer = MediaPlayer().apply {
-                    setDataSource(application, uri)
-                    isLooping = true
-                    setAudioAttributes(
-                        AudioAttributes.Builder()
-                            .setUsage(AudioAttributes.USAGE_NOTIFICATION_RINGTONE)
-                            .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
-                            .build()
-                    )
-                    prepare()
-                }
-            }
-
-            val notificationManager = application.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-            val notifs = notificationManager.activeNotifications.toList()
-            var notificationTime = 0L
-
-            for (notification in notifs) {
-                // First check if it's our notification
-                val isOurs = isOurNotification(notification)
-
-                // Only proceed with ringtone if it's our notification
-                if (!isOurs) {
-                    Log.d("RingtonePlayer", "Skipping notification as it's not our incoming call notification")
-                    continue
-                }
-
-                // Cancel our notification
-                try {
-                    Log.d("RingtonePlayer", "Canceling notification/service with id: ${notification.id}")
-                    this.cancelIncomingCallService()
-                } catch (e: Exception) {
-                    Log.e("RingtonePlayer", "Error cancelling notification: ${e.message}")
-                }
-                notificationTime = notification.postTime
-            }
-
-            if (notificationTime > 0) {
-                val currentTime = System.currentTimeMillis()
-                val elapsedTime = currentTime - notificationTime
-
-                // Only start playing if we're within the ringtone duration
-                if (elapsedTime < DEFAULT_RINGTONE_DURATION) {
-                    // Get the ringtone duration
-                    val ringtoneDuration = mediaPlayer?.duration?.toLong() ?: DEFAULT_RINGTONE_DURATION
-                    
-                    // Calculate the position to seek to
-                    val seekPosition = (elapsedTime % ringtoneDuration).toInt()
-                    Log.d("RingtonePlayer", "Seeking to position: $seekPosition ms in ringtone")
-                    
-                    mediaPlayer?.seekTo(seekPosition)
-                    mediaPlayer?.start()
-
-                    // Schedule stop at the remaining duration
-                    val remainingDuration = DEFAULT_RINGTONE_DURATION - elapsedTime
-                    stopRingtoneRunnable = Runnable { stopRinging() }
-                    handler.postDelayed(stopRingtoneRunnable!!, remainingDuration)
-                    
-                    Log.d("RingtonePlayer", "Starting ringtone with offset: $elapsedTime ms, will play for $remainingDuration ms")
-                } else {
-                    Log.d("RingtonePlayer", "Not starting ringtone as elapsed time ($elapsedTime ms) exceeds duration")
-                }
-            } else {
-                // If no notification time found, just play normally
-                mediaPlayer?.start()
-                
-                // Schedule stop at the default duration
-                stopRingtoneRunnable = Runnable { stopRinging() }
-                handler.postDelayed(stopRingtoneRunnable!!, DEFAULT_RINGTONE_DURATION)
-                
-                Log.d("RingtonePlayer", "Starting ringtone with default duration")
-            }
-        } catch (e: Exception) {
-            Log.e("RingtonePlayer", "Error playing ringtone: ${e.message}")
-        }
+//        try {
+//            isStopped = false
+//            isPaused = false
+//            if (mediaPlayer == null) {
+//                val uri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE)
+//                mediaPlayer = MediaPlayer().apply {
+//                    setDataSource(application, uri)
+//                    isLooping = true
+//                    setAudioAttributes(
+//                        AudioAttributes.Builder()
+//                            .setUsage(AudioAttributes.USAGE_NOTIFICATION_RINGTONE)
+//                            .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
+//                            .build()
+//                    )
+//                    prepare()
+//                }
+//            }
+//
+//            val notificationManager = application.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+//            val notifs = notificationManager.activeNotifications.toList()
+//            var notificationTime = 0L
+//
+//            for (notification in notifs) {
+//                // First check if it's our notification
+//                val isOurs = isOurNotification(notification)
+//
+//                // Only proceed with ringtone if it's our notification
+//                if (!isOurs) {
+//                    Log.d("RingtonePlayer", "Skipping notification as it's not our incoming call notification")
+//                    continue
+//                }
+//
+//                // Cancel our notification
+//                try {
+//                    Log.d("RingtonePlayer", "Canceling notification/service with id: ${notification.id}")
+//                    this.cancelIncomingCallService()
+//                } catch (e: Exception) {
+//                    Log.e("RingtonePlayer", "Error cancelling notification: ${e.message}")
+//                }
+//                notificationTime = notification.postTime
+//            }
+//
+//            if (notificationTime > 0) {
+//                val currentTime = System.currentTimeMillis()
+//                val elapsedTime = currentTime - notificationTime
+//
+//                // Only start playing if we're within the ringtone duration
+//                if (elapsedTime < DEFAULT_RINGTONE_DURATION) {
+//                    // Get the ringtone duration
+//                    val ringtoneDuration = mediaPlayer?.duration?.toLong() ?: DEFAULT_RINGTONE_DURATION
+//
+//                    // Calculate the position to seek to
+//                    val seekPosition = (elapsedTime % ringtoneDuration).toInt()
+//                    Log.d("RingtonePlayer", "Seeking to position: $seekPosition ms in ringtone")
+//
+//                    mediaPlayer?.seekTo(seekPosition)
+//                    mediaPlayer?.start()
+//
+//                    // Schedule stop at the remaining duration
+//                    val remainingDuration = DEFAULT_RINGTONE_DURATION - elapsedTime
+//                    stopRingtoneRunnable = Runnable { stopRinging() }
+//                    handler.postDelayed(stopRingtoneRunnable!!, remainingDuration)
+//
+//                    Log.d("RingtonePlayer", "Starting ringtone with offset: $elapsedTime ms, will play for $remainingDuration ms")
+//                } else {
+//                    Log.d("RingtonePlayer", "Not starting ringtone as elapsed time ($elapsedTime ms) exceeds duration")
+//                }
+//            } else {
+//                // If no notification time found, just play normally
+//                mediaPlayer?.start()
+//
+//                // Schedule stop at the default duration
+//                stopRingtoneRunnable = Runnable { stopRinging() }
+//                handler.postDelayed(stopRingtoneRunnable!!, DEFAULT_RINGTONE_DURATION)
+//
+//                Log.d("RingtonePlayer", "Starting ringtone with default duration")
+//            }
+//        } catch (e: Exception) {
+//            Log.e("RingtonePlayer", "Error playing ringtone: ${e.message}")
+//        }
     }
 
     fun stopRinging() {
         Log.d("RingtonePlayer", "Stop ringing")
-        try {
-            isStopped = true
-            isPaused = false
-            stopRingtoneRunnable?.let { handler.removeCallbacks(it) }
-            stopRingtoneRunnable = null
-            
-            mediaPlayer?.stop()
-            mediaPlayer?.reset()
-            mediaPlayer?.release()
-            mediaPlayer = null
-        } catch (e: Exception) {
-            Log.e("RingtonePlayer", "Error stopping ringtone: ${e.message}")
-        }
+//        try {
+//            isStopped = true
+//            isPaused = false
+//            stopRingtoneRunnable?.let { handler.removeCallbacks(it) }
+//            stopRingtoneRunnable = null
+//
+//            mediaPlayer?.stop()
+//            mediaPlayer?.reset()
+//            mediaPlayer?.release()
+//            mediaPlayer = null
+//        } catch (e: Exception) {
+//            Log.e("RingtonePlayer", "Error stopping ringtone: ${e.message}")
+//        }
     }
 
 

package/android/src/main/java/ee/forgr/capacitor/streamcall/StreamCallPlugin.kt

@@ -1,45 +1,42 @@
 package ee.forgr.capacitor.streamcall
 
 import TouchInterceptWrapper
+import android.Manifest
 import android.app.Activity
 import android.app.Application
 import android.app.KeyguardManager
+import android.content.BroadcastReceiver
 import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.content.pm.PackageManager
 import android.graphics.Color
 import android.media.RingtoneManager
 import android.net.Uri
+import android.os.Build
 import android.os.Bundle
 import android.os.Handler
 import android.os.Looper
 import android.view.View
 import android.view.ViewGroup
+import android.view.WindowManager
 import android.widget.FrameLayout
+import androidx.compose.runtime.collectAsState
 import androidx.compose.ui.platform.ComposeView
+import androidx.core.app.ActivityCompat
+import androidx.core.content.ContextCompat
 import androidx.core.view.isVisible
 import com.getcapacitor.BridgeActivity
+import com.getcapacitor.JSArray
 import com.getcapacitor.JSObject
 import com.getcapacitor.Plugin
 import com.getcapacitor.PluginCall
 import com.getcapacitor.PluginMethod
 import com.getcapacitor.annotation.CapacitorPlugin
-import io.getstream.android.push.permissions.ActivityLifecycleCallbacks
-import io.getstream.video.android.core.Call
-import io.getstream.video.android.core.GEO
-import io.getstream.video.android.core.StreamVideo
-import io.getstream.video.android.core.StreamVideoBuilder
-import io.getstream.video.android.core.notifications.NotificationConfig
-import io.getstream.video.android.core.notifications.NotificationHandler
-import io.getstream.video.android.core.sounds.toSounds
-import io.getstream.video.android.model.StreamCallId
-import io.getstream.video.android.model.User
-import io.getstream.video.android.model.streamCallId
-import kotlinx.coroutines.DelicateCoroutinesApi
-import kotlinx.coroutines.launch
-import io.getstream.video.android.model.Device
-import kotlinx.coroutines.tasks.await
 import com.google.firebase.messaging.FirebaseMessaging
 import io.getstream.android.push.PushProvider
 import io.getstream.android.push.firebase.FirebasePushDeviceGenerator
+import io.getstream.android.push.permissions.ActivityLifecycleCallbacks
 import io.getstream.android.video.generated.models.CallAcceptedEvent
 import io.getstream.android.video.generated.models.CallCreatedEvent
 import io.getstream.android.video.generated.models.CallEndedEvent
@@ -47,26 +44,36 @@ import io.getstream.android.video.generated.models.CallMissedEvent
 import io.getstream.android.video.generated.models.CallRejectedEvent
 import io.getstream.android.video.generated.models.CallRingEvent
 import io.getstream.android.video.generated.models.CallSessionEndedEvent
+import io.getstream.android.video.generated.models.CallSessionParticipantLeftEvent
 import io.getstream.android.video.generated.models.CallSessionStartedEvent
-import io.getstream.video.android.core.sounds.RingingConfig
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import android.Manifest
-import android.content.pm.PackageManager
-import androidx.core.app.ActivityCompat
-import androidx.core.content.ContextCompat
 import io.getstream.android.video.generated.models.VideoEvent
+import io.getstream.log.Priority
 import io.getstream.video.android.compose.theme.VideoTheme
 import io.getstream.video.android.compose.ui.components.call.activecall.CallContent
-import androidx.compose.runtime.collectAsState
+import io.getstream.video.android.core.Call
 import io.getstream.video.android.core.CameraDirection
-import android.content.BroadcastReceiver
-import android.content.Intent
-import android.content.IntentFilter
-import com.getcapacitor.JSArray
-import io.getstream.android.video.generated.models.CallSessionParticipantLeftEvent
+import io.getstream.video.android.core.GEO
 import io.getstream.video.android.core.RealtimeConnection
+import io.getstream.video.android.core.StreamVideo
+import io.getstream.video.android.core.StreamVideoBuilder
+import io.getstream.video.android.core.call.CallType
 import io.getstream.video.android.core.events.ParticipantLeftEvent
+import io.getstream.video.android.core.logging.LoggingLevel
+import io.getstream.video.android.core.notifications.NotificationConfig
+import io.getstream.video.android.core.notifications.NotificationHandler
+import io.getstream.video.android.core.notifications.internal.service.CallServiceConfigRegistry
+import io.getstream.video.android.core.notifications.internal.service.DefaultCallConfigurations
+import io.getstream.video.android.core.sounds.RingingConfig
+import io.getstream.video.android.core.sounds.toSounds
+import io.getstream.video.android.model.Device
+import io.getstream.video.android.model.StreamCallId
+import io.getstream.video.android.model.User
+import io.getstream.video.android.model.streamCallId
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.DelicateCoroutinesApi
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.tasks.await
 
 // I am not a religious pearson, but at this point, I am not sure even god himself would understand this code
 // It's a spaghetti-like, tangled, unreadable mess and frankly, I am deeply sorry for the code crimes commited in the Android impl
@@ -76,7 +83,6 @@ public class StreamCallPlugin : Plugin() {
     private var state: State = State.NOT_INITIALIZED
     private var overlayView: ComposeView? = null
     private var barrierView: View? = null
-    private var ringtonePlayer: RingtonePlayer? = null
     private val mainHandler = Handler(Looper.getMainLooper())
     private var savedContext: Context? = null
     private var bootedToHandleCall: Boolean = false
@@ -112,62 +118,15 @@ public class StreamCallPlugin : Plugin() {
     }
 
     override fun handleOnPause() {
-        this.ringtonePlayer.let { it?.pauseRinging() }
         super.handleOnPause()
     }
 
     override fun handleOnResume() {
-        this.ringtonePlayer.let { it?.resumeRinging() }
         super.handleOnResume()
     }
 
     override fun load() {
         // general init
-        ringtonePlayer = RingtonePlayer(
-            this.activity.application,
-            cancelIncomingCallService = {
-                val streamVideoClient = this.streamVideoClient
-                if (streamVideoClient == null) {
-                    android.util.Log.d("StreamCallPlugin", "StreamVideo SDK client is null, no incoming call notification can be constructed")
-                    return@RingtonePlayer
-                }
-
-                try {
-                    val callServiceClass = Class.forName("io.getstream.video.android.core.notifications.internal.service.CallService")
-                    val companionClass = callServiceClass.declaredClasses.first { it.simpleName == "Companion" }
-                    // Instead of getting INSTANCE, we'll get the companion object through the enclosing class
-                    val companionField = callServiceClass.getDeclaredField("Companion")
-                    companionField.isAccessible = true
-                    val companionInstance = companionField.get(null)
-
-                    val removeIncomingCallMethod = companionClass.getDeclaredMethod(
-                        "removeIncomingCall",
-                        Context::class.java,
-                        Class.forName("io.getstream.video.android.model.StreamCallId"),
-                        Class.forName("io.getstream.video.android.core.notifications.internal.service.CallServiceConfig")
-                    )
-                    removeIncomingCallMethod.isAccessible = true
-
-                    // Get the default config using reflection
-                    val defaultConfigClass = Class.forName("io.getstream.video.android.core.notifications.internal.service.DefaultCallConfigurations")
-                    val defaultField = defaultConfigClass.getDeclaredField("INSTANCE")
-                    val defaultInstance = defaultField.get(null)
-                    val defaultMethod = defaultConfigClass.getDeclaredMethod("getDefault")
-                    val defaultConfig = defaultMethod.invoke(defaultInstance)
-
-                    val app = this.activity.application
-                    val cId = streamVideoClient.state.ringingCall.value?.cid?.let { StreamCallId.fromCallCid(it) }
-                    if (app == null || cId == null || defaultConfig == null) {
-                        android.util.Log.e("StreamCallPlugin", "Some required parameters are null - app: ${app == null}, cId: ${cId == null}, defaultConfig: ${defaultConfig == null}")
-                    }
-
-                    // Call the method
-                    removeIncomingCallMethod.invoke(companionInstance, app, cId, defaultConfig)
-                } catch (e : Throwable) {
-                    android.util.Log.e("StreamCallPlugin", "Reflecting streamNotificationManager and the config DID NOT work", e);
-                }
-            }
-        )
         initializeStreamVideo()
         setupViews()
         super.load()
@@ -206,6 +165,8 @@ public class StreamCallPlugin : Plugin() {
 
         if (action === "io.getstream.video.android.action.INCOMING_CALL") {
             android.util.Log.d("StreamCallPlugin", "handleOnNewIntent: Matched INCOMING_CALL action")
+            // We need to make sure the activity is visible on locked screen in such case
+            changeActivityAsVisibleOnLockScreen(this@StreamCallPlugin.activity, true)
             activity?.runOnUiThread {
                 val cid = intent.streamCallId(NotificationHandler.INTENT_EXTRA_CALL_CID)
                 android.util.Log.d("StreamCallPlugin", "handleOnNewIntent: INCOMING_CALL - Extracted cid: $cid")
@@ -213,8 +174,6 @@ public class StreamCallPlugin : Plugin() {
                     android.util.Log.d("StreamCallPlugin", "handleOnNewIntent: INCOMING_CALL - cid is not null, processing.")
                     val call = streamVideoClient?.call(id = cid.id, type = cid.type)
                     android.util.Log.d("StreamCallPlugin", "handleOnNewIntent: INCOMING_CALL - Got call object: ${call?.id}")
-                    // Start ringtone only; UI handled in web layer
-                    ringtonePlayer?.startRinging()
 
                     // Try to get caller information from the call
                     kotlinx.coroutines.GlobalScope.launch {
@@ -296,9 +255,7 @@ public class StreamCallPlugin : Plugin() {
         kotlinx.coroutines.GlobalScope.launch {
             try {
                 call.reject()
-
-                // Stop ringtone
-                ringtonePlayer?.stopRinging()
+                changeActivityAsVisibleOnLockScreen(this@StreamCallPlugin.activity, false)
 
                 // Notify that call has ended using our helper
                 updateCallStatusAndNotify(call.id, "rejected")
@@ -547,6 +504,7 @@ public class StreamCallPlugin : Plugin() {
             )
 
             val soundsConfig = incomingOnlyRingingConfig()
+
             // Initialize StreamVideo client
             streamVideoClient = StreamVideoBuilder(
                 context = contextToUse,
@@ -555,8 +513,8 @@ public class StreamCallPlugin : Plugin() {
                 user = savedCredentials.user,
                 token = savedCredentials.tokenValue,
                 notificationConfig = notificationConfig,
-                sounds = soundsConfig.toSounds()
-                //, loggingLevel = LoggingLevel(priority = Priority.VERBOSE)
+                sounds = soundsConfig.toSounds(),
+                // loggingLevel = LoggingLevel(priority = Priority.DEBUG)
             ).build()
 
             // don't do event handler registration when activity may be null
@@ -758,7 +716,6 @@ public class StreamCallPlugin : Plugin() {
                         val keyguardManager = context.getSystemService(Context.KEYGUARD_SERVICE) as KeyguardManager
                         if (keyguardManager.isKeyguardLocked) {
                             android.util.Log.d("StreamCallPlugin", "Stop ringing and move to background")
-                            this.ringtonePlayer?.stopRinging()
                             moveAllActivitiesToBackgroundOrKill(context)
                         }
 
@@ -865,9 +822,12 @@ public class StreamCallPlugin : Plugin() {
                         // Notify that a call has started or state updated (e.g., participants changed but still active)
                         // The actual check for "last participant" is now handled by CallSessionParticipantLeftEvent
                         updateCallStatusAndNotify(call.cid, "joined")
+                        // Make sure activity is visible on lock screen
+                        changeActivityAsVisibleOnLockScreen(this@StreamCallPlugin.activity, true)
                     } ?: run {
                         // Notify that call has ended using our helper
                         updateCallStatusAndNotify("", "left")
+                        changeActivityAsVisibleOnLockScreen(this@StreamCallPlugin.activity, false)
                     }
                 }
             }
@@ -967,9 +927,6 @@ public class StreamCallPlugin : Plugin() {
         kotlinx.coroutines.GlobalScope.launch {
             try {
                 android.util.Log.d("StreamCallPlugin", "internalAcceptCall: Coroutine started for call ${call.id}")
-                // Stop ringtone
-                ringtonePlayer?.stopRinging()
-                android.util.Log.d("StreamCallPlugin", "internalAcceptCall: Ringtone player stopped for call ${call.id}")
 
                 // Hide incoming call view first
                 runOnMainThread {
@@ -1274,6 +1231,12 @@ public class StreamCallPlugin : Plugin() {
                 android.util.Log.d("StreamCallPlugin", "Leaving call $callId (not creator, >2 participants)")
                 call.leave()
             }
+
+            // Here, we'll also mark the activity as not-visible on lock screen
+            this@StreamCallPlugin.savedActivity?.let {
+                changeActivityAsVisibleOnLockScreen(it, false)
+            }
+
         } catch (e: Exception) {
             android.util.Log.e("StreamCallPlugin", "Error getting call info for $callId, defaulting to leave()", e)
             // Fallback to leave if we can't determine the call info
@@ -1328,7 +1291,6 @@ public class StreamCallPlugin : Plugin() {
             }
             overlayView?.isVisible = false
             bridge?.webView?.setBackgroundColor(Color.WHITE) // Restore webview opacity
-            this@StreamCallPlugin.ringtonePlayer?.stopRinging()
 
             // Also hide incoming call view if visible
             android.util.Log.d("StreamCallPlugin", "Hiding incoming call view for call $callId")
@@ -1339,6 +1301,29 @@ public class StreamCallPlugin : Plugin() {
         updateCallStatusAndNotify(callId, "left")
     }
 
+    private fun changeActivityAsVisibleOnLockScreen(activity: Activity, visible: Boolean) {
+        if (visible) {
+            // Ensure the activity is visible over the lock screen when launched via full-screen intent
+            android.util.Log.d("StreamCallPlugin", "Mark the mainActivity as visible on the lockscreen")
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O_MR1) {
+                activity.setShowWhenLocked(true)
+                activity.setTurnScreenOn(true)
+            } else {
+                activity.getWindow().addFlags(WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED or WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON)
+            }
+        } else {
+            // Ensure the activity is NOT visible over the lock screen when launched via full-screen intent
+            android.util.Log.d("StreamCallPlugin", "Clear the flag for the mainActivity for visible on the lockscreen")
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O_MR1) {
+                activity.setShowWhenLocked(false)
+                activity.setTurnScreenOn(false)
+            } else {
+                activity.getWindow().clearFlags(WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED or WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON)
+            }
+        }
+
+    }
+
     @OptIn(DelicateCoroutinesApi::class)
     private fun transEndCallRaw(call: Call) {
         val callId = call.id
@@ -1595,8 +1580,8 @@ public class StreamCallPlugin : Plugin() {
         runOnMainThread {
             android.util.Log.d("StreamCallPlugin", "Hiding UI elements for call $callCid (one-time cleanup)")
             overlayView?.isVisible = false
-            ringtonePlayer?.stopRinging()
-            // No dedicated incoming-call native view anymore; UI handled by web layer
+            // here we will also make sure we don't show on lock screen
+            changeActivityAsVisibleOnLockScreen(this.activity, false)
         }
 
         android.util.Log.d("StreamCallPlugin", "Cleaned up resources for ended call: $callCid")

package/dist/esm/web.js

@@ -21,18 +21,20 @@ export class StreamCallWeb extends WebPlugin {
                     role: event.call.created_by.role,
                 };
             }
-            if (!this.currentCall) {
-                console.log('Creating new call', event.call.id);
-                this.currentCall = (_b = this.client) === null || _b === void 0 ? void 0 : _b.call(event.call.type, event.call.id);
-                // this.currentActiveCallId = this.currentCall?.cid;
+            // if (!this.currentCall) {
+            console.log('Creating new call', event.call.id);
+            this.currentCall = (_b = this.client) === null || _b === void 0 ? void 0 : _b.call(event.call.type, event.call.id);
+            // this.currentActiveCallId = this.currentCall?.cid;
+            setTimeout(() => {
                 this.notifyListeners('callEvent', {
                     callId: event.call.id,
                     state: CallingState.RINGING,
                     caller,
                 });
-                // Clear previous responses when a new call starts
-                this.participantResponses.clear();
-            }
+            }, 100);
+            // Clear previous responses when a new call starts
+            this.participantResponses.clear();
+            // }
             if (this.currentCall) {
                 console.log('Call found', this.currentCall.id);
                 this.callStateSubscription = (_c = this.currentCall) === null || _c === void 0 ? void 0 : _c.state.callingState$.subscribe((s) => {