@capgo/capacitor-stream-call 0.0.64 → 0.0.66

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

@@ -255,13 +255,6 @@ 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}")
@@ -326,37 +319,64 @@ public class StreamCallPlugin : Plugin() {
                 ViewGroup.LayoutParams.MATCH_PARENT,
                 ViewGroup.LayoutParams.MATCH_PARENT
             )
-            setContent {
-                VideoTheme {
-                    val activeCall = streamVideoClient?.state?.activeCall?.collectAsState()?.value
-                    if (activeCall != null) {
-                        val participants by activeCall.state.participants.collectAsStateWithLifecycle()
-                        val sortedParticipants by activeCall.state.sortedParticipants.collectAsStateWithLifecycle(emptyList())
-                        val callParticipants by remember(participants) {
-                            derivedStateOf {
-                                if (sortedParticipants.size > 6) {
-                                    sortedParticipants
-                                } else {
-                                    participants
-                                }
+        }
+        parent.addView(overlayView, 0)  // Add at index 0 to ensure it's below WebView
+
+        // Initialize with active call content
+        setOverlayContent()
+
+        // Create barrier view (above webview for blocking interaction during call setup)
+        barrierView = View(context).apply {
+            isVisible = false
+            layoutParams = FrameLayout.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                ViewGroup.LayoutParams.MATCH_PARENT
+            )
+            setBackgroundColor(Color.parseColor("#1a242c"))
+        }
+        parent.addView(barrierView, parent.indexOfChild(bridge?.webView) + 1) // Add above WebView
+    }
+
+    /**
+     * Centralized function to set the overlay content with call UI.
+     * This handles all the common Compose UI setup for video calls.
+     */
+    private fun setOverlayContent(call: Call? = null) {
+        overlayView?.setContent {
+            VideoTheme {
+                val activeCall = call ?: streamVideoClient?.state?.activeCall?.collectAsState()?.value
+                if (activeCall != null) {
+                    val participants by activeCall.state.participants.collectAsStateWithLifecycle()
+                    val sortedParticipants by activeCall.state.sortedParticipants.collectAsStateWithLifecycle(emptyList())
+                    val callParticipants by remember(participants) {
+                        derivedStateOf {
+                            if (sortedParticipants.size > 6) {
+                                sortedParticipants
+                            } else {
+                                participants
                             }
                         }
+                    }
 
-                        val currentLocal by activeCall.state.me.collectAsStateWithLifecycle()
-
-                        CallContent(
-                            call = activeCall,
-                            onBackPressed = { /* Handle back press if needed */ },
-                            videoRenderer = { videoModifier, videoCall, videoParticipant, videoStyle ->
-                                ParticipantVideo(
-                                    modifier = videoModifier,
-                                    call = videoCall,
-                                    participant = videoParticipant,
-                                    style = videoStyle,
-                                    actionsContent = {_, _, _ -> {}}
-                                )
-                            },
-                            floatingVideoRenderer = { call, parentSize ->
+                    val currentLocal by activeCall.state.me.collectAsStateWithLifecycle()
+
+                    CallContent(
+                        call = activeCall,
+                        onBackPressed = { /* Handle back press if needed */ },
+                        controlsContent = { /* Empty to disable native controls */ },
+                        appBarContent = { /* Empty to disable app bar with stop call button */ },
+                        videoRenderer = { videoModifier, videoCall, videoParticipant, videoStyle ->
+                            ParticipantVideo(
+                                modifier = videoModifier,
+                                call = videoCall,
+                                participant = videoParticipant,
+                                style = videoStyle,
+                                actionsContent = {_, _, _ -> {}},
+                                scalingType = VideoScalingType.SCALE_ASPECT_FIT
+                            )
+                        },
+                        floatingVideoRenderer = { call, parentSize ->
+                            currentLocal?.let {
                                 FloatingParticipantVideo(
                                     call = call,
                                     participant = currentLocal!!,
@@ -368,30 +388,19 @@ public class StreamCallPlugin : Plugin() {
                                                 .fillMaxSize()
                                                 .clip(VideoTheme.shapes.dialog),
                                             call = call,
-                                            participant = currentLocal!!,
+                                            participant = it,
                                             style = RegularVideoRendererStyle().copy(isShowingConnectionQualityIndicator = false),
                                             actionsContent = {_, _, _ -> {}},
                                         )
                                     }
                                 )
                             }
-                        )
-                    }
+
+                        }
+                    )
                 }
             }
         }
-        parent.addView(overlayView, 0)  // Add at index 0 to ensure it's below WebView
-
-        // Create barrier view (above webview for blocking interaction during call setup)
-        barrierView = View(context).apply {
-            isVisible = false
-            layoutParams = FrameLayout.LayoutParams(
-                ViewGroup.LayoutParams.MATCH_PARENT,
-                ViewGroup.LayoutParams.MATCH_PARENT
-            )
-            setBackgroundColor(Color.parseColor("#1a242c"))
-        }
-        parent.addView(barrierView, parent.indexOfChild(bridge?.webView) + 1) // Add above WebView
     }
 
     @PluginMethod
@@ -1033,65 +1042,8 @@ public class StreamCallPlugin : Plugin() {
                     call.microphone?.setEnabled(true)
                     call.camera?.setEnabled(true)
                     android.util.Log.d("StreamCallPlugin", "internalAcceptCall: Microphone and camera enabled for call ${call.id}")
-                    overlayView?.setContent {
-                        VideoTheme {
-                            if (call != null) {
-                                android.util.Log.d("StreamCallPlugin", "internalAcceptCall: Setting CallContent with active call ${call.id}")
-                                
-                                val participants by call.state.participants.collectAsStateWithLifecycle()
-                                val sortedParticipants by call.state.sortedParticipants.collectAsStateWithLifecycle(emptyList())
-                                val callParticipants by remember(participants) {
-                                    derivedStateOf {
-                                        if (sortedParticipants.size > 6) {
-                                            sortedParticipants
-                                        } else {
-                                            participants
-                                        }
-                                    }
-                                }
-
-                                val currentLocal by call.state.me.collectAsStateWithLifecycle()
-
-                                CallContent(
-                                    call = call,
-                                    onBackPressed = { /* ... */ },
-                                    controlsContent = { /* ... */ },
-                                    appBarContent = { /* ... */ },
-                                    videoRenderer = { videoModifier, videoCall, videoParticipant, videoStyle ->
-                                        ParticipantVideo(
-                                            modifier = videoModifier,
-                                            call = videoCall,
-                                            participant = videoParticipant,
-                                            style = videoStyle,
-                                            actionsContent = {_, _, _ -> {}},
-                                            scalingType = VideoScalingType.SCALE_ASPECT_FIT
-                                        )
-                                    },
-                                    floatingVideoRenderer = { call, parentSize ->
-                                        FloatingParticipantVideo(
-                                            call = call,
-                                            participant = currentLocal!!,
-                                            style = RegularVideoRendererStyle().copy(isShowingConnectionQualityIndicator = false),
-                                            parentBounds = parentSize,
-                                            videoRenderer = { _ ->
-                                                ParticipantVideo(
-                                                    modifier = Modifier
-                                                        .fillMaxSize()
-                                                        .clip(VideoTheme.shapes.dialog),
-                                                    call = call,
-                                                    participant = currentLocal!!,
-                                                    style = RegularVideoRendererStyle().copy(isShowingConnectionQualityIndicator = false),
-                                                    actionsContent = {_, _, _ ->},
-                                                )
-                                            }
-                                        )
-                                    }
-                                )
-                            } else {
-                                android.util.Log.w("StreamCallPlugin", "internalAcceptCall: Active call is null, cannot set CallContent for call ${call.id}")
-                            }
-                        }
-                    }
+                    android.util.Log.d("StreamCallPlugin", "internalAcceptCall: Setting CallContent with active call ${call.id}")
+                    setOverlayContent(call)
                     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}")
@@ -1111,61 +1063,8 @@ public class StreamCallPlugin : Plugin() {
                             // 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}")
-                                        
-                                        val participants by activeCall.state.participants.collectAsStateWithLifecycle()
-                                        val sortedParticipants by activeCall.state.sortedParticipants.collectAsStateWithLifecycle(emptyList())
-                                        val callParticipants by remember(participants) {
-                                            derivedStateOf {
-                                                if (sortedParticipants.size > 6) {
-                                                    sortedParticipants
-                                                } else {
-                                                    participants
-                                                }
-                                            }
-                                        }
-
-                                        val currentLocal by activeCall.state.me.collectAsStateWithLifecycle()
-
-                                        CallContent(
-                                            call = activeCall,
-                                            onBackPressed = { /* ... */ },
-                                            controlsContent = { /* ... */ },
-                                            appBarContent = { /* ... */ },
-                                            videoRenderer = { videoModifier, videoCall, videoParticipant, videoStyle ->
-                                                ParticipantVideo(
-                                                    modifier = videoModifier,
-                                                    call = videoCall,
-                                                    participant = videoParticipant,
-                                                    style = videoStyle,
-                                                    actionsContent = {_, _, _ -> {}},
-                                                    scalingType = VideoScalingType.SCALE_ASPECT_FIT
-                                                )
-                                            },
-                                            floatingVideoRenderer = { call, parentSize ->
-                                                FloatingParticipantVideo(
-                                                    call = call,
-                                                    participant = currentLocal!!,
-                                                    style = RegularVideoRendererStyle().copy(isShowingConnectionQualityIndicator = false),
-                                                    parentBounds = parentSize,
-                                                    videoRenderer = { _ ->
-                                                        ParticipantVideo(
-                                                            modifier = Modifier
-                                                                .fillMaxSize()
-                                                                .clip(VideoTheme.shapes.dialog),
-                                                            call = call,
-                                                            participant = currentLocal!!,
-                                                            style = RegularVideoRendererStyle().copy(isShowingConnectionQualityIndicator = false),
-                                                            actionsContent = {_, _, _ -> {}},
-                                                        )
-                                                    }
-                                                )
-                                            }
-                                        )
-                                    }
-                                }
+                                android.util.Log.d("StreamCallPlugin", "internalAcceptCall: Force refreshing CallContent with active call ${activeCall.id}")
+                                setOverlayContent(activeCall)
                                 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}")
@@ -1424,59 +1323,7 @@ public class StreamCallPlugin : Plugin() {
                 return@runOnMainThread
             }
 
-            overlayView?.setContent {
-                VideoTheme {
-                    val participants by call.state.participants.collectAsStateWithLifecycle()
-                    val sortedParticipants by call.state.sortedParticipants.collectAsStateWithLifecycle(emptyList())
-                    val callParticipants by remember(participants) {
-                        derivedStateOf {
-                            if (sortedParticipants.size > 6) {
-                                sortedParticipants
-                            } else {
-                                participants
-                            }
-                        }
-                    }
-
-                    val currentLocal by call.state.me.collectAsStateWithLifecycle()
-
-                    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 */ },
-                        videoRenderer = { videoModifier, videoCall, videoParticipant, videoStyle ->
-                            ParticipantVideo(
-                                modifier = videoModifier,
-                                call = videoCall,
-                                participant = videoParticipant,
-                                style = videoStyle,
-                                actionsContent = {_, _, _ -> {}},
-                                scalingType = VideoScalingType.SCALE_ASPECT_FIT
-                            )
-                        },
-                        floatingVideoRenderer = { call, parentSize ->
-                            FloatingParticipantVideo(
-                                call = call,
-                                participant = currentLocal!!,
-                                style = RegularVideoRendererStyle().copy(isShowingConnectionQualityIndicator = false),
-                                parentBounds = parentSize,
-                                videoRenderer = { _ ->
-                                    ParticipantVideo(
-                                        modifier = Modifier
-                                            .fillMaxSize()
-                                            .clip(VideoTheme.shapes.dialog),
-                                        call = call,
-                                        participant = currentLocal!!,
-                                        style = RegularVideoRendererStyle().copy(isShowingConnectionQualityIndicator = false),
-                                        actionsContent = {_, _, _ -> {}},
-                                    )
-                                }
-                            )
-                        }
-                    )
-                }
-            }
+            setOverlayContent(call)
             overlayView?.isVisible = false
             bridge?.webView?.setBackgroundColor(Color.WHITE) // Restore webview opacity
 
@@ -1646,62 +1493,7 @@ public class StreamCallPlugin : Plugin() {
 
                         bridge?.webView?.setBackgroundColor(Color.TRANSPARENT) // Make webview transparent
                         bridge?.webView?.bringToFront() // Ensure WebView is on top and transparent
-                        overlayView?.setContent {
-                            VideoTheme {
-                                if (streamCall != null) {
-
-                                    val participants by streamCall.state.participants.collectAsStateWithLifecycle()
-                                    val sortedParticipants by streamCall.state.sortedParticipants.collectAsStateWithLifecycle(emptyList())
-                                    val callParticipants by remember(participants) {
-                                        derivedStateOf {
-                                            if (sortedParticipants.size > 6) {
-                                                sortedParticipants
-                                            } else {
-                                                participants
-                                            }
-                                        }
-                                    }
-
-                                    val currentLocal by streamCall.state.me.collectAsStateWithLifecycle()
-
-                                    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 */ },
-                                        videoRenderer = { videoModifier, videoCall, videoParticipant, videoStyle ->
-                                            ParticipantVideo(
-                                                modifier = videoModifier,
-                                                call = videoCall,
-                                                participant = videoParticipant,
-                                                style = videoStyle,
-                                                actionsContent = {_, _, _ -> {}},
-                                                scalingType = VideoScalingType.SCALE_ASPECT_FIT
-                                            )
-                                        },
-                                        floatingVideoRenderer = { call, parentSize ->
-                                            FloatingParticipantVideo(
-                                                call = call,
-                                                participant = currentLocal!!,
-                                                style = RegularVideoRendererStyle().copy(isShowingConnectionQualityIndicator = false),
-                                                parentBounds = parentSize,
-                                                videoRenderer = { _ ->
-                                                    ParticipantVideo(
-                                                        modifier = Modifier
-                                                            .fillMaxSize()
-                                                            .clip(VideoTheme.shapes.dialog),
-                                                        call = call,
-                                                        participant = currentLocal!!,
-                                                        style = RegularVideoRendererStyle().copy(isShowingConnectionQualityIndicator = false),
-                                                        actionsContent = {_, _, _ -> {}}
-                                                    )
-                                                }
-                                            )
-                                        }
-                                    )
-                                }
-                            }
-                        }
+                        setOverlayContent(streamCall)
                         overlayView?.isVisible = true
                         // Ensure overlay is behind WebView by adjusting its position in the parent
                         val parent = overlayView?.parent as? ViewGroup

package/ios/Sources/StreamCallPlugin/CallOverlayView.swift

@@ -23,6 +23,37 @@ class CallOverlayViewFactory: ViewFactory {
             call: call
         )
     }
+    
+    public func makeVideoCallParticipantModifier(
+        participant: CallParticipant,
+        call: Call?,
+        availableFrame: CGRect,
+        ratio: CGFloat,
+        showAllInfo: Bool
+    ) -> some ViewModifier {
+        VideoCallParticipantModifier(
+            participant: participant,
+            call: call,
+            availableFrame: availableFrame,
+            ratio: ratio,
+            showAllInfo: showAllInfo,
+            decorations: [.speaking] // Here we only want the speaking decoration
+        )
+    }
+    
+    public func makeLocalParticipantViewModifier(
+        localParticipant: CallParticipant,
+        callSettings: Binding<CallSettings>,
+        call: Call?
+    ) -> some ViewModifier {
+        LocalParticipantViewModifier(
+                localParticipant: localParticipant,
+                call: call,
+                callSettings: callSettings,
+                showAllInfo: true,
+            decorations: [.speaking] // Here we only need the speaking decoration
+            )
+    }
 }
 
 struct CallOverlayView: View {

package/ios/Sources/StreamCallPlugin/TouchInterceptView.swift

@@ -19,7 +19,7 @@ class TouchInterceptView: UIView {
         // Ensure this view is transparent and doesn't interfere with display
         self.backgroundColor = .clear
         self.isOpaque = false
-        os_log(.debug, "TouchInterceptView: setupWithWebView - webView: %{public}s, overlayView: %{public}s", String(describing: webView), String(describing: overlayView))
+        // os_log(.debug, "TouchInterceptView: setupWithWebView - webView: %{public}s, overlayView: %{public}s", String(describing: webView), String(describing: overlayView))
     }
     
     func setActiveCallCheck(_ check: @escaping () -> Bool) {
@@ -28,7 +28,7 @@ class TouchInterceptView: UIView {
     
     func setCallActive(_ active: Bool) {
         self.isCallActive = active
-        os_log(.debug, "TouchInterceptView: setCallActive - %{public}s", String(describing: active))
+        // os_log(.debug, "TouchInterceptView: setCallActive - %{public}s", String(describing: active))
         
         // Cancel any pending timer when call becomes inactive
         if !active {
@@ -44,7 +44,7 @@ class TouchInterceptView: UIView {
         let shouldIntercept = isCallActive && hasActiveCall
         
         if isCallActive != hasActiveCall {
-            os_log(.debug, "TouchInterceptView: State mismatch - isCallActive: %{public}s, hasActiveCall: %{public}s", String(describing: isCallActive), String(describing: hasActiveCall))
+            // os_log(.debug, "TouchInterceptView: State mismatch - isCallActive: %{public}s, hasActiveCall: %{public}s", String(describing: isCallActive), String(describing: hasActiveCall))
         }
         
         return shouldIntercept
@@ -99,12 +99,12 @@ class TouchInterceptView: UIView {
             return el.tagName;
         })();
         """
-        os_log(.debug, "TouchInterceptView: forwardClickToWeb - (%{public}d,%{public}d)", x, y)
+        // os_log(.debug, "TouchInterceptView: forwardClickToWeb - (%{public}d,%{public}d)", x, y)
         wk.evaluateJavaScript(js) { result, error in
             if let error = error {
-                os_log(.error, "TouchInterceptView: JS error %{public}s", String(describing: error))
+                // os_log(.error, "TouchInterceptView: JS error %{public}s", String(describing: error))
             } else {
-                os_log(.debug, "TouchInterceptView: JS returned %{public}s", String(describing: result))
+                // os_log(.debug, "TouchInterceptView: JS returned %{public}s", String(describing: result))
             }
         }
     }
@@ -116,13 +116,13 @@ class TouchInterceptView: UIView {
             if let webView = self.webView {
                 let webPoint = self.convert(point, to: webView)
                 let result = webView.hitTest(webPoint, with: event)
-                os_log(.debug, "TouchInterceptView: hitTest - Not intercepting, direct WebView result %{public}s at %{public}s", String(describing: result), String(describing: webPoint))
+//                os_log(.debug, "TouchInterceptView: hitTest - Not intercepting, direct WebView result %{public}s at %{public}s", String(describing: result), String(describing: webPoint))
                 return result
             }
             return nil
         }
         
-        os_log(.debug, "TouchInterceptView: hitTest entry at %{public}s, callActive: %{public}s", String(describing: point), String(describing: isCallActive))
+        // os_log(.debug, "TouchInterceptView: hitTest entry at %{public}s, callActive: %{public}s", String(describing: point), String(describing: isCallActive))
         
         // Check if this is same touch location continuing
         if let lastPoint = lastTouchPoint {
@@ -130,7 +130,7 @@ class TouchInterceptView: UIView {
             if distance <= touchThreshold {
                 // Same touch continuing, cancel existing timer
                 forwardTimer?.invalidate()
-                os_log(.debug, "TouchInterceptView: Touch continuing at %{public}s, cancelling timer", String(describing: point))
+                // os_log(.debug, "TouchInterceptView: Touch continuing at %{public}s, cancelling timer", String(describing: point))
             }
         }
         
@@ -139,10 +139,10 @@ class TouchInterceptView: UIView {
         forwardTimer?.invalidate()
         forwardTimer = Timer.scheduledTimer(withTimeInterval: timerDelay, repeats: false) { [weak self] _ in
             guard let self = self, self.shouldInterceptTouches() else {
-                os_log(.debug, "TouchInterceptView: Timer fired but no longer in call, skipping web forward")
+                // os_log(.debug, "TouchInterceptView: Timer fired but no longer in call, skipping web forward")
                 return
             }
-            os_log(.debug, "TouchInterceptView: Timer fired, forwarding click to web at %{public}s", String(describing: point))
+            // os_log(.debug, "TouchInterceptView: Timer fired, forwarding click to web at %{public}s", String(describing: point))
             self.forwardClickToWeb(at: point)
         }
         
@@ -150,7 +150,7 @@ class TouchInterceptView: UIView {
         if let overlayView = self.overlayView, !overlayView.isHidden {
             let overlayPoint = self.convert(point, to: overlayView)
             if let overlayHit = nonGreedyInteractiveHitTest(in: overlayView, point: overlayPoint, with: event) {
-                os_log(.debug, "TouchInterceptView: hitTest - Overlay view %{public}s at %{public}s", String(describing: overlayHit), String(describing: overlayPoint))
+                // os_log(.debug, "TouchInterceptView: hitTest - Overlay view %{public}s at %{public}s", String(describing: overlayHit), String(describing: overlayPoint))
                 return overlayHit
             }
         }
@@ -158,10 +158,10 @@ class TouchInterceptView: UIView {
         if let webView = self.webView {
             let webPoint = self.convert(point, to: webView)
             let result = webView.hitTest(webPoint, with: event)
-            os_log(.debug, "TouchInterceptView: hitTest - WebView result %{public}s at %{public}s", String(describing: result), String(describing: webPoint))
+            // os_log(.debug, "TouchInterceptView: hitTest - WebView result %{public}s at %{public}s", String(describing: result), String(describing: webPoint))
             return result
         }
-        os_log(.debug, "TouchInterceptView: hitTest - No view found for %{public}s", String(describing: point))
+        // os_log(.debug, "TouchInterceptView: hitTest - No view found for %{public}s", String(describing: point))
         return nil
     }
     
@@ -173,16 +173,16 @@ class TouchInterceptView: UIView {
             }
             let webViewPoint = self.convert(point, to: webView)
             let result = webView.point(inside: webViewPoint, with: event)
-            os_log(.debug, "TouchInterceptView: point(inside) - Not intercepting, WebView only (%{public}s at %{public}s) for original point %{public}s = %s", String(describing: result), String(describing: webViewPoint), String(describing: point), String(describing: result))
+            // os_log(.debug, "TouchInterceptView: point(inside) - Not intercepting, WebView only (%{public}s at %{public}s) for original point %{public}s = %s", String(describing: result), String(describing: webViewPoint), String(describing: point), String(describing: result))
             return result
         }
         
         guard let webView = self.webView else {
-            os_log(.debug, "TouchInterceptView: point(inside) - webView is nil for point %{public}s. Checking overlay or deferring to super.", String(describing: point))
+            // os_log(.debug, "TouchInterceptView: point(inside) - webView is nil for point %{public}s. Checking overlay or deferring to super.", String(describing: point))
             if let overlayView = self.overlayView, !overlayView.isHidden {
                 let overlayPoint = self.convert(point, to: overlayView)
                 let overlayViewConsidersPointInside = overlayView.point(inside: overlayPoint, with: event)
-                os_log(.debug, "TouchInterceptView: point(inside) - webView nil. Overlay (%{public}s) for converted point %{public}s = %s", String(describing: overlayViewConsidersPointInside), String(describing: overlayPoint), String(describing: overlayViewConsidersPointInside))
+                //os_log(.debug, "TouchInterceptView: point(inside) - webView nil. Overlay (%{public}s) for converted point %{public}s = %s", String(describing: overlayViewConsidersPointInside), String(describing: overlayPoint), String(describing: overlayViewConsidersPointInside))
                 return overlayViewConsidersPointInside
             }
             return super.point(inside: point, with: event)
@@ -195,13 +195,13 @@ class TouchInterceptView: UIView {
             let overlayPoint = self.convert(point, to: overlayView)
             let overlayViewConsidersPointInside = overlayView.point(inside: overlayPoint, with: event)
             let result = webViewConsidersPointInside || overlayViewConsidersPointInside
-            os_log(.debug, "TouchInterceptView: point(inside) - WebView (%{public}s at %{public}s) OR Visible Overlay (%{public}s at %{public}s) for original point %{public}s = %s", String(describing: webViewConsidersPointInside), String(describing: webViewPoint), String(describing: overlayViewConsidersPointInside), String(describing: overlayPoint), String(describing: point), String(describing: result))
+            // os_log(.debug, "TouchInterceptView: point(inside) - WebView (%{public}s at %{public}s) OR Visible Overlay (%{public}s at %{public}s) for original point %{public}s = %s", String(describing: webViewConsidersPointInside), String(describing: webViewPoint), String(describing: overlayViewConsidersPointInside), String(describing: overlayPoint), String(describing: point), String(describing: result))
             return result
         } else {
             if self.overlayView == nil {
-                 os_log(.debug, "TouchInterceptView: point(inside) - Overlay nil. WebView (%{public}s at %{public}s) for original point %{public}s = %s", String(describing: webViewConsidersPointInside), String(describing: webViewPoint), String(describing: point), String(describing: webViewConsidersPointInside))
+                 // os_log(.debug, "TouchInterceptView: point(inside) - Overlay nil. WebView (%{public}s at %{public}s) for original point %{public}s = %s", String(describing: webViewConsidersPointInside), String(describing: webViewPoint), String(describing: point), String(describing: webViewConsidersPointInside))
             } else {
-                 os_log(.debug, "TouchInterceptView: point(inside) - Overlay hidden. WebView (%{public}s at %{public}s) for original point %{public}s = %s", String(describing: webViewConsidersPointInside), String(describing: webViewPoint), String(describing: point), String(describing: webViewConsidersPointInside))
+                 // os_log(.debug, "TouchInterceptView: point(inside) - Overlay hidden. WebView (%{public}s at %{public}s) for original point %{public}s = %s", String(describing: webViewConsidersPointInside), String(describing: webViewPoint), String(describing: point), String(describing: webViewConsidersPointInside))
             }
             return webViewConsidersPointInside
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capgo/capacitor-stream-call",
-  "version": "0.0.64",
+  "version": "0.0.66",
   "description": "Uses the https://getstream.io/ SDK to implement calling in Capacitor",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",