@capgo/capacitor-stream-call 0.0.26 → 0.0.28

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

@@ -48,8 +48,21 @@ 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.CallSessionStartedEvent
-import io.getstream.android.video.generated.models.VideoEvent
 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.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.CameraDirection
+import android.content.BroadcastReceiver
+import android.content.Intent
+import android.content.IntentFilter
 
 // 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
@@ -58,7 +71,6 @@ public class StreamCallPlugin : Plugin() {
     private var streamVideoClient: StreamVideo? = null
     private var state: State = State.NOT_INITIALIZED
     private var overlayView: ComposeView? = null
-    private var incomingCallView: ComposeView? = null
     private var barrierView: View? = null
     private var ringtonePlayer: RingtonePlayer? = null
     private val mainHandler = Handler(Looper.getMainLooper())
@@ -69,12 +81,17 @@ public class StreamCallPlugin : Plugin() {
     private var savedActivityPaused = false
     private var savedCallsToEndOnResume = mutableListOf<Call>()
     private val callStates: MutableMap<String, LocalCallState> = mutableMapOf()
-    
+
     // Store current call info
     private var currentCallId: String = ""
     private var currentCallType: String = ""
     private var currentCallState: String = ""
 
+    // Add a field for the fragment
+    private var callFragment: StreamCallFragment? = null
+    private var streamVideo: StreamVideo? = null
+    private var touchInterceptWrapper: TouchInterceptWrapper? = null
+
     private enum class State {
         NOT_INITIALIZED,
         INITIALIZING,
@@ -118,7 +135,7 @@ public class StreamCallPlugin : Plugin() {
                     val companionField = callServiceClass.getDeclaredField("Companion")
                     companionField.isAccessible = true
                     val companionInstance = companionField.get(null)
-                    
+
                     val removeIncomingCallMethod = companionClass.getDeclaredMethod(
                         "removeIncomingCall",
                         Context::class.java,
@@ -150,64 +167,81 @@ public class StreamCallPlugin : Plugin() {
         initializeStreamVideo()
         setupViews()
         super.load()
+        checkPermissions()
+        // Register broadcast receiver for ACCEPT_CALL action with high priority
+        val filter = IntentFilter("io.getstream.video.android.action.ACCEPT_CALL")
+        filter.priority = 999 // Set high priority to ensure it captures the intent
+        androidx.core.content.ContextCompat.registerReceiver(activity, acceptCallReceiver, filter, androidx.core.content.ContextCompat.RECEIVER_NOT_EXPORTED)
+        android.util.Log.d("StreamCallPlugin", "Registered broadcast receiver for ACCEPT_CALL action with high priority")
+
+        // Start the background service to keep the app alive
+        val serviceIntent = Intent(activity, StreamCallBackgroundService::class.java)
+        activity.startService(serviceIntent)
+        android.util.Log.d("StreamCallPlugin", "Started StreamCallBackgroundService to keep app alive")
 
         // Handle initial intent if present
         activity?.intent?.let { handleOnNewIntent(it) }
+
+        // process the very first intent that started the app (if any)
+        pendingIntent?.let {
+            android.util.Log.d("StreamCallPlugin","Processing saved initial intent")
+            handleOnNewIntent(it)
+            pendingIntent = null
+        }
     }
 
     @OptIn(DelicateCoroutinesApi::class)
     override fun handleOnNewIntent(intent: android.content.Intent) {
+        android.util.Log.d("StreamCallPlugin", "handleOnNewIntent called: action=${intent.action}, data=${intent.data}, extras=${intent.extras}")
         super.handleOnNewIntent(intent)
-        
+
         val action = intent.action
         val data = intent.data
         val extras = intent.extras
+        android.util.Log.d("StreamCallPlugin", "handleOnNewIntent: Parsed action: $action")
 
         if (action === "io.getstream.video.android.action.INCOMING_CALL") {
+            android.util.Log.d("StreamCallPlugin", "handleOnNewIntent: Matched INCOMING_CALL action")
             activity?.runOnUiThread {
                 val cid = intent.streamCallId(NotificationHandler.INTENT_EXTRA_CALL_CID)
+                android.util.Log.d("StreamCallPlugin", "handleOnNewIntent: INCOMING_CALL - Extracted cid: $cid")
                 if (cid != null) {
+                    android.util.Log.d("StreamCallPlugin", "handleOnNewIntent: INCOMING_CALL - cid is not null, processing.")
                     val call = streamVideoClient?.call(id = cid.id, type = cid.type)
-                    // Start playing ringtone
+                    android.util.Log.d("StreamCallPlugin", "handleOnNewIntent: INCOMING_CALL - Got call object: ${call?.id}")
+                    // Start ringtone only; UI handled in web layer
                     ringtonePlayer?.startRinging()
-                    // let's set a barrier. This will prevent the user from interacting with the webview while the calling screen is loading
-                    // Launch a coroutine to handle the suspend function
-                    showBarrier()
 
-                    kotlinx.coroutines.GlobalScope.launch {
-                        call?.get()
-                        activity?.runOnUiThread {
-                            incomingCallView?.setContent {
-                                IncomingCallView(
-                                    streamVideo = streamVideoClient,
-                                    call = call,
-                                    onDeclineCall = { declinedCall ->
-                                        declineCall(declinedCall)
-                                    },
-                                    onAcceptCall = { acceptedCall ->
-                                        internalAcceptCall(acceptedCall)
-                                    },
-                                    onHideIncomingCall = {
-                                        hideIncomingCall()
-                                    }
-                                )
-                            }
-                            incomingCallView?.isVisible = true
-                            hideBarrier()
+                    // Notify WebView/JS about incoming call so it can render its own UI
+                    try {
+                        val payload = com.getcapacitor.JSObject().apply {
+                            put("cid", cid.cid)
+                            put("type", "incoming")
                         }
+                        notifyListeners("incomingCall", payload, true)
+                    } catch (e: Exception) {
+                        android.util.Log.e("StreamCallPlugin", "Error notifying JS about incoming call", e)
                     }
+
+                    bringAppToForeground()
+                } else {
+                    android.util.Log.w("StreamCallPlugin", "handleOnNewIntent: INCOMING_CALL - cid is null. Cannot process.")
                 }
             }
         } else if (action === "io.getstream.video.android.action.ACCEPT_CALL") {
-            // it's a strategic placed initializeStreamVideo. I want to register the even listeners
-            // (which are not initialized during the first load in initialization by the application class)
-            // initializeStreamVideo()
+            android.util.Log.d("StreamCallPlugin", "handleOnNewIntent: Matched ACCEPT_CALL action")
             val cid = intent.streamCallId(NotificationHandler.INTENT_EXTRA_CALL_CID)
+            android.util.Log.d("StreamCallPlugin", "handleOnNewIntent: ACCEPT_CALL - Extracted cid: $cid")
             if (cid != null) {
+                android.util.Log.d("StreamCallPlugin", "handleOnNewIntent: ACCEPT_CALL - Accepting call with cid: $cid")
                 val call = streamVideoClient?.call(id = cid.id, type = cid.type)
-                kotlinx.coroutines.GlobalScope.launch {
-                    call?.get()
-                    call?.let { internalAcceptCall(it) }
+                if (call != null) {
+                    kotlinx.coroutines.GlobalScope.launch {
+                        internalAcceptCall(call)
+                    }
+                    bringAppToForeground()
+                } else {
+                    android.util.Log.e("StreamCallPlugin", "handleOnNewIntent: ACCEPT_CALL - Call object is null for cid: $cid")
                 }
             }
         }
@@ -217,18 +251,26 @@ public class StreamCallPlugin : Plugin() {
         android.util.Log.d("StreamCallPlugin", "New Intent - Extras: $extras")
     }
 
+    // Public method to handle ACCEPT_CALL intent from MainActivity
+    @JvmOverloads
+    public fun handleAcceptCallIntent(intent: android.content.Intent) {
+        android.util.Log.d("StreamCallPlugin", "handleAcceptCallIntent called: action=${intent.action}")
+        handleOnNewIntent(intent)
+    }
+
     @OptIn(DelicateCoroutinesApi::class)
     private fun declineCall(call: Call) {
+        android.util.Log.d("StreamCallPlugin", "declineCall called for call: ${call.id}")
         kotlinx.coroutines.GlobalScope.launch {
             try {
                 call.reject()
-                
+
                 // Stop ringtone
                 ringtonePlayer?.stopRinging()
-                
+
                 // Notify that call has ended using our helper
                 updateCallStatusAndNotify(call.id, "rejected")
-                
+
                 hideIncomingCall()
             } catch (e: Exception) {
                 android.util.Log.e("StreamCallPlugin", "Error declining call: ${e.message}")
@@ -238,14 +280,7 @@ public class StreamCallPlugin : Plugin() {
 
     private fun hideIncomingCall() {
         activity?.runOnUiThread {
-            incomingCallView?.isVisible = false
-            // Stop ringtone if it's still playing
-            ringtonePlayer?.stopRinging()
-            // Check if device is locked using KeyguardManager
-            val keyguardManager = context.getSystemService(Context.KEYGUARD_SERVICE) as KeyguardManager
-            if (keyguardManager.isKeyguardLocked) {
-                activity.moveTaskToBack(true)
-            }
+            // No dedicated incoming-call native view anymore; UI handled by web layer
         }
     }
 
@@ -263,35 +298,46 @@ public class StreamCallPlugin : Plugin() {
 
     private fun setupViews() {
         val context = context
-        val parent = bridge?.webView?.parent as? ViewGroup ?: return
+        val originalParent = bridge?.webView?.parent as? ViewGroup ?: return
+
+        // Wrap original parent with TouchInterceptWrapper to allow touch passthrough
+        val rootParent = originalParent.parent as? ViewGroup
+        val indexInRoot = rootParent?.indexOfChild(originalParent) ?: -1
+        if (rootParent != null && indexInRoot >= 0) {
+            rootParent.removeViewAt(indexInRoot)
+            touchInterceptWrapper = TouchInterceptWrapper(originalParent).apply {
+                setBackgroundColor(android.graphics.Color.TRANSPARENT)
+            }
+            rootParent.addView(touchInterceptWrapper, indexInRoot)
+        }
 
-        // Make WebView transparent
-        bridge?.webView?.setBackgroundColor(Color.TRANSPARENT)
+        val parent: ViewGroup = touchInterceptWrapper ?: originalParent
 
-        // Create and add overlay view below WebView
+        // Make WebView initially visible and opaque
+        bridge?.webView?.setBackgroundColor(Color.WHITE) // Or whatever background color suits your app
+
+        // Create and add overlay view below WebView for calls
         overlayView = ComposeView(context).apply {
-            isVisible = false
+            isVisible = false // Start invisible until a call starts
             layoutParams = FrameLayout.LayoutParams(
                 ViewGroup.LayoutParams.MATCH_PARENT,
                 ViewGroup.LayoutParams.MATCH_PARENT
             )
             setContent {
-                CallOverlayView(
-                    context = context,
-                    streamVideo = streamVideoClient,
-                    call = null
-                )
+                VideoTheme {
+                    val activeCall = streamVideoClient?.state?.activeCall?.collectAsState()?.value
+                    if (activeCall != null) {
+                        CallContent(
+                            call = activeCall,
+                            onBackPressed = { /* Handle back press if needed */ }
+                        )
+                    }
+                }
             }
         }
         parent.addView(overlayView, 0)  // Add at index 0 to ensure it's below WebView
 
-        val originalContainer: ViewGroup = getBridge().webView
-
-        val wrapper = TouchInterceptWrapper(parent)
-        (parent.parent as ViewGroup).removeView(originalContainer)
-        (parent.parent as ViewGroup).addView(wrapper, 0)
-
-        // Create barrier view
+        // Create barrier view (above webview for blocking interaction during call setup)
         barrierView = View(context).apply {
             isVisible = false
             layoutParams = FrameLayout.LayoutParams(
@@ -301,19 +347,6 @@ public class StreamCallPlugin : Plugin() {
             setBackgroundColor(Color.parseColor("#1a242c"))
         }
         parent.addView(barrierView, parent.indexOfChild(bridge?.webView) + 1) // Add above WebView
-
-        // Create and add incoming call view
-        incomingCallView = ComposeView(context).apply {
-            isVisible = false
-            layoutParams = FrameLayout.LayoutParams(
-                ViewGroup.LayoutParams.MATCH_PARENT,
-                ViewGroup.LayoutParams.MATCH_PARENT
-            )
-            setContent {
-                IncomingCallView(streamVideoClient)
-            }
-        }
-        parent.addView(incomingCallView, parent.indexOfChild(bridge?.webView) + 2)  // Add above WebView
     }
 
     @PluginMethod
@@ -363,7 +396,7 @@ public class StreamCallPlugin : Plugin() {
         try {
             // Clear stored credentials
             SecureUserRepository.getInstance(context).removeCurrentUser()
-            
+
             // Properly cleanup the client
             kotlinx.coroutines.GlobalScope.launch {
                 streamVideoClient?.let {
@@ -386,7 +419,7 @@ public class StreamCallPlugin : Plugin() {
 
     @OptIn(DelicateCoroutinesApi::class)
     public fun initializeStreamVideo(passedContext: Context? = null, passedApplication: Application? = null) {
-        android.util.Log.v("StreamCallPlugin", "Attempting to initialize streamVideo")
+        android.util.Log.d("StreamCallPlugin", "initializeStreamVideo called")
         if (state == State.INITIALIZING) {
             android.util.Log.v("StreamCallPlugin", "Returning, already in the process of initializing")
             return
@@ -473,9 +506,9 @@ public class StreamCallPlugin : Plugin() {
             val notificationConfig = NotificationConfig(
                 pushDeviceGenerators = listOf(
                     FirebasePushDeviceGenerator(
-                    providerName = "firebase",
-                    context = contextToUse
-                )
+                        providerName = "firebase",
+                        context = contextToUse
+                    )
                 ),
                 requestPermissionOnAppLaunch = { true },
                 notificationHandler = notificationHandler,
@@ -506,7 +539,7 @@ public class StreamCallPlugin : Plugin() {
             }
 
             registerEventHandlers()
-            
+
             android.util.Log.v("StreamCallPlugin", "Initialization finished")
             initializationTime = System.currentTimeMillis()
             state = State.INITIALIZED
@@ -571,15 +604,23 @@ public class StreamCallPlugin : Plugin() {
                     // Handle CallCreatedEvent differently - only log it but don't try to access members yet
                     is CallCreatedEvent -> {
                         val callCid = event.callCid
-                        android.util.Log.d("StreamCallPlugin", "Call created: $callCid")
+                        android.util.Log.d("StreamCallPlugin", "CallCreatedEvent: Received for $callCid")
+                        android.util.Log.d("StreamCallPlugin", "CallCreatedEvent: All members from event: ${event.members.joinToString { it.user.id + " (role: " + it.user.role + ")" }}")
+                        android.util.Log.d("StreamCallPlugin", "CallCreatedEvent: Self user ID from SDK: ${this@StreamCallPlugin.streamVideoClient?.userId}")
 
-                        // let's get the members
-                        val callParticipants = event.members.filter{ it.user.id != this@StreamCallPlugin.streamVideoClient?.userId }.map { it.user.id }
-                        android.util.Log.d("StreamCallPlugin", "Call created for $callCid with ${callParticipants.size} participants")
+                        val callParticipants = event.members.filter {
+                            val selfId = this@StreamCallPlugin.streamVideoClient?.userId
+                            val memberId = it.user.id
+                            val isSelf = memberId == selfId
+                            android.util.Log.d("StreamCallPlugin", "CallCreatedEvent: Filtering member $memberId. Self ID: $selfId. Is self: $isSelf")
+                            !isSelf
+                        }.map { it.user.id }
+
+                        android.util.Log.d("StreamCallPlugin", "Call created for $callCid with ${callParticipants.size} remote participants: ${callParticipants.joinToString()}.")
 
                         // Start tracking this call now that we have the member list
                         startCallTimeoutMonitor(callCid, callParticipants)
-                        
+
                         // Use direction from event if available
                         val callType = callCid.split(":").firstOrNull() ?: "default"
                         updateCallStatusAndNotify(callCid, "created")
@@ -589,61 +630,61 @@ public class StreamCallPlugin : Plugin() {
                         val callCid = event.callCid
                         updateCallStatusAndNotify(callCid, "session_started")
                     }
-                    
+
                     is CallRejectedEvent -> {
                         val userId = event.user.id
                         val callCid = event.callCid
-                        
+
                         // Update call state
                         callStates[callCid]?.let { callState ->
                             callState.participantResponses[userId] = "rejected"
                         }
-                        
+
                         updateCallStatusAndNotify(callCid, "rejected", userId)
-                        
+
                         // Check if all participants have responded
                         checkAllParticipantsResponded(callCid)
                     }
-                    
+
                     is CallMissedEvent -> {
                         val userId = event.user.id
                         val callCid = event.callCid
-                        
+
                         // Update call state
                         callStates[callCid]?.let { callState ->
                             callState.participantResponses[userId] = "missed"
                         }
-                        
+
                         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)
                         }
-                        
+
                         updateCallStatusAndNotify(callCid, "missed", userId)
-                        
+
                         // Check if all participants have responded
                         checkAllParticipantsResponded(callCid)
                     }
-                    
+
                     is CallAcceptedEvent -> {
                         val userId = event.user.id
                         val callCid = event.callCid
-                        
+
                         // Update call state
                         callStates[callCid]?.let { callState ->
                             callState.participantResponses[userId] = "accepted"
-                            
+
                             // Since someone accepted, cancel the timeout timer
                             android.util.Log.d("StreamCallPlugin", "Call accepted by $userId, canceling timeout timer for $callCid")
                             callState.timer?.removeCallbacksAndMessages(null)
                             callState.timer = null
                         }
-                        
+
                         updateCallStatusAndNotify(callCid, "accepted", userId)
                     }
-                    
+
                     is CallEndedEvent -> {
                         runOnMainThread {
                             android.util.Log.d("StreamCallPlugin", "Setting overlay invisible due to CallEndedEvent for call ${event.callCid}")
@@ -653,7 +694,7 @@ public class StreamCallPlugin : Plugin() {
                         }
                         updateCallStatusAndNotify(event.callCid, "left")
                     }
-                    
+
                     is CallSessionEndedEvent -> {
                         runOnMainThread {
                             android.util.Log.d("StreamCallPlugin", "Setting overlay invisible due to CallSessionEndedEvent for call ${event.callCid}. Test session: ${event.call.session?.endedAt}")
@@ -663,7 +704,7 @@ public class StreamCallPlugin : Plugin() {
                         }
                         updateCallStatusAndNotify(event.callCid, "left")
                     }
-                    
+
                     else -> {
                         updateCallStatusAndNotify(
                             streamVideoClient?.state?.activeCall?.value?.cid ?: "",
@@ -749,6 +790,7 @@ public class StreamCallPlugin : Plugin() {
 
     @PluginMethod
     public fun acceptCall(call: PluginCall) {
+        android.util.Log.d("StreamCallPlugin", "acceptCall called")
         try {
             val streamVideoCall = streamVideoClient?.state?.ringingCall?.value
             if (streamVideoCall == null) {
@@ -766,6 +808,7 @@ public class StreamCallPlugin : Plugin() {
 
     @PluginMethod
     public fun rejectCall(call: PluginCall) {
+        android.util.Log.d("StreamCallPlugin", "rejectCall called")
         try {
             val streamVideoCall = streamVideoClient?.state?.ringingCall?.value
             if (streamVideoCall == null) {
@@ -782,38 +825,120 @@ public class StreamCallPlugin : Plugin() {
     }
 
     @OptIn(DelicateCoroutinesApi::class)
-    private fun internalAcceptCall(call: Call) {
+    internal fun internalAcceptCall(call: Call) {
+        android.util.Log.d("StreamCallPlugin", "internalAcceptCall: Entered for call: ${call.id}")
         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 {
-                    android.util.Log.d("StreamCallPlugin", "Hiding incoming call view for call ${call.id}")
-                    incomingCallView?.isVisible = false
+                    android.util.Log.d("StreamCallPlugin", "internalAcceptCall: Hiding incoming call view for call ${call.id}")
+                    // No dedicated incoming-call native view anymore; UI handled by web layer
+                }
+                android.util.Log.d("StreamCallPlugin", "internalAcceptCall: Incoming call view hidden for call ${call.id}")
+
+                // Check and request permissions before joining the call
+                val permissionsGranted = checkPermissions()
+                android.util.Log.d("StreamCallPlugin", "internalAcceptCall: checkPermissions result for call ${call.id}: $permissionsGranted")
+                if (!permissionsGranted) {
+                    android.util.Log.d("StreamCallPlugin", "internalAcceptCall: Permissions not granted for call ${call.id}. Requesting permissions.")
+                    requestPermissions()
+                    // Do not proceed with joining until permissions are granted
+                    runOnMainThread {
+                        android.widget.Toast.makeText(
+                            context,
+                            "Permissions required for call. Please grant them.",
+                            android.widget.Toast.LENGTH_LONG
+                        ).show()
+                    }
+                    android.util.Log.w("StreamCallPlugin", "internalAcceptCall: Permissions not granted for call ${call.id}. Aborting accept process.")
+                    return@launch
                 }
 
+                android.util.Log.d("StreamCallPlugin", "internalAcceptCall: Permissions are granted for call ${call.id}. Proceeding to accept.")
                 // Join the call without affecting others
                 call.accept()
+                android.util.Log.d("StreamCallPlugin", "internalAcceptCall: call.accept() completed for call ${call.id}")
+                call.join()
+                android.util.Log.d("StreamCallPlugin", "internalAcceptCall: call.join() completed for call ${call.id}")
+                streamVideoClient?.state?.setActiveCall(call)
+                android.util.Log.d("StreamCallPlugin", "internalAcceptCall: setActiveCall completed for call ${call.id}")
 
                 // Notify that call has started using helper
                 updateCallStatusAndNotify(call.id, "joined")
+                android.util.Log.d("StreamCallPlugin", "internalAcceptCall: updateCallStatusAndNotify(joined) called for ${call.id}")
 
-                // Show overlay view with the active call
+                // Show overlay view with the active call and make webview transparent
                 runOnMainThread {
-                    android.util.Log.d("StreamCallPlugin", "Setting overlay visible after accepting call ${call.id}")
+                    android.util.Log.d("StreamCallPlugin", "internalAcceptCall: Updating UI for active call ${call.id} - setting overlay visible.")
+                    bridge?.webView?.setBackgroundColor(Color.TRANSPARENT) // Make webview transparent
+                    android.util.Log.d("StreamCallPlugin", "internalAcceptCall: WebView background set to transparent for call ${call.id}")
+                    bridge?.webView?.bringToFront() // Ensure WebView is on top and transparent
+                    android.util.Log.d("StreamCallPlugin", "internalAcceptCall: WebView brought to front for call ${call.id}")
+                    // Reusing the initialization logic from call method
+                    call.microphone?.setEnabled(true)
+                    call.camera?.setEnabled(true)
+                    android.util.Log.d("StreamCallPlugin", "internalAcceptCall: Microphone and camera enabled for call ${call.id}")
                     overlayView?.setContent {
-                        CallOverlayView(
-                            context = context,
-                            streamVideo = streamVideoClient,
-                            call = call
-                        )
+                        VideoTheme {
+                            if (call != null) {
+                                android.util.Log.d("StreamCallPlugin", "internalAcceptCall: Setting CallContent with active call ${call.id}")
+                                CallContent(
+                                    call = call,
+                                    onBackPressed = { /* ... */ },
+                                    controlsContent = { /* ... */ },
+                                    appBarContent = { /* ... */ }
+                                )
+                            } else {
+                                android.util.Log.w("StreamCallPlugin", "internalAcceptCall: Active call is null, cannot set CallContent for call ${call.id}")
+                            }
+                        }
                     }
+                    android.util.Log.d("StreamCallPlugin", "internalAcceptCall: Content set for overlayView for call ${call.id}")
                     overlayView?.isVisible = true
+                    android.util.Log.d("StreamCallPlugin", "internalAcceptCall: OverlayView set to visible for call ${call.id}, isVisible: ${overlayView?.isVisible}")
+
+                    // Ensure overlay is behind WebView by adjusting its position in the parent
+                    val parent = overlayView?.parent as? ViewGroup
+                    parent?.removeView(overlayView)
+                    parent?.addView(overlayView, 0) // Add at index 0 to ensure it's behind other views
+                    android.util.Log.d("StreamCallPlugin", "internalAcceptCall: OverlayView re-added to parent at index 0 for call ${call.id}")
+                    // Add a small delay to ensure UI refresh
+                    mainHandler.postDelayed({
+                        android.util.Log.d("StreamCallPlugin", "internalAcceptCall: Delayed UI check, overlay visible: ${overlayView?.isVisible} for call ${call.id}")
+                        if (overlayView?.isVisible == true) {
+                            overlayView?.invalidate()
+                            overlayView?.requestLayout()
+                            android.util.Log.d("StreamCallPlugin", "internalAcceptCall: UI invalidated and layout requested for call ${call.id}")
+                            // Force refresh with active call from client
+                            val activeCall = streamVideoClient?.state?.activeCall?.value
+                            if (activeCall != null) {
+                                overlayView?.setContent {
+                                    VideoTheme {
+                                        android.util.Log.d("StreamCallPlugin", "internalAcceptCall: Force refreshing CallContent with active call ${activeCall.id}")
+                                        CallContent(
+                                            call = activeCall,
+                                            onBackPressed = { /* ... */ },
+                                            controlsContent = { /* ... */ },
+                                            appBarContent = { /* ... */ }
+                                        )
+                                    }
+                                }
+                                android.util.Log.d("StreamCallPlugin", "internalAcceptCall: Content force refreshed for call ${activeCall.id}")
+                            } else {
+                                android.util.Log.w("StreamCallPlugin", "internalAcceptCall: Active call is null during force refresh for call ${call.id}")
+                            }
+                        } else {
+                            android.util.Log.w("StreamCallPlugin", "internalAcceptCall: overlayView not visible after delay for call ${call.id}")
+                        }
+                    }, 1000) // Increased delay to ensure all events are processed
                 }
             } catch (e: Exception) {
-                android.util.Log.e("StreamCallPlugin", "Error accepting call ${call.id}: ${e.message}")
+                android.util.Log.e("StreamCallPlugin", "internalAcceptCall: Error accepting call ${call.id}: ${e.message}", e)
                 runOnMainThread {
                     android.widget.Toast.makeText(
                         context,
@@ -825,6 +950,74 @@ public class StreamCallPlugin : Plugin() {
         }
     }
 
+    // Function to check required permissions
+    private fun checkPermissions(): Boolean {
+        android.util.Log.d("StreamCallPlugin", "checkPermissions: Entered")
+        val audioPermission = ContextCompat.checkSelfPermission(context, Manifest.permission.RECORD_AUDIO)
+        android.util.Log.d("StreamCallPlugin", "checkPermissions: RECORD_AUDIO permission status: $audioPermission (Granted=${PackageManager.PERMISSION_GRANTED})")
+        val cameraPermission = ContextCompat.checkSelfPermission(context, Manifest.permission.CAMERA)
+        android.util.Log.d("StreamCallPlugin", "checkPermissions: CAMERA permission status: $cameraPermission (Granted=${PackageManager.PERMISSION_GRANTED})")
+        val allGranted = audioPermission == PackageManager.PERMISSION_GRANTED && cameraPermission == PackageManager.PERMISSION_GRANTED
+        android.util.Log.d("StreamCallPlugin", "checkPermissions: All permissions granted: $allGranted")
+        return allGranted
+    }
+
+    // Function to request required permissions
+    private fun requestPermissions() {
+        android.util.Log.d("StreamCallPlugin", "requestPermissions: Requesting RECORD_AUDIO and CAMERA permissions.")
+        ActivityCompat.requestPermissions(
+            activity,
+            arrayOf(Manifest.permission.RECORD_AUDIO, Manifest.permission.CAMERA),
+            1001 // Request code for permission result handling
+        )
+        android.util.Log.d("StreamCallPlugin", "requestPermissions: ActivityCompat.requestPermissions called.")
+    }
+
+    // Override to handle permission results
+    override fun handleRequestPermissionsResult(requestCode: Int, permissions: Array<out String>, grantResults: IntArray) {
+        super.handleRequestPermissionsResult(requestCode, permissions, grantResults)
+        android.util.Log.d("StreamCallPlugin", "handleRequestPermissionsResult: Entered. RequestCode: $requestCode")
+        if (requestCode == 1001) {
+            android.util.Log.d("StreamCallPlugin", "handleRequestPermissionsResult: Matched requestCode 1001.")
+            logPermissionResults(permissions, grantResults)
+            if (grantResults.isNotEmpty() && grantResults.all { it == PackageManager.PERMISSION_GRANTED }) {
+                android.util.Log.i("StreamCallPlugin", "handleRequestPermissionsResult: All permissions GRANTED.")
+                // Permissions granted, can attempt to join the call again if needed
+                val ringingCall = streamVideoClient?.state?.ringingCall?.value
+                android.util.Log.d("StreamCallPlugin", "handleRequestPermissionsResult: Ringing call object: ${ringingCall?.id}")
+                if (ringingCall != null) {
+                    android.util.Log.d("StreamCallPlugin", "handleRequestPermissionsResult: Ringing call found (${ringingCall.id}). Re-attempting internalAcceptCall.")
+                    kotlinx.coroutines.GlobalScope.launch {
+                        internalAcceptCall(ringingCall)
+                    }
+                } else {
+                    android.util.Log.w("StreamCallPlugin", "handleRequestPermissionsResult: Permissions granted, but no ringing call found to accept.")
+                }
+            } else {
+                android.util.Log.e("StreamCallPlugin", "handleRequestPermissionsResult: One or more permissions DENIED.")
+                runOnMainThread {
+                    android.widget.Toast.makeText(
+                        context,
+                        "Permissions not granted. Cannot join call.",
+                        android.widget.Toast.LENGTH_LONG
+                    ).show()
+                }
+            }
+        } else {
+            android.util.Log.w("StreamCallPlugin", "handleRequestPermissionsResult: Received unknown requestCode: $requestCode")
+        }
+    }
+
+    private fun logPermissionResults(permissions: Array<out String>, grantResults: IntArray) {
+        android.util.Log.d("StreamCallPlugin", "logPermissionResults: Logging permission results:")
+        for (i in permissions.indices) {
+            val permission = permissions[i]
+            val grantResult = if (grantResults.size > i) grantResults[i] else -999 // -999 for safety if arrays mismatch
+            val resultString = if (grantResult == PackageManager.PERMISSION_GRANTED) "GRANTED" else "DENIED ($grantResult)"
+            android.util.Log.d("StreamCallPlugin", "  Permission: $permission, Result: $resultString")
+        }
+    }
+
     @OptIn(DelicateCoroutinesApi::class)
     @PluginMethod
     fun setMicrophoneEnabled(call: PluginCall) {
@@ -921,14 +1114,14 @@ public class StreamCallPlugin : Plugin() {
         val callId = call.id
         android.util.Log.d("StreamCallPlugin", "Attempting to end call $callId")
         call.leave()
-        
+
         // Capture context from the overlayView
         val currentContext = overlayView?.context ?: this.savedContext
         if (currentContext == null) {
             android.util.Log.w("StreamCallPlugin", "Cannot end call $callId because context is null")
             return
         }
-        
+
         runOnMainThread {
             android.util.Log.d("StreamCallPlugin", "Setting overlay invisible after ending call $callId")
 
@@ -959,20 +1152,24 @@ public class StreamCallPlugin : Plugin() {
             }
 
             overlayView?.setContent {
-                CallOverlayView(
-                    context = currentContext,
-                    streamVideo = streamVideoClient,
-                    call = null
-                )
+                VideoTheme {
+                    CallContent(
+                        call = call,
+                        onBackPressed = { /* Handle back press if needed */ },
+                        controlsContent = { /* Empty to disable native controls */ },
+                        appBarContent = { /* Empty to disable app bar with stop call button */ }
+                    )
+                }
             }
             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")
-            incomingCallView?.isVisible = false
+            // No dedicated incoming-call native view anymore; UI handled by web layer
         }
-        
+
         // Notify that call has ended using helper
         updateCallStatusAndNotify(callId, "left")
     }
@@ -1068,15 +1265,22 @@ public class StreamCallPlugin : Plugin() {
             android.util.Log.d("StreamCallPlugin", "- Users: $userIds")
             android.util.Log.d("StreamCallPlugin", "- Should Ring: $shouldRing")
 
+            // Check permissions before creating the call
+            if (!checkPermissions()) {
+                requestPermissions()
+                call.reject("Permissions required for call. Please grant them.")
+                return
+            }
+
             // Create and join call in a coroutine
             kotlinx.coroutines.GlobalScope.launch {
                 try {
                     // Create the call object
                     val streamCall = streamVideoClient?.call(type = callType, id = callId)
-                    
+
                     // Note: We no longer start tracking here - we'll wait for CallSessionStartedEvent
                     // instead, which contains the actual participant list
-                    
+
                     android.util.Log.d("StreamCallPlugin", "Creating call with members...")
                     // Create the call with all members
                     val createResult = streamCall?.create(
@@ -1085,9 +1289,9 @@ public class StreamCallPlugin : Plugin() {
                         ring = shouldRing,
                         team = team,
                     )
-                    
+
                     if (createResult?.isFailure == true) {
-                       throw (createResult.errorOrNull() ?: RuntimeException("Unknown error creating call")) as Throwable
+                        throw (createResult.errorOrNull() ?: RuntimeException("Unknown error creating call")) as Throwable
                     }
 
                     android.util.Log.d("StreamCallPlugin", "Setting overlay visible for outgoing call $callId")
@@ -1096,14 +1300,25 @@ public class StreamCallPlugin : Plugin() {
                         streamCall?.microphone?.setEnabled(true)
                         streamCall?.camera?.setEnabled(true)
 
+                        bridge?.webView?.setBackgroundColor(Color.TRANSPARENT) // Make webview transparent
+                        bridge?.webView?.bringToFront() // Ensure WebView is on top and transparent
                         overlayView?.setContent {
-                            CallOverlayView(
-                                context = context,
-                                streamVideo = streamVideoClient,
-                                call = streamCall
-                            )
+                            VideoTheme {
+                                if (streamCall != null) {
+                                    CallContent(
+                                        call = streamCall,
+                                        onBackPressed = { /* Handle back press if needed */ },
+                                        controlsContent = { /* Empty to disable native controls */ },
+                                        appBarContent = { /* Empty to disable app bar with stop call button */ }
+                                    )
+                                }
+                            }
                         }
                         overlayView?.isVisible = true
+                        // Ensure overlay is behind WebView by adjusting its position in the parent
+                        val parent = overlayView?.parent as? ViewGroup
+                        parent?.removeView(overlayView)
+                        parent?.addView(overlayView, 0) // Add at index 0 to ensure it's behind other views
                     }
 
                     // Resolve the call with success
@@ -1122,7 +1337,7 @@ public class StreamCallPlugin : Plugin() {
 
     private fun startCallTimeoutMonitor(callCid: String, memberIds: List<String>) {
         val callState = LocalCallState(members = memberIds)
-        
+
         val handler = Handler(Looper.getMainLooper())
         val timeoutRunnable = object : Runnable {
             override fun run() {
@@ -1130,55 +1345,55 @@ public class StreamCallPlugin : Plugin() {
                 handler.postDelayed(this, 1000)
             }
         }
-        
+
         handler.postDelayed(timeoutRunnable, 1000)
         callState.timer = handler
-        
+
         callStates[callCid] = callState
-        
+
         android.util.Log.d("StreamCallPlugin", "Started timeout monitor for call $callCid with ${memberIds.size} members")
     }
 
     private fun checkCallTimeout(callCid: String) {
         val callState = callStates[callCid] ?: return
-        
+
         val now = System.currentTimeMillis()
         val elapsedSeconds = (now - callState.createdAt) / 1000
-        
+
         if (elapsedSeconds >= 30) {
             android.util.Log.d("StreamCallPlugin", "Call $callCid has timed out after $elapsedSeconds seconds")
-            
+
             val hasAccepted = callState.participantResponses.values.any { it == "accepted" }
-            
+
             if (!hasAccepted) {
                 android.util.Log.d("StreamCallPlugin", "No one accepted call $callCid, marking all non-responders as missed")
-                
+
                 // First, remove the timer to prevent further callbacks
                 callState.timer?.removeCallbacksAndMessages(null)
                 callState.timer = null
-                
+
                 callState.members.forEach { memberId ->
                     if (memberId !in callState.participantResponses) {
                         callState.participantResponses[memberId] = "missed"
-                        
+
                         updateCallStatusAndNotify(callCid, "missed", memberId)
                     }
                 }
-                
+
                 val callIdParts = callCid.split(":")
                 if (callIdParts.size >= 2) {
                     val callType = callIdParts[0]
                     val callId = callIdParts[1]
-                    
+
                     streamVideoClient?.call(type = callType, id = callId)?.let { call ->
                         kotlinx.coroutines.GlobalScope.launch {
                             try {
                                 // Use endCallRaw instead of manual cleanup
                                 endCallRaw(call)
-                                
+
                                 // Clean up state - we don't need to do this in endCallRaw because we already did it here
                                 callStates.remove(callCid)
-                                
+
                                 // Notify that call has ended using helper
                                 updateCallStatusAndNotify(callCid, "ended", null, "timeout")
                             } catch (e: Exception) {
@@ -1194,62 +1409,62 @@ public class StreamCallPlugin : Plugin() {
     private fun cleanupCall(callCid: String) {
         // Get the call state
         val callState = callStates[callCid]
-        
+
         if (callState != null) {
             // Ensure timer is properly canceled
             android.util.Log.d("StreamCallPlugin", "Stopping timer for call: $callCid")
             callState.timer?.removeCallbacksAndMessages(null)
             callState.timer = null
         }
-        
+
         // Remove from callStates
         callStates.remove(callCid)
-        
+
         // Hide UI elements directly without setting content
         runOnMainThread {
             android.util.Log.d("StreamCallPlugin", "Hiding UI elements for call $callCid (one-time cleanup)")
             overlayView?.isVisible = false
             ringtonePlayer?.stopRinging()
-            incomingCallView?.isVisible = false
+            // No dedicated incoming-call native view anymore; UI handled by web layer
         }
-        
+
         android.util.Log.d("StreamCallPlugin", "Cleaned up resources for ended call: $callCid")
     }
 
     private fun checkAllParticipantsResponded(callCid: String) {
         val callState = callStates[callCid] ?: return
-        
+
         val totalParticipants = callState.members.size
         val responseCount = callState.participantResponses.size
-        
+
         android.util.Log.d("StreamCallPlugin", "Checking responses for call $callCid: $responseCount / $totalParticipants")
-        
+
         val allResponded = responseCount >= totalParticipants
-        val allRejectedOrMissed = allResponded && 
-            callState.participantResponses.values.all { it == "rejected" || it == "missed" }
-        
+        val allRejectedOrMissed = allResponded &&
+                callState.participantResponses.values.all { it == "rejected" || it == "missed" }
+
         if (allResponded && allRejectedOrMissed) {
             android.util.Log.d("StreamCallPlugin", "All participants have rejected or missed the call $callCid")
-            
+
             // Cancel the timer immediately to prevent further callbacks
             callState.timer?.removeCallbacksAndMessages(null)
             callState.timer = null
-            
+
             // End the call using endCallRaw
             val callIdParts = callCid.split(":")
             if (callIdParts.size >= 2) {
                 val callType = callIdParts[0]
                 val callId = callIdParts[1]
-                
+
                 streamVideoClient?.call(type = callType, id = callId)?.let { call ->
                     kotlinx.coroutines.GlobalScope.launch {
                         try {
                             // Use endCallRaw instead of manual cleanup
                             endCallRaw(call)
-                            
+
                             // Clean up state - we don't need to do this in endCallRaw because we already did it here
                             callStates.remove(callCid)
-                            
+
                             // Notify that call has ended using helper
                             updateCallStatusAndNotify(callCid, "ended", null, "all_rejected_or_missed")
                         } catch (e: Exception) {
@@ -1291,23 +1506,58 @@ public class StreamCallPlugin : Plugin() {
         val result = JSObject()
         result.put("callId", currentCallId)
         result.put("state", currentCallState)
-        
+
         // No additional fields to ensure compatibility with CallEvent interface
-        
+
         call.resolve(result)
     }
 
+    @PluginMethod
+    fun setSpeaker(call: PluginCall) {
+        val name = call.getString("name") ?: "speaker"
+        val activeCall = streamVideoClient?.state?.activeCall?.value
+        if (activeCall != null) {
+            if (name == "speaker")
+                activeCall.speaker.setSpeakerPhone(enable = true)
+            else
+                activeCall.speaker.setSpeakerPhone(enable = false)
+            call.resolve(JSObject().apply {
+                put("success", true)
+            })
+        } else {
+            call.reject("No active call")
+        }
+    }
+
+    @PluginMethod
+    fun switchCamera(call: PluginCall) {
+        val camera = call.getString("camera") ?: "front"
+        val activeCall = streamVideoClient?.state?.activeCall?.value
+        if (activeCall != null) {
+            if (camera == "front")
+                activeCall.camera.setDirection(CameraDirection.Front)
+            else
+                activeCall.camera.setDirection(CameraDirection.Back)
+            call.resolve(JSObject().apply {
+                put("success", true)
+            })
+        } else {
+            call.reject("No active call")
+        }
+    }
+    
     // Helper method to update call status and notify listeners
     private fun updateCallStatusAndNotify(callId: String, state: String, userId: String? = null, reason: String? = null) {
+        android.util.Log.d("StreamCallPlugin", "updateCallStatusAndNotify called: callId=$callId, state=$state, userId=$userId, reason=$reason")
         // Update stored call info
         currentCallId = callId
         currentCallState = state
-        
+
         // Get call type from call ID if available
         if (callId.contains(":")) {
             currentCallType = callId.split(":").firstOrNull() ?: ""
         }
-        
+
         // Create data object with only the fields in the CallEvent interface
         val data = JSObject().apply {
             put("callId", callId)
@@ -1319,15 +1569,102 @@ public class StreamCallPlugin : Plugin() {
                 put("reason", it)
             }
         }
-        
+
         // Notify listeners
         notifyListeners("callEvent", data)
     }
 
+    @PluginMethod
+    fun joinCall(call: PluginCall) {
+        val fragment = callFragment
+        if (fragment != null && fragment.getCall() != null) {
+            if (!checkPermissions()) {
+                requestPermissions()
+                call.reject("Permissions required for call. Please grant them.")
+                return
+            }
+            CoroutineScope(Dispatchers.Main).launch {
+                fragment.getCall()?.join()
+                call.resolve()
+            }
+        } else {
+            call.reject("No active call or fragment not initialized")
+        }
+    }
+
+    @PluginMethod
+    fun leaveCall(call: PluginCall) {
+        val fragment = callFragment
+        if (fragment != null && fragment.getCall() != null) {
+            CoroutineScope(Dispatchers.Main).launch {
+                fragment.getCall()?.leave()
+                call.resolve()
+            }
+        } else {
+            call.reject("No active call or fragment not initialized")
+        }
+    }
+
     data class LocalCallState(
         val members: List<String>,
         val participantResponses: MutableMap<String, String> = mutableMapOf(),
         val createdAt: Long = System.currentTimeMillis(),
         var timer: Handler? = null
     )
+
+    private val acceptCallReceiver = object : BroadcastReceiver() {
+        override fun onReceive(context: Context?, intent: Intent?) {
+            android.util.Log.d("StreamCallPlugin", "BroadcastReceiver: Received broadcast with action: ${intent?.action}")
+            if (intent?.action == "io.getstream.video.android.action.ACCEPT_CALL") {
+                val cid = intent.streamCallId(NotificationHandler.INTENT_EXTRA_CALL_CID)
+                android.util.Log.d("StreamCallPlugin", "BroadcastReceiver: ACCEPT_CALL broadcast received with cid: $cid")
+                if (cid != null) {
+                    android.util.Log.d("StreamCallPlugin", "BroadcastReceiver: Accepting call with cid: $cid")
+                    val call = streamVideoClient?.call(id = cid.id, type = cid.type)
+                    if (call != null) {
+                        kotlinx.coroutines.GlobalScope.launch {
+                            internalAcceptCall(call)
+                        }
+                        bringAppToForeground()
+                    } else {
+                        android.util.Log.e("StreamCallPlugin", "BroadcastReceiver: Call object is null for cid: $cid")
+                    }
+                }
+            }
+        }
+    }
+
+    private fun bringAppToForeground() {
+        try {
+            val ctx = savedContext ?: context
+            val launchIntent = ctx.packageManager.getLaunchIntentForPackage(ctx.packageName)
+            launchIntent?.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_REORDER_TO_FRONT or Intent.FLAG_ACTIVITY_SINGLE_TOP)
+            if (launchIntent != null) {
+                ctx.startActivity(launchIntent)
+                android.util.Log.d("StreamCallPlugin", "bringAppToForeground: Launch intent executed to foreground app")
+            } else {
+                android.util.Log.w("StreamCallPlugin", "bringAppToForeground: launchIntent is null")
+            }
+        } catch (e: Exception) {
+            android.util.Log.e("StreamCallPlugin", "bringAppToForeground error", e)
+        }
+    }
+
+    companion object {
+        private var pendingIntent: Intent? = null
+        @JvmStatic fun saveInitialIntent(it: Intent) {
+            pendingIntent = it
+        }
+        @JvmStatic fun preLoadInit(ctx: Context, app: Application) {
+            holder ?: run {
+                val p = StreamCallPlugin()
+                p.savedContext = ctx
+                p.initializeStreamVideo(ctx, app)
+                holder = p
+                // record the intent that started the process
+                if (ctx is Activity) saveInitialIntent((ctx as Activity).intent)
+            }
+        }
+        private var holder: StreamCallPlugin? = null
+    }
 }