@capgo/capacitor-stream-call 7.0.1 → 7.0.3

package/CapgoCapacitorStreamCall.podspec

@@ -13,7 +13,7 @@ Pod::Spec.new do |s|
   s.source_files = 'ios/Sources/**/*.{swift,h,m,c,cc,mm,cpp}'
   s.ios.deployment_target = '14.0'
   s.dependency 'Capacitor'
-  s.dependency 'StreamVideo', '1.29.0'
-  s.dependency 'StreamVideoSwiftUI', '1.29.0'
+  s.dependency 'StreamVideo', '1.29.1'
+  s.dependency 'StreamVideoSwiftUI', '1.29.1'
   s.swift_version = '5.1'
 end

package/Package.swift

@@ -11,7 +11,7 @@ let package = Package(
     ],
     dependencies: [
         .package(url: "https://github.com/ionic-team/capacitor-swift-pm.git", from: "7.0.0"),
-        .package(url: "https://github.com/GetStream/stream-video-swift.git", exact: "1.29.0")
+        .package(url: "https://github.com/GetStream/stream-video-swift.git", exact: "1.29.1")
     ],
     targets: [
         .target(

package/android/build.gradle

@@ -77,8 +77,8 @@ dependencies {
 
     
     // Stream dependencies
-    implementation("io.getstream:stream-video-android-ui-compose:1.9.2")
-    implementation("io.getstream:stream-video-android-core:1.9.2")
+    implementation("io.getstream:stream-video-android-ui-compose:1.10.0")
+    implementation("io.getstream:stream-video-android-core:1.10.0")
     implementation("io.getstream:stream-android-push:1.3.2")
     implementation("io.getstream:stream-android-push-firebase:1.3.2")
     

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

@@ -370,19 +370,6 @@ class StreamCallPlugin : Plugin() {
         val context = context
         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(Color.TRANSPARENT)
-            }
-            rootParent.addView(touchInterceptWrapper, indexInRoot)
-        }
-
-        val parent: ViewGroup = touchInterceptWrapper ?: originalParent
-
         // Make WebView initially visible and opaque
         bridge?.webView?.setBackgroundColor(Color.WHITE) // Or whatever background color suits your app
 
@@ -394,7 +381,7 @@ class StreamCallPlugin : Plugin() {
                 ViewGroup.LayoutParams.MATCH_PARENT
             )
         }
-        parent.addView(overlayView, 0)  // Add at index 0 to ensure it's below WebView
+        originalParent.addView(overlayView, 0)  // Add at index 0 to ensure it's below WebView
 
         // Initialize with active call content
         setOverlayContent()
@@ -408,7 +395,160 @@ class StreamCallPlugin : Plugin() {
             )
             setBackgroundColor("#1a242c".toColorInt())
         }
-        parent.addView(barrierView, parent.indexOfChild(bridge?.webView) + 1) // Add above WebView
+        originalParent.addView(barrierView, originalParent.indexOfChild(bridge?.webView) + 1) // Add above WebView
+    }
+
+    private fun addTouchInterceptor() {
+        val webView = bridge?.webView
+        if (webView == null) {
+            Log.e("StreamCallPlugin", "addTouchInterceptor: WebView is null, cannot add touch interceptor")
+            return
+        }
+        
+        val originalParent = webView.parent as? ViewGroup
+        if (originalParent == null) {
+            Log.e("StreamCallPlugin", "addTouchInterceptor: WebView parent is null or not a ViewGroup")
+            return
+        }
+        
+        // Check if touch interceptor already exists
+        if (touchInterceptWrapper != null) {
+            Log.d("StreamCallPlugin", "addTouchInterceptor: Touch interceptor already exists, skipping creation")
+            return
+        }
+        
+        Log.d("StreamCallPlugin", "addTouchInterceptor: Starting setup")
+        Log.d("StreamCallPlugin", "addTouchInterceptor: Original parent type: ${originalParent.javaClass.simpleName}")
+        Log.d("StreamCallPlugin", "addTouchInterceptor: Original parent child count: ${originalParent.childCount}")
+        
+        // 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) {
+            Log.d("StreamCallPlugin", "addTouchInterceptor: Root parent type: ${rootParent.javaClass.simpleName}")
+            
+            rootParent.removeViewAt(indexInRoot)
+            touchInterceptWrapper = TouchInterceptWrapper(originalParent).apply {
+                setBackgroundColor(Color.TRANSPARENT)
+            }
+            rootParent.addView(touchInterceptWrapper, indexInRoot)
+            
+            // Move views to touch interceptor
+            val parent = touchInterceptWrapper!!
+            if (overlayView?.parent != parent) {
+                (overlayView?.parent as? ViewGroup)?.removeView(overlayView)
+                parent.addView(overlayView, 0)
+            }
+            if (barrierView?.parent != parent) {
+                (barrierView?.parent as? ViewGroup)?.removeView(barrierView)
+                parent.addView(barrierView, parent.indexOfChild(webView) + 1)
+            }
+            
+            Log.d("StreamCallPlugin", "addTouchInterceptor: Touch interceptor added successfully")
+            Log.d("StreamCallPlugin", "addTouchInterceptor: TouchWrapper child count: ${parent.childCount}")
+            
+            // Log children of touch wrapper
+            for (i in 0 until parent.childCount) {
+                val child = parent.getChildAt(i)
+                Log.d("StreamCallPlugin", "addTouchInterceptor: TouchWrapper child $i: ${child.javaClass.simpleName}")
+            }
+        } else {
+            Log.e("StreamCallPlugin", "addTouchInterceptor: Could not add touch interceptor - rootParent=$rootParent, indexInRoot=$indexInRoot")
+        }
+    }
+    
+    private fun removeTouchInterceptor() {
+        val touchWrapper = touchInterceptWrapper ?: return
+        val rootParent = touchWrapper.parent as? ViewGroup ?: return
+        val indexInRoot = rootParent.indexOfChild(touchWrapper)
+        
+        Log.d("StreamCallPlugin", "removeTouchInterceptor: Starting removal process")
+        Log.d("StreamCallPlugin", "removeTouchInterceptor: TouchWrapper has ${touchWrapper.childCount} children")
+        Log.d("StreamCallPlugin", "removeTouchInterceptor: RootParent type: ${rootParent.javaClass.simpleName}")
+        
+        // Log all children of touchWrapper
+        for (i in 0 until touchWrapper.childCount) {
+            val child = touchWrapper.getChildAt(i)
+            Log.d("StreamCallPlugin", "removeTouchInterceptor: Child $i: ${child.javaClass.simpleName}")
+        }
+        
+        // Store references to all children before removing
+        val childrenToRestore = mutableListOf<View>()
+        for (i in 0 until touchWrapper.childCount) {
+            childrenToRestore.add(touchWrapper.getChildAt(i))
+        }
+        
+        // Find which child should be the new container (usually the one that was the original parent)
+        // This is typically a FrameLayout or similar ViewGroup, but NOT ComposeView
+        var newParent: ViewGroup? = null
+        
+        // Look for a ViewGroup that is not a ComposeView to be the new parent
+        for (child in childrenToRestore) {
+            if (child is ViewGroup && child !is ComposeView) {
+                // Check if this ViewGroup originally contained the WebView or other views
+                newParent = child
+                Log.d("StreamCallPlugin", "removeTouchInterceptor: Found potential parent: ${child.javaClass.simpleName}")
+                break
+            }
+        }
+        
+        // If we didn't find a suitable parent, create a new FrameLayout
+        if (newParent == null) {
+            Log.d("StreamCallPlugin", "removeTouchInterceptor: No suitable parent found, creating new FrameLayout")
+            newParent = FrameLayout(touchWrapper.context).apply {
+                layoutParams = touchWrapper.layoutParams
+            }
+            
+            // Move all children from touchWrapper to the new parent
+            touchWrapper.removeAllViews()
+            for (child in childrenToRestore) {
+                newParent.addView(child)
+            }
+        } else {
+            // If we found an existing parent, move other children to it
+            touchWrapper.removeAllViews()
+            
+            // First add the parent back
+            rootParent.addView(newParent, indexInRoot)
+            
+            // Then add other children to this parent if they're not already there
+            for (child in childrenToRestore) {
+                if (child != newParent && child.parent == null) {
+                    when (child) {
+                        is ComposeView -> newParent.addView(child, 0) // Add ComposeView at bottom
+                        bridge?.webView -> newParent.addView(child) // Add WebView on top
+                        else -> newParent.addView(child) // Add other views
+                    }
+                }
+            }
+        }
+        
+        // Remove the touch wrapper from root if not done yet
+        if (touchWrapper.parent != null) {
+            rootParent.removeView(touchWrapper)
+            if (newParent.parent == null) {
+                rootParent.addView(newParent, indexInRoot)
+            }
+        }
+        
+        // Ensure WebView is still visible and has correct background
+        bridge?.webView?.let { webView ->
+            webView.visibility = View.VISIBLE
+            webView.setBackgroundColor(Color.WHITE)
+            webView.bringToFront()
+            Log.d("StreamCallPlugin", "removeTouchInterceptor: WebView visibility set to VISIBLE, background set to WHITE")
+        }
+        
+        touchInterceptWrapper = null
+        Log.d("StreamCallPlugin", "Touch interceptor removed successfully")
+        
+        // Log final state
+        Log.d("StreamCallPlugin", "removeTouchInterceptor: Final rootParent child count: ${rootParent.childCount}")
+        for (i in 0 until rootParent.childCount) {
+            val child = rootParent.getChildAt(i)
+            Log.d("StreamCallPlugin", "removeTouchInterceptor: Final child $i: ${child.javaClass.simpleName}")
+        }
     }
 
     /**
@@ -1101,6 +1241,10 @@ class StreamCallPlugin : Plugin() {
                 // Show overlay view with the active call and make webview transparent
                 runOnMainThread {
                     Log.d("StreamCallPlugin", "internalAcceptCall: Updating UI for active call ${call.id} - setting overlay visible.")
+                    
+                    // Add touch interceptor for the call
+                    addTouchInterceptor()
+                    
                     bridge?.webView?.setBackgroundColor(Color.TRANSPARENT) // Make webview transparent
                     Log.d("StreamCallPlugin", "internalAcceptCall: WebView background set to transparent for call ${call.id}")
                     bridge?.webView?.bringToFront() // Ensure WebView is on top and transparent
@@ -1474,6 +1618,9 @@ class StreamCallPlugin : Plugin() {
                     streamCall?.microphone?.setEnabled(true)
                     streamCall?.camera?.setEnabled(!isAudioOnly)
 
+                    // Add touch interceptor for the call
+                    addTouchInterceptor()
+                    
                     bridge?.webView?.setBackgroundColor(Color.TRANSPARENT) // Make webview transparent
                     bridge?.webView?.bringToFront() // Ensure WebView is on top and transparent
                     setOverlayContent(streamCall)
@@ -1896,26 +2043,39 @@ class StreamCallPlugin : Plugin() {
                 }
             }
 
+            // Always clean up the UI regardless of savedCapacitorActivity state
+            Log.d("StreamCallPlugin", "endCallRaw: Cleaning up UI for call $callId")
+            Log.d("StreamCallPlugin", "endCallRaw: WebView visible before: ${bridge?.webView?.visibility}")
+            Log.d("StreamCallPlugin", "endCallRaw: TouchInterceptWrapper exists: ${touchInterceptWrapper != null}")
+            
+            setOverlayContent(call)
+            overlayView?.isVisible = false
+            bridge?.webView?.setBackgroundColor(Color.WHITE) // Restore webview opacity
+            bridge?.webView?.visibility = View.VISIBLE // Ensure WebView is visible
+            
+            // Remove touch interceptor
+            if (touchInterceptWrapper != null) {
+                Log.d("StreamCallPlugin", "endCallRaw: Removing touch interceptor")
+                removeTouchInterceptor()
+            } else {
+                Log.d("StreamCallPlugin", "endCallRaw: No touch interceptor to remove")
+            }
+
+            // Also hide incoming call view if visible
+            Log.d("StreamCallPlugin", "endCallRaw: Hiding incoming call view for call $callId")
+            // No dedicated incoming-call native view anymore; UI handled by web layer
+            
+            Log.d("StreamCallPlugin", "endCallRaw: WebView visible after: ${bridge?.webView?.visibility}")
+
             val savedCapacitorActivity = savedActivity
             if (savedCapacitorActivity != null) {
-
                 if (savedActivityPaused) {
-                    Log.d("StreamCallPlugin", "Activity is paused. Adding call ${call.id} to savedCallsToEndOnResume")
+                    Log.d("StreamCallPlugin", "endCallRaw: Activity is paused. Adding call ${call.id} to savedCallsToEndOnResume")
                     savedCallsToEndOnResume.add(call)
                 } else {
                     transEndCallRaw(call)
                 }
-
-                return@runOnMainThread
             }
-
-            setOverlayContent(call)
-            overlayView?.isVisible = false
-            bridge?.webView?.setBackgroundColor(Color.WHITE) // Restore webview opacity
-
-            // Also hide incoming call view if visible
-            Log.d("StreamCallPlugin", "Hiding incoming call view for call $callId")
-            // No dedicated incoming-call native view anymore; UI handled by web layer
         }
 
         // Notify that call has ended using helper
@@ -2176,10 +2336,30 @@ class StreamCallPlugin : Plugin() {
 
         // Hide UI elements directly without setting content
         runOnMainThread {
-            Log.d("StreamCallPlugin", "Hiding UI elements for call $callCid (one-time cleanup)")
+            Log.d("StreamCallPlugin", "cleanupCall: Hiding UI elements for call $callCid")
+            
+            // Log current state before cleanup
+            Log.d("StreamCallPlugin", "cleanupCall: OverlayView visible: ${overlayView?.isVisible}")
+            Log.d("StreamCallPlugin", "cleanupCall: WebView visible: ${bridge?.webView?.visibility}")
+            Log.d("StreamCallPlugin", "cleanupCall: TouchInterceptWrapper exists: ${touchInterceptWrapper != null}")
+            
             overlayView?.isVisible = false
+            bridge?.webView?.setBackgroundColor(Color.WHITE) // Restore webview opacity
+            bridge?.webView?.visibility = View.VISIBLE // Ensure WebView is visible
+            
+            // Remove touch interceptor if it exists
+            if (touchInterceptWrapper != null) {
+                Log.d("StreamCallPlugin", "cleanupCall: Removing touch interceptor")
+                removeTouchInterceptor()
+            } else {
+                Log.d("StreamCallPlugin", "cleanupCall: No touch interceptor to remove")
+            }
+            
             // here we will also make sure we don't show on lock screen
             changeActivityAsVisibleOnLockScreen(this.activity, false)
+            
+            // Log final state after cleanup
+            Log.d("StreamCallPlugin", "cleanupCall: Cleanup complete. WebView visible: ${bridge?.webView?.visibility}")
         }
 
         Log.d("StreamCallPlugin", "Cleaned up resources for ended call: $callCid")

package/ios/Sources/StreamCallPlugin/StreamCallPlugin.swift

@@ -245,9 +245,6 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
                             print("- In call state detected")
                             print("- All participants: \(String(describing: viewModel.participants))")
                             
-                            // Enable touch interceptor when call becomes active
-                            self.touchInterceptView?.setCallActive(true)
-                            
                             // Create/update overlay and make visible when there's an active call
                             self.createCallOverlayView()
                             
@@ -303,9 +300,6 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
                         } else if newState == .idle {
                             print("Call state changed to idle. CurrentCallId: \(self.currentCallId), ActiveCall: \(String(describing: self.streamVideo?.state.activeCall?.cId))")
                             
-                            // Disable touch interceptor when call becomes inactive
-                            self.touchInterceptView?.setCallActive(false)
-                            
                             // Only notify about call ending if we have a valid stored call ID and there's truly no active call
                             // This prevents false "left" events during normal state transitions
                             if !self.currentCallId.isEmpty && self.streamVideo?.state.activeCall == nil {
@@ -433,9 +427,11 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
         Task { @MainActor in
             // self.overlayViewModel?.updateCall(nil)
             // self.overlayViewModel?.updateStreamVideo(nil)
-            self.touchInterceptView?.setCallActive(false)
             self.overlayView?.isHidden = true
             self.webView?.isOpaque = true
+            
+            // Remove touch interceptor if it exists
+            self.removeTouchInterceptor()
         }
 
         call.resolve([
@@ -604,6 +600,9 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
                     
                     // Update UI on main thread
                     await MainActor.run {
+                        // Add touch interceptor for the call
+                        self.addTouchInterceptor()
+                        
                         // self.overlayViewModel?.updateCall(streamCall)
                         self.overlayView?.isHidden = false
                         self.webView?.isOpaque = false
@@ -671,9 +670,11 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
                     }
                     
                     await MainActor.run {
-                        self.touchInterceptView?.setCallActive(false)
                         self.overlayView?.isHidden = true
                         self.webView?.isOpaque = true
+                        
+                        // Remove touch interceptor
+                        self.removeTouchInterceptor()
                     }
                     
                     call.resolve([
@@ -700,9 +701,11 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
                     await callViewModel?.hangUp()
                     
                     await MainActor.run {
-                        self.touchInterceptView?.setCallActive(false)
                         self.overlayView?.isHidden = true
                         self.webView?.isOpaque = true
+                        
+                        // Remove touch interceptor
+                        self.removeTouchInterceptor()
                     }
                     
                     call.resolve([
@@ -809,6 +812,9 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
 
                     // Update the CallOverlayView with the active call
                     await MainActor.run {
+                        // Add touch interceptor for the call
+                        self.addTouchInterceptor()
+                        
                         // self.overlayViewModel?.updateCall(streamCall)
                         self.overlayView?.isHidden = false
                         self.webView?.isOpaque = false
@@ -900,12 +906,6 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
     private func setupViews() {
         guard let webView = self.webView, let parent = webView.superview else { return }
         
-        // Create the touch intercept view as an overlay for touch passthrough
-        let touchInterceptView = TouchInterceptView(frame: parent.bounds)
-        touchInterceptView.translatesAutoresizingMaskIntoConstraints = false
-        touchInterceptView.backgroundColor = .clear
-        touchInterceptView.isOpaque = false
-        
         // Create SwiftUI view with view model if not already created
         if self.overlayView == nil, let callViewModel = self.callViewModel {
             let hostingController = UIHostingController(rootView: CallOverlayView(viewModel: callViewModel))
@@ -930,16 +930,34 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
                 ])
             }
         }
+    }
+    
+    private func addTouchInterceptor() {
+        guard let webView = self.webView, let parent = webView.superview else { return }
+        
+        // Check if touch interceptor already exists
+        if self.touchInterceptView != nil {
+            print("Touch interceptor already exists, skipping creation")
+            return
+        }
+        
+        // Create the touch intercept view as an overlay for touch passthrough
+        let touchInterceptView = TouchInterceptView(frame: parent.bounds)
+        touchInterceptView.translatesAutoresizingMaskIntoConstraints = false
+        touchInterceptView.backgroundColor = .clear
+        touchInterceptView.isOpaque = false
         
         // Setup touch intercept view with references to webview and overlay
         if let overlayView = self.overlayView {
             touchInterceptView.setupWithWebView(webView, overlayView: overlayView)
-            // Insert touchInterceptView above webView
-            parent.insertSubview(touchInterceptView, aboveSubview: webView)
+            // Add touchInterceptView as the topmost view
+            parent.addSubview(touchInterceptView)
+            parent.bringSubviewToFront(touchInterceptView)
         } else {
             // If overlayView is not present, just add on top of webView
             touchInterceptView.setupWithWebView(webView, overlayView: webView)
-            parent.insertSubview(touchInterceptView, aboveSubview: webView)
+            parent.addSubview(touchInterceptView)
+            parent.bringSubviewToFront(touchInterceptView)
         }
         
         // Set up active call check function
@@ -957,6 +975,18 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
             touchInterceptView.leadingAnchor.constraint(equalTo: parent.leadingAnchor),
             touchInterceptView.trailingAnchor.constraint(equalTo: parent.trailingAnchor)
         ])
+        
+        print("Touch interceptor added for active call - view hierarchy: \(parent.subviews.map { type(of: $0) })")
+    }
+    
+    private func removeTouchInterceptor() {
+        guard let touchInterceptView = self.touchInterceptView else { return }
+        
+        // Remove touch interceptor from view hierarchy
+        touchInterceptView.removeFromSuperview()
+        self.touchInterceptView = nil
+        
+        print("Touch interceptor removed after call ended")
     }
     
     private func createCallOverlayView() {
@@ -1004,43 +1034,8 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
         self.hostingController = overlayView
         self.overlayView = overlayView.view
         
-        // Ensure touch intercept view is on top
-        if let touchInterceptView = parent.subviews.first(where: { $0 is TouchInterceptView }) {
-            parent.bringSubviewToFront(touchInterceptView)
-            // Update reference and set call active
-            self.touchInterceptView = touchInterceptView as? TouchInterceptView
-            
-            // Set up active call check function
-            self.touchInterceptView?.setActiveCallCheck { [weak self] in
-                return self?.streamVideo?.state.activeCall != nil
-            }
-            
-            self.touchInterceptView?.setCallActive(true)
-        } else {
-            // Create touch intercept view if not already created
-            let touchInterceptView = TouchInterceptView(frame: parent.bounds)
-            touchInterceptView.translatesAutoresizingMaskIntoConstraints = false
-            touchInterceptView.backgroundColor = .clear
-            touchInterceptView.isOpaque = false
-            touchInterceptView.setupWithWebView(webView, overlayView: overlayView.view)
-            parent.addSubview(touchInterceptView)
-            
-            // Set up active call check function
-            touchInterceptView.setActiveCallCheck { [weak self] in
-                return self?.streamVideo?.state.activeCall != nil
-            }
-            
-            // Store reference and set call active
-            self.touchInterceptView = touchInterceptView
-            self.touchInterceptView?.setCallActive(true)
-            
-            NSLayoutConstraint.activate([
-                touchInterceptView.topAnchor.constraint(equalTo: parent.topAnchor),
-                touchInterceptView.bottomAnchor.constraint(equalTo: parent.bottomAnchor),
-                touchInterceptView.leadingAnchor.constraint(equalTo: parent.leadingAnchor),
-                touchInterceptView.trailingAnchor.constraint(equalTo: parent.trailingAnchor)
-            ])
-        }
+        // Add touch interceptor if not already present
+        self.addTouchInterceptor()
     }
     
     // MARK: - Dynamic API Key Management
@@ -1066,9 +1061,6 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
     }
     
     func ensureViewRemoved() {
-        // Disable touch interceptor when overlay is removed
-        self.touchInterceptView?.setCallActive(false)
-        
         // Check if we have an overlay view
         if let existingOverlayView = self.overlayView {
             print("Hiding call overlay view")
@@ -1083,6 +1075,9 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
         } else {
             print("No call overlay view to hide")
         }
+        
+        // Remove touch interceptor
+        self.removeTouchInterceptor()
     }
 
     @objc func getCallStatus(_ call: CAPPluginCall) {

package/ios/Sources/StreamCallPlugin/TouchInterceptView.swift

@@ -9,7 +9,6 @@ class TouchInterceptView: UIView {
     private var lastTouchPoint: CGPoint?
     private let touchThreshold: CGFloat = 5.0 // pixels
     private let timerDelay: TimeInterval = 0.1 // seconds
-    private var isCallActive: Bool = false
     private var hasActiveCallCheck: (() -> Bool)?
     
     func setupWithWebView(_ webView: UIView, overlayView: UIView) {
@@ -26,28 +25,10 @@ class TouchInterceptView: UIView {
         self.hasActiveCallCheck = check
     }
     
-    func setCallActive(_ active: Bool) {
-        self.isCallActive = active
-        // os_log(.debug, "TouchInterceptView: setCallActive - %{public}s", String(describing: active))
-        
-        // Cancel any pending timer when call becomes inactive
-        if !active {
-            forwardTimer?.invalidate()
-            forwardTimer = nil
-            lastTouchPoint = nil
-        }
-    }
-    
     private func shouldInterceptTouches() -> Bool {
-        // Check both our flag and actual call state
+        // Check if there's an active call
         let hasActiveCall = hasActiveCallCheck?() ?? false
-        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))
-        }
-        
-        return shouldIntercept
+        return hasActiveCall
     }
     
     private func isInteractive(_ view: UIView) -> Bool {
@@ -130,16 +111,21 @@ class TouchInterceptView: UIView {
         
         // Check if we should intercept touches
         if !shouldInterceptTouches() {
+            // Cancel any pending timer when not in a call
+            forwardTimer?.invalidate()
+            forwardTimer = nil
+            lastTouchPoint = nil
+            
             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))
+                print("TouchInterceptView: hitTest - Not intercepting (no active call), direct WebView result \(String(describing: result)) at \(webPoint)")
                 return result
             }
             return nil
         }
         
-        // os_log(.debug, "TouchInterceptView: hitTest entry at %{public}s, callActive: %{public}s", String(describing: point), String(describing: isCallActive))
+        print("TouchInterceptView: hitTest intercepting touch at \(point)")
         
         // Check if this is same touch location continuing
         if let lastPoint = lastTouchPoint {
@@ -167,7 +153,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))
+                print("TouchInterceptView: hitTest - Hit overlay view \(String(describing: overlayHit)) at \(overlayPoint)")
                 return overlayHit
             }
         }
@@ -175,10 +161,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))
+            print("TouchInterceptView: hitTest - WebView fallback result \(String(describing: result)) at \(webPoint)")
             return result
         }
-        // os_log(.debug, "TouchInterceptView: hitTest - No view found for %{public}s", String(describing: point))
+        print("TouchInterceptView: hitTest - No view found for \(point)")
         return nil
     }
     

package/package.json

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