@capgo/capacitor-stream-call 0.0.18 → 0.0.20

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

@@ -29,7 +29,6 @@ import io.getstream.video.android.core.StreamVideo
 import io.getstream.video.android.core.StreamVideoBuilder
 import io.getstream.video.android.core.notifications.NotificationConfig
 import io.getstream.video.android.core.notifications.NotificationHandler
-import io.getstream.video.android.core.sounds.emptyRingingConfig
 import io.getstream.video.android.core.sounds.toSounds
 import io.getstream.video.android.model.StreamCallId
 import io.getstream.video.android.model.User
@@ -46,6 +45,7 @@ import io.getstream.android.video.generated.models.CallCreatedEvent
 import io.getstream.android.video.generated.models.CallEndedEvent
 import io.getstream.android.video.generated.models.CallMissedEvent
 import io.getstream.android.video.generated.models.CallRejectedEvent
+import io.getstream.android.video.generated.models.CallRingEvent
 import io.getstream.android.video.generated.models.CallSessionEndedEvent
 import io.getstream.android.video.generated.models.CallSessionStartedEvent
 import io.getstream.android.video.generated.models.VideoEvent
@@ -185,7 +185,7 @@ public class StreamCallPlugin : Plugin() {
                                         declineCall(declinedCall)
                                     },
                                     onAcceptCall = { acceptedCall ->
-                                        acceptCall(acceptedCall)
+                                        internalAcceptCall(acceptedCall)
                                     },
                                     onHideIncomingCall = {
                                         hideIncomingCall()
@@ -207,7 +207,7 @@ public class StreamCallPlugin : Plugin() {
                 val call = streamVideoClient?.call(id = cid.id, type = cid.type)
                 kotlinx.coroutines.GlobalScope.launch {
                     call?.get()
-                    call?.let { acceptCall(it) }
+                    call?.let { internalAcceptCall(it) }
                 }
             }
         }
@@ -565,6 +565,9 @@ public class StreamCallPlugin : Plugin() {
             client.subscribe { event: VideoEvent ->
                 android.util.Log.v("StreamCallPlugin", "Received an event ${event.getEventType()} $event")
                 when (event) {
+                    is CallRingEvent -> {
+                        updateCallStatusAndNotify(event.callCid, "ringing")
+                    }
                     // Handle CallCreatedEvent differently - only log it but don't try to access members yet
                     is CallCreatedEvent -> {
                         val callCid = event.callCid
@@ -744,8 +747,42 @@ public class StreamCallPlugin : Plugin() {
         })
     }
 
+    @PluginMethod
+    public fun acceptCall(call: PluginCall) {
+        try {
+            val streamVideoCall = streamVideoClient?.state?.ringingCall?.value
+            if (streamVideoCall == null) {
+                call.reject("Ringing call is null")
+                return
+            }
+            kotlinx.coroutines.GlobalScope.launch {
+                internalAcceptCall(streamVideoCall)
+            }
+        } catch (t: Throwable) {
+            android.util.Log.d("StreamCallPlugin", "JS -> acceptCall fail", t);
+            call.reject("Cannot acceptCall")
+        }
+    }
+
+    @PluginMethod
+    public fun rejectCall(call: PluginCall) {
+        try {
+            val streamVideoCall = streamVideoClient?.state?.ringingCall?.value
+            if (streamVideoCall == null) {
+                call.reject("Ringing call is null")
+                return
+            }
+            kotlinx.coroutines.GlobalScope.launch {
+                declineCall(streamVideoCall)
+            }
+        } catch (t: Throwable) {
+            android.util.Log.d("StreamCallPlugin", "JS -> rejectCall fail", t);
+            call.reject("Cannot rejectCall")
+        }
+    }
+
     @OptIn(DelicateCoroutinesApi::class)
-    private fun acceptCall(call: Call) {
+    private fun internalAcceptCall(call: Call) {
         kotlinx.coroutines.GlobalScope.launch {
             try {
                 // Stop ringtone

package/ios/Sources/StreamCallPlugin/CallOverlayView.swift

@@ -3,53 +3,6 @@ import StreamVideo
 import StreamVideoSwiftUI
 import Combine
 
-class CallOverlayViewModel: ObservableObject {
-    @Published var streamVideo: StreamVideo?
-    @Published var call: Call?
-    @Published var callState: CallState?
-    @Published var viewModel: CallViewModel?
-    @Published var participants: [CallParticipant] = []
-
-    private var participantsSubscription: AnyCancellable?
-
-    init(streamVideo: StreamVideo?) {
-        self.streamVideo = streamVideo
-    }
-
-    @MainActor
-    func updateCall(_ call: Call?) {
-        self.call = call
-        // Clean up previous subscription if any
-        participantsSubscription?.cancel()
-
-        if let call = call {
-            participantsSubscription = call.state.$participants.sink { [weak self] participants in
-                print("Participants update \(participants.map { $0.name })")
-                self?.participants = participants
-            }
-            self.callState = call.state
-            participantsSubscription = call.state.$callSettings.sink { [weak self] callSettings in
-                print("Call settings update")
-                self?.viewModel = CallViewModel(callSettings: callSettings)
-                self?.viewModel?.setActiveCall(call)
-            }
-        } else {
-            // Clear participants when call ends
-            self.participants = []
-            self.callState = nil
-        }
-    }
-
-    @MainActor
-    func updateStreamVideo(_ streamVideo: StreamVideo?) {
-        self.streamVideo = streamVideo
-        if streamVideo == nil {
-            self.call = nil
-            self.callState = nil
-        }
-    }
-}
-
 class CallOverlayViewFactory: ViewFactory {
     // ... existing ViewFactory methods ...
     func makeVideoParticipantView(
@@ -73,26 +26,22 @@ class CallOverlayViewFactory: ViewFactory {
 }
 
 struct CallOverlayView: View {
-    @ObservedObject var viewModel: CallOverlayViewModel
+    @ObservedObject var viewModel: CallViewModel
     @State private var safeAreaInsets: EdgeInsets = .init()
     private let viewFactory: CallOverlayViewFactory
 
-    init(viewModel: CallOverlayViewModel) {
+    init(viewModel: CallViewModel) {
         self.viewModel = viewModel
         self.viewFactory = CallOverlayViewFactory()
     }
 
     var body: some View {
         VStack(spacing: 0) {
-            if let viewModelStandard = viewModel.viewModel {
-                ZStack {
-                    CustomCallView(viewFactory: viewFactory, viewModel: viewModelStandard)
-                }
-                .padding(.top, safeAreaInsets.top)
-                .padding(.bottom, safeAreaInsets.bottom)
-            } else {
-                Color.white
+            ZStack {
+                CustomCallView(viewFactory: viewFactory, viewModel: viewModel)
             }
+            .padding(.top, safeAreaInsets.top)
+            .padding(.bottom, safeAreaInsets.bottom)
         }
         .edgesIgnoringSafeArea(.all)
         .overlay(
@@ -108,7 +57,7 @@ struct CallOverlayView: View {
     }
 
     private func changeTrackVisibility(_ participant: CallParticipant?, isVisible: Bool) {
-        print("changeTrackVisibility for \(participant?.userId), visible: \(isVisible)")
+        print("changeTrackVisibility for \(String(describing: participant?.userId)), visible: \(isVisible)")
         guard let participant = participant,
               let call = viewModel.call else { return }
         Task {
@@ -118,26 +67,17 @@ struct CallOverlayView: View {
 }
 
 extension CallOverlayView {
-    static func create(streamVideo: StreamVideo?) -> (UIHostingController<CallOverlayView>, CallOverlayViewModel) {
-        let viewModel = CallOverlayViewModel(streamVideo: streamVideo)
-        let view = CallOverlayView(viewModel: viewModel)
+    static func create(callViewModel: CallViewModel) -> UIHostingController<CallOverlayView> {
+        let view = CallOverlayView(viewModel: callViewModel)
         let hostingController = UIHostingController(rootView: view)
         hostingController.view.backgroundColor = .clear
 
         // Make sure we respect safe areas
         hostingController.view.insetsLayoutMarginsFromSafeArea = true
 
-        return (hostingController, viewModel)
-    }
-}
-
-#if DEBUG
-struct CallOverlayView_Previews: PreviewProvider {
-    static var previews: some View {
-        CallOverlayView(viewModel: CallOverlayViewModel(streamVideo: nil))
+        return (hostingController)
     }
 }
-#endif
 
 struct SafeAreaInsetsKey: PreferenceKey {
     static var defaultValue: EdgeInsets = .init()

package/ios/Sources/StreamCallPlugin/ParticipantsView.swift

@@ -50,18 +50,6 @@ struct ParticipantsView: View {
     var localParticipant: CallParticipant
     @State private var labeledFrames: [ViewFramePreferenceData] = []
 
-    private func findTouchInterceptView() -> TouchInterceptView? {
-        // Find the TouchInterceptView by traversing up the view hierarchy
-        var currentView = UIApplication.shared.windows.first?.rootViewController?.view
-        while let view = currentView {
-            if let touchInterceptView = view as? TouchInterceptView {
-                return touchInterceptView
-            }
-            currentView = view.superview
-        }
-        return nil
-    }
-
     var body: some View {
         GeometryReader { proxy in
             if !participants.isEmpty {
@@ -170,20 +158,6 @@ struct ParticipantsView: View {
                         }
                     }
                 }
-                .onPreferenceChange(ViewFramePreferenceKey.self) { frames in
-                    print("ParticipantsView - Received frame updates:")
-                    print("Number of frames: \(frames.count)")
-                    frames.forEach { frame in
-                        print("Label: \(frame.label), Frame: \(frame.frame)")
-                    }
-                    self.labeledFrames = frames
-                    if let touchInterceptView = findTouchInterceptView() {
-                        print("ParticipantsView - Found TouchInterceptView, updating frames")
-                        touchInterceptView.updateLabeledFrames(frames)
-                    } else {
-                        print("ParticipantsView - Failed to find TouchInterceptView!")
-                    }
-                }
             } else {
                 Color.gray
             }

package/ios/Sources/StreamCallPlugin/StreamCallPlugin.swift

@@ -41,20 +41,16 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
 
     private var overlayView: UIView?
     private var hostingController: UIHostingController<CallOverlayView>?
-    private var overlayViewModel: CallOverlayViewModel?
     private var tokenSubscription: AnyCancellable?
     private var activeCallSubscription: AnyCancellable?
     private var lastVoIPToken: String?
-    private var touchInterceptView: TouchInterceptView?
 
     private var streamVideo: StreamVideo?
 
-    // Track the current active call ID
-    private var currentActiveCallId: String?
-
     // Store current call info for getCallStatus
     private var currentCallId: String = ""
     private var currentCallState: String = ""
+    private var hasNotifiedCallJoined: Bool = false
 
     @Injected(\.callKitAdapter) var callKitAdapter
     @Injected(\.callKitPushNotificationAdapter) var callKitPushNotificationAdapter
@@ -63,6 +59,9 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
     // Add class property to store call states
     private var callStates: [String: (members: [MemberResponse], participantResponses: [String: String], createdAt: Date, timer: Timer?)] = [:]
 
+    // Declare as optional and initialize in load() method
+    private var callViewModel: CallViewModel?
+
     // Helper method to update call status and notify listeners
     private func updateCallStatusAndNotify(callId: String, state: String, userId: String? = nil, reason: String? = nil) {
         // Update stored call info
@@ -95,7 +94,7 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
         if self.apiKey == nil {
             fatalError("Cannot get apikey")
         }
-
+        
         // Check if we have a logged in user for handling incoming calls
         if let credentials = SecureUserRepository.shared.loadCurrentUser() {
             print("Loading user for StreamCallPlugin: \(credentials.user.name)")
@@ -118,32 +117,6 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
         self.webView?.navigationDelegate = self.webviewDelegate
     }
 
-    //    private func cleanupStreamVideo() {
-    //        // Cancel subscriptions
-    //        tokenSubscription?.cancel()
-    //        tokenSubscription = nil
-    //        activeCallSubscription?.cancel()
-    //        activeCallSubscription = nil
-    //        lastVoIPToken = nil
-    //
-    //        // Cleanup UI
-    //        Task { @MainActor in
-    //            self.overlayViewModel?.updateCall(nil)
-    //            self.overlayViewModel?.updateStreamVideo(nil)
-    //            self.overlayView?.removeFromSuperview()
-    //            self.overlayView = nil
-    //            self.hostingController = nil
-    //            self.overlayViewModel = nil
-    //
-    //            // Reset webview
-    //            self.webView?.isOpaque = true
-    //            self.webView?.backgroundColor = .white
-    //            self.webView?.scrollView.backgroundColor = .white
-    //        }
-    //
-    //        state = .notInitialized
-    //    }
-
     private func requireInitialized() throws {
         guard state == .initialized else {
             throw NSError(domain: "StreamCallPlugin", code: -1, userInfo: [NSLocalizedDescriptionKey: "StreamVideo not initialized"])
@@ -192,191 +165,132 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
     }
 
     private func setupActiveCallSubscription() {
-        if let streamVideo = streamVideo {
-            Task {
-                for await event in streamVideo.subscribe() {
-                    // print("Event", event)
-                    if let ringingEvent = event.rawValue as? CallRingEvent {
-                        updateCallStatusAndNotify(callId: ringingEvent.callCid, state: "ringing")
-                        continue
-                    }
-
-                    if let callCreatedEvent = event.rawValue as? CallCreatedEvent {
-                        print("CallCreatedEvent \(String(describing: userId))")
-
-                        let callCid = callCreatedEvent.callCid
-                        let members = callCreatedEvent.members
-
-                        // Create timer on main thread
-                        await MainActor.run {
-                            // Store in the combined callStates map
-                            self.callStates[callCid] = (
-                                members: members,
-                                participantResponses: [:],
-                                createdAt: Date(),
-                                timer: nil
-                            )
-
-                            // Start timer to check for timeout every second
-                            // Use @objc method as timer target to avoid sendable closure issues
-                            let timer = Timer.scheduledTimer(timeInterval: 1.0, target: self, selector: #selector(self.checkCallTimeoutTimer(_:)), userInfo: callCid, repeats: true)
-
-                            // Update timer in callStates
-                            self.callStates[callCid]?.timer = timer
-                        }
-
-                        updateCallStatusAndNotify(callId: callCid, state: "created")
-                    }
-
-                    if let rejectedEvent = event.rawValue as? CallRejectedEvent {
-                        let userId = rejectedEvent.user.id
-                        let callCid = rejectedEvent.callCid
-
-                        // Operate on callStates on the main thread
-                        await MainActor.run {
-                            // Update the combined callStates map
-                            if var callState = self.callStates[callCid] {
-                                callState.participantResponses[userId] = "rejected"
-                                self.callStates[callCid] = callState
-                            }
-                        }
-
-                        print("CallRejectedEvent \(userId)")
-                        updateCallStatusAndNotify(callId: callCid, state: "rejected", userId: userId)
-
-                        await checkAllParticipantsResponded(callCid: callCid)
-                        continue
+        // Ensure this method is called on the main thread and properly establishes the subscription
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+            
+            // Cancel existing subscription if any
+            self.activeCallSubscription?.cancel()
+            self.activeCallSubscription = nil
+            
+            // Verify callViewModel exists
+            guard let callViewModel = self.callViewModel, let streamVideo = self.streamVideo else {
+                print("Warning: setupActiveCallSubscription called but callViewModel or streamVideo is nil")
+                // Schedule a retry after a short delay if callViewModel is nil
+                DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) { [weak self] in
+                    self?.setupActiveCallSubscription()
+                }
+                return
+            }
+            
+            print("Setting up active call subscription")
+            
+            // Create a strong reference to callViewModel to ensure it's not deallocated
+            // while the subscription is active
+            let viewModel = callViewModel
+            
+            // Subscribe to streamVideo.state.$activeCall to handle CallKit integration
+            let callPublisher = streamVideo.state.$activeCall
+                .receive(on: DispatchQueue.main)
+                .sink { [weak self, weak viewModel] activeCall in
+                    guard let self = self, let viewModel = viewModel else { return }
+                    
+                    print("Active call update from streamVideo: \(String(describing: activeCall?.cId))")
+                    
+                    if let activeCall = activeCall {
+                        // Sync callViewModel with activeCall from streamVideo state
+                        // This ensures CallKit integration works properly
+                        viewModel.setActiveCall(activeCall)
                     }
-
-                    if let missedEvent = event.rawValue as? CallMissedEvent {
-                        let userId = missedEvent.user.id
-                        let callCid = missedEvent.callCid
-
-                        // Operate on callStates on the main thread
-                        await MainActor.run {
-                            // Update the combined callStates map
-                            if var callState = self.callStates[callCid] {
-                                callState.participantResponses[userId] = "missed"
-                                self.callStates[callCid] = callState
-                            }
-                        }
-
-                        print("CallMissedEvent \(userId)")
-                        updateCallStatusAndNotify(callId: callCid, state: "missed", userId: userId)
-
-                        await checkAllParticipantsResponded(callCid: callCid)
-                        continue
+                }
+            
+            // Store the subscription for activeCall updates
+            self.activeCallSubscription = callPublisher
+            
+            // Additionally, subscribe to callingState for other call state changes
+            let statePublisher = viewModel.$callingState
+                .receive(on: DispatchQueue.main)
+                .sink { [weak self, weak viewModel] newState in
+                    guard let self = self, let viewModel = viewModel else {
+                        print("Warning: Call state update received but self or viewModel is nil")
+                        return
                     }
-
-                    if let participantLeftEvent = event.rawValue as? CallSessionParticipantLeftEvent {
-                        let callIdSplit = participantLeftEvent.callCid.split(separator: ":")
-                        if callIdSplit.count != 2 {
-                            print("CallSessionParticipantLeftEvent invalid cID \(participantLeftEvent.callCid)")
-                            continue
-                        }
-
-                        let callType = callIdSplit[0]
-                        let callId = callIdSplit[1]
-
-                        let call = streamVideo.call(callType: String(callType), callId: String(callId))
-                        if await MainActor.run(body: { (call.state.session?.participants.count ?? 1) - 1 <= 1 }) {
-
-                            print("We are left solo in a call. Ending. cID: \(participantLeftEvent.callCid)")
-
-                            Task {
-                                if let activeCall = streamVideo.state.activeCall {
-                                    activeCall.leave()
-                                }
+                    
+                    do {
+                        try self.requireInitialized()
+                        print("Call State Update: \(newState)")
+                        
+                        if newState == .inCall {
+                            print("- In call state detected")
+                            print("- All participants: \(String(describing: viewModel.participants))")
+                            
+                            // Create/update overlay and make visible when there's an active call
+                            self.createCallOverlayView()
+                            
+                            // Notify that a call has started - but only if we haven't notified for this call yet
+                            if let callId = viewModel.call?.cId, !self.hasNotifiedCallJoined || callId != self.currentCallId {
+                                print("Notifying call joined: \(callId)")
+                                self.updateCallStatusAndNotify(callId: callId, state: "joined")
+                                self.hasNotifiedCallJoined = true
                             }
-                        }
-                    }
-
-                    if let acceptedEvent = event.rawValue as? CallAcceptedEvent {
-                        let userId = acceptedEvent.user.id
-                        let callCid = acceptedEvent.callCid
-
-                        // Operate on callStates on the main thread
-                        await MainActor.run {
-                            // Update the combined callStates map
-                            if var callState = self.callStates[callCid] {
-                                callState.participantResponses[userId] = "accepted"
-
-                                // If someone accepted, invalidate the timer as we don't need to check anymore
-                                callState.timer?.invalidate()
-                                callState.timer = nil
-
-                                self.callStates[callCid] = callState
+                        } else if case .incoming(let incomingCall) = newState {
+                            self.updateCallStatusAndNotify(callId: incomingCall.id, state: "ringing")
+                        } else if newState == .idle && self.streamVideo?.state.activeCall == nil {
+                            // Get the call ID that was active before the state changed
+                            let endingCallId = viewModel.call?.cId
+                            print("Call ending: \(String(describing: endingCallId))")
+                            
+                            // Notify that call has ended - use the properly tracked call ID
+                            self.updateCallStatusAndNotify(callId: endingCallId ?? "", state: "left")
+                            
+                            // Reset notification flag when call ends
+                            self.hasNotifiedCallJoined = false
+                            
+                            // Clean up any resources for this call
+                            if let callCid = endingCallId {
+                                // Invalidate and remove the timer
+                                self.callStates[callCid]?.timer?.invalidate()
+                                
+                                // Remove call from callStates
+                                self.callStates.removeValue(forKey: callCid)
+                                
+                                print("Cleaned up resources for ended call: \(callCid)")
                             }
+                            
+                            // Remove the call overlay view when not in a call
+                            self.ensureViewRemoved()
                         }
-
-                        print("CallAcceptedEvent \(userId)")
-                        updateCallStatusAndNotify(callId: callCid, state: "accepted", userId: userId)
-                        continue
+                    } catch {
+                        log.error("Error handling call state update: \(String(describing: error))")
                     }
-
-                    updateCallStatusAndNotify(callId: streamVideo.state.activeCall?.callId ?? "", state: event.type)
                 }
+            
+            // Combine both publishers
+            self.activeCallSubscription = AnyCancellable {
+                callPublisher.cancel()
+                statePublisher.cancel()
             }
+            
+            print("Active call subscription setup completed")
+            
+            // Schedule a periodic check to ensure subscription is active
+            self.scheduleSubscriptionCheck()
         }
-        // Cancel existing subscription if any
-        activeCallSubscription?.cancel()
-        // Create new subscription
-        activeCallSubscription = streamVideo?.state.$activeCall.sink { [weak self] newState in
+    }
+    
+    // Add a new method to periodically check and restore the subscription if needed
+    private func scheduleSubscriptionCheck() {
+        // Create a timer that checks the subscription every 5 seconds
+        DispatchQueue.main.asyncAfter(deadline: .now() + 5.0) { [weak self] in
             guard let self = self else { return }
-
-            Task { @MainActor in
-                do {
-                    try self.requireInitialized()
-                    print("Call State Update:")
-                    print("- Call is nil: \(newState == nil)")
-
-                    if let state = newState?.state {
-                        print("- state: \(state)")
-                        print("- Session ID: \(state.sessionId)")
-                        print("- All participants: \(String(describing: state.participants))")
-                        print("- Remote participants: \(String(describing: state.remoteParticipants))")
-
-                        // Store the active call ID when a call becomes active
-                        self.currentActiveCallId = newState?.cId
-                        print("Updated current active call ID: \(String(describing: self.currentActiveCallId))")
-
-                        // Update overlay and make visible when there's an active call
-                        self.overlayViewModel?.updateCall(newState)
-                        self.overlayView?.isHidden = false
-                        self.webView?.isOpaque = false
-
-                        // Notify that a call has started
-                        self.updateCallStatusAndNotify(callId: newState?.cId ?? "", state: "joined")
-                    } else {
-                        // Get the call ID that was active before the state changed to nil
-                        let endingCallId = self.currentActiveCallId
-                        print("Call ending: \(String(describing: endingCallId))")
-
-                        // If newState is nil, hide overlay and clear call
-                        self.overlayViewModel?.updateCall(nil)
-                        self.overlayView?.isHidden = true
-                        self.webView?.isOpaque = true
-
-                        // Notify that call has ended - use the properly tracked call ID
-                        self.updateCallStatusAndNotify(callId: endingCallId ?? "", state: "left")
-
-                        // Clean up any resources for this call
-                        if let callCid = endingCallId {
-                            // Invalidate and remove the timer
-                            self.callStates[callCid]?.timer?.invalidate()
-
-                            // Remove call from callStates
-                            self.callStates.removeValue(forKey: callCid)
-
-                            print("Cleaned up resources for ended call: \(callCid)")
-                        }
-
-                        // Clear the active call ID
-                        self.currentActiveCallId = nil
-                    }
-                } catch {
-                    log.error("Error handling call state update: \(String(describing: error))")
-                }
+            
+            // Check if we're in a state where we need the subscription but it's not active
+            if self.state == .initialized && self.activeCallSubscription == nil && self.callViewModel != nil {
+                print("Subscription check: Restoring lost activeCallSubscription")
+                self.setupActiveCallSubscription()
+            } else {
+                // Schedule the next check
+                self.scheduleSubscriptionCheck()
             }
         }
     }
@@ -456,7 +370,7 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
 
                 // Update UI
                 await MainActor.run {
-                    self.overlayViewModel?.updateCall(nil)
+                    // self.overlayViewModel?.updateCall(nil)
                     self.overlayView?.isHidden = true
                     self.webView?.isOpaque = true
                     self.updateCallStatusAndNotify(callId: callCid, state: "ended", reason: "timeout")
@@ -501,7 +415,7 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
                 // Remove from callStates
                 self.callStates.removeValue(forKey: callCid)
 
-                self.overlayViewModel?.updateCall(nil)
+                // self.overlayViewModel?.updateCall(nil)
                 self.overlayView?.isHidden = true
                 self.webView?.isOpaque = true
                 self.updateCallStatusAndNotify(callId: callCid, state: "ended", reason: "all_rejected_or_missed")
@@ -537,7 +451,7 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
 
         // Update the CallOverlayView with new StreamVideo instance
         Task { @MainActor in
-            self.overlayViewModel?.updateStreamVideo(self.streamVideo)
+            // self.overlayViewModel?.updateStreamVideo(self.streamVideo)
         }
 
         call.resolve([
@@ -571,8 +485,8 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
 
         // Update the CallOverlayView with nil StreamVideo instance
         Task { @MainActor in
-            self.overlayViewModel?.updateCall(nil)
-            self.overlayViewModel?.updateStreamVideo(nil)
+            // self.overlayViewModel?.updateCall(nil)
+            // self.overlayViewModel?.updateStreamVideo(nil)
             self.overlayView?.isHidden = true
             self.webView?.isOpaque = true
         }
@@ -655,7 +569,7 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
 
                     // Update the CallOverlayView with the active call
                     await MainActor.run {
-                        self.overlayViewModel?.updateCall(streamCall)
+                        // self.overlayViewModel?.updateCall(streamCall)
                         self.overlayView?.isHidden = false
                         self.webView?.isOpaque = false
                     }
@@ -683,7 +597,7 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
 
                     // Update view state instead of cleaning up
                     await MainActor.run {
-                        self.overlayViewModel?.updateCall(nil)
+                        // self.overlayViewModel?.updateCall(nil)
                         self.overlayView?.isHidden = true
                         self.webView?.isOpaque = true
                     }
@@ -782,13 +696,17 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
 
                     // Join the call
                     print("Accepting and joining call \(streamCall!.cId)...")
-                    try await streamCall?.accept()
-                    try await streamCall?.join(create: false)
+                    guard case .incoming(let incomingCall) = await self.callViewModel?.callingState else {
+                        call.reject("Failed to accept call as there is no call ID")
+                        return
+                    }
+
+                    await self.callViewModel?.acceptCall(callType: incomingCall.type, callId: incomingCall.id)
                     print("Successfully joined call")
 
                     // Update the CallOverlayView with the active call
                     await MainActor.run {
-                        self.overlayViewModel?.updateCall(streamCall)
+                        // self.overlayViewModel?.updateCall(streamCall)
                         self.overlayView?.isHidden = false
                         self.webView?.isOpaque = false
                     }
@@ -807,6 +725,21 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
     }
 
     private func initializeStreamVideo() {
+        if (state == .initialized) {
+            print("initializeStreamVideo already initialized")
+            // Try to get user credentials from repository
+            guard let savedCredentials = SecureUserRepository.shared.loadCurrentUser() else {
+                print("Save credentials not found, skipping initialization")
+                return
+            }
+            if (savedCredentials.user.id == streamVideo?.user.id) {
+                print("Skipping initializeStreamVideo as user is already logged in")
+                return
+            }
+        } else if (state == .initializing) {
+            print("initializeStreamVideo rejected - already initializing")
+            return
+        }
         state = .initializing
 
         // Try to get user credentials from repository
@@ -818,11 +751,31 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
         }
         print("Initializing with saved credentials for user: \(savedCredentials.user.name)")
 
+        LogConfig.level = .debug
         self.streamVideo = StreamVideo(
             apiKey: apiKey,
             user: savedCredentials.user,
-            token: UserToken(stringLiteral: savedCredentials.tokenValue)
+            token: UserToken(stringLiteral: savedCredentials.tokenValue),
+            tokenProvider: {completion in
+                guard let savedCredentials = SecureUserRepository.shared.loadCurrentUser() else {
+                    print("No saved credentials or API key found, cannot refresh token")
+                    
+                    completion(.failure(NSError(domain: "No saved credentials or API key found, cannot refresh token", code: 0, userInfo: nil)))
+                    return
+                }
+                completion(.success(UserToken(stringLiteral: savedCredentials.tokenValue)))
+            }
         )
+        
+        if (self.callViewModel == nil) {
+            // Initialize on main thread with proper MainActor isolation
+            DispatchQueue.main.async {
+                Task { @MainActor in
+                    self.callViewModel = CallViewModel(participantsLayout: .grid)
+                    self.callViewModel?.participantAutoLeavePolicy = LastParticipantAutoLeavePolicy()
+                }
+            }
+        }
 
         state = .initialized
         callKitAdapter.streamVideo = self.streamVideo
@@ -837,63 +790,98 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
     }
 
     private func setupViews() {
-        guard let webView = self.webView,
-              let parent = webView.superview else { return }
 
-        // Create TouchInterceptView
-        let touchInterceptView = TouchInterceptView(frame: parent.bounds)
-        touchInterceptView.translatesAutoresizingMaskIntoConstraints = false
-        self.touchInterceptView = touchInterceptView
 
-        // Remove webView from its parent
-        webView.removeFromSuperview()
-
-        // Add TouchInterceptView to the parent
-        parent.addSubview(touchInterceptView)
-
-        // Setup TouchInterceptView constraints
+//        // Create SwiftUI view with view model
+//        let (hostingController, viewModel) = CallOverlayView.create(streamVideo: self.streamVideo)
+//        hostingController.view.backgroundColor = .clear
+//        hostingController.view.translatesAutoresizingMaskIntoConstraints = false
+//
+//        self.hostingController = hostingController
+//        self.overlayViewModel = viewModel
+//        self.overlayView = hostingController.view
+//
+//        if let overlayView = self.overlayView {
+//            // Setup the views in TouchInterceptView
+//            touchInterceptView.setupWithWebView(webView, overlayView: overlayView)
+//
+//            // Setup constraints for webView
+//            NSLayoutConstraint.activate([
+//                webView.topAnchor.constraint(equalTo: touchInterceptView.topAnchor),
+//                webView.bottomAnchor.constraint(equalTo: touchInterceptView.bottomAnchor),
+//                webView.leadingAnchor.constraint(equalTo: touchInterceptView.leadingAnchor),
+//                webView.trailingAnchor.constraint(equalTo: touchInterceptView.trailingAnchor)
+//            ])
+//
+//            // Setup constraints for overlayView
+//            let safeGuide = touchInterceptView.safeAreaLayoutGuide
+//            NSLayoutConstraint.activate([
+//                overlayView.topAnchor.constraint(equalTo: safeGuide.topAnchor),
+//                overlayView.bottomAnchor.constraint(equalTo: safeGuide.bottomAnchor),
+//                overlayView.leadingAnchor.constraint(equalTo: safeGuide.leadingAnchor),
+//                overlayView.trailingAnchor.constraint(equalTo: safeGuide.trailingAnchor)
+//            ])
+//        }
+    }
+    
+    private func createCallOverlayView() {
+        guard let webView = self.webView,
+              let parent = webView.superview,
+              let callOverlayView = self.callViewModel else { return }
+        
+        // Check if we already have an overlay view - do nothing if it exists
+        if let existingOverlayView = self.overlayView, existingOverlayView.superview != nil {
+            print("Call overlay view already exists, doing nothing")
+            return
+        }
+        
+        print("Creating new call overlay view")
+        
+        // First, create the overlay view
+        let overlayView = CallOverlayView.create(callViewModel: callOverlayView)
+        overlayView.view.translatesAutoresizingMaskIntoConstraints = false
+        
+        // Important: Insert the overlay view BELOW the webView in the view hierarchy
+        parent.insertSubview(overlayView.view, belowSubview: webView)
+        
+        // Set constraints to fill the parent's safe area
+        let safeGuide = parent.safeAreaLayoutGuide
+        
         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)
+            overlayView.view.topAnchor.constraint(equalTo: safeGuide.topAnchor),
+            overlayView.view.bottomAnchor.constraint(equalTo: safeGuide.bottomAnchor),
+            overlayView.view.leadingAnchor.constraint(equalTo: safeGuide.leadingAnchor),
+            overlayView.view.trailingAnchor.constraint(equalTo: safeGuide.trailingAnchor)
         ])
-
-        // Configure webview for transparency
-        webView.isOpaque = true
+        
+        // Set opacity for visual effect - make webView transparent to see overlay
+        webView.isOpaque = false
         webView.backgroundColor = .clear
         webView.scrollView.backgroundColor = .clear
-        webView.translatesAutoresizingMaskIntoConstraints = false
-
-        // Create SwiftUI view with view model
-        let (hostingController, viewModel) = CallOverlayView.create(streamVideo: self.streamVideo)
-        hostingController.view.backgroundColor = .clear
-        hostingController.view.translatesAutoresizingMaskIntoConstraints = false
-
-        self.hostingController = hostingController
-        self.overlayViewModel = viewModel
-        self.overlayView = hostingController.view
-
-        if let overlayView = self.overlayView {
-            // Setup the views in TouchInterceptView
-            touchInterceptView.setupWithWebView(webView, overlayView: overlayView)
-
-            // Setup constraints for webView
-            NSLayoutConstraint.activate([
-                webView.topAnchor.constraint(equalTo: touchInterceptView.topAnchor),
-                webView.bottomAnchor.constraint(equalTo: touchInterceptView.bottomAnchor),
-                webView.leadingAnchor.constraint(equalTo: touchInterceptView.leadingAnchor),
-                webView.trailingAnchor.constraint(equalTo: touchInterceptView.trailingAnchor)
-            ])
+        
+        // Store reference to the hosting controller
+        self.hostingController = overlayView
+        self.overlayView = overlayView.view
+    }
 
-            // Setup constraints for overlayView
-            let safeGuide = touchInterceptView.safeAreaLayoutGuide
-            NSLayoutConstraint.activate([
-                overlayView.topAnchor.constraint(equalTo: safeGuide.topAnchor),
-                overlayView.bottomAnchor.constraint(equalTo: safeGuide.bottomAnchor),
-                overlayView.leadingAnchor.constraint(equalTo: safeGuide.leadingAnchor),
-                overlayView.trailingAnchor.constraint(equalTo: safeGuide.trailingAnchor)
-            ])
+    private func ensureViewRemoved() {
+        // Check if we have an overlay view
+        if let existingOverlayView = self.overlayView {
+            print("Removing call overlay view")
+            
+            // Remove the view from its superview
+            existingOverlayView.removeFromSuperview()
+            
+            // Reset opacity for webView
+            self.webView?.isOpaque = true
+            self.webView?.backgroundColor = nil
+            self.webView?.scrollView.backgroundColor = nil
+            
+            // Clear references
+            self.overlayView = nil
+            self.hostingController = nil
+        } else {
+            print("No call overlay view to remove")
         }
     }
 

package/package.json

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

package/ios/Sources/StreamCallPlugin/TouchInterceptView.swift

@@ -1,177 +0,0 @@
-import UIKit
-
-class TouchInterceptView: UIView {
-    private var webView: UIView?
-    private var overlayView: UIView?
-    private var labeledFrames: [ViewFramePreferenceData] = []
-
-    override init(frame: CGRect) {
-        super.init(frame: frame)
-        isUserInteractionEnabled = true
-    }
-
-    required init?(coder: NSCoder) {
-        super.init(coder: coder)
-        isUserInteractionEnabled = true
-    }
-
-    func setupWithWebView(_ webView: UIView, overlayView: UIView) {
-        self.webView = webView
-        self.overlayView = overlayView
-
-        // Add both views as subviews
-        addSubview(overlayView)
-        addSubview(webView)
-
-        // Ensure both views can receive touches
-        webView.isUserInteractionEnabled = true
-        overlayView.isUserInteractionEnabled = true
-    }
-
-    override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
-        guard let webView = webView,
-              let overlayView = overlayView else {
-            super.touchesBegan(touches, with: event)
-            return
-        }
-
-        // Convert touch locations and check labeled frames
-        if let touch = touches.first {
-            let point = touch.location(in: self)
-            let globalPoint = convert(point, to: nil)
-
-            // If touch is in a labeled frame, only send to overlay
-            if labeledFrames.contains(where: { $0.frame.contains(globalPoint) }) {
-                overlayView.touchesBegan(touches, with: event)
-            } else {
-                // Otherwise broadcast to both views
-                webView.touchesBegan(touches, with: event)
-                overlayView.touchesBegan(touches, with: event)
-            }
-        }
-
-        super.touchesBegan(touches, with: event)
-    }
-
-    override func touchesMoved(_ touches: Set<UITouch>, with event: UIEvent?) {
-        guard let webView = webView,
-              let overlayView = overlayView else {
-            super.touchesMoved(touches, with: event)
-            return
-        }
-
-        if let touch = touches.first {
-            let point = touch.location(in: self)
-            let globalPoint = convert(point, to: nil)
-
-            if labeledFrames.contains(where: { $0.frame.contains(globalPoint) }) {
-                overlayView.touchesMoved(touches, with: event)
-            } else {
-                webView.touchesMoved(touches, with: event)
-                overlayView.touchesMoved(touches, with: event)
-            }
-        }
-
-        super.touchesMoved(touches, with: event)
-    }
-
-    override func touchesEnded(_ touches: Set<UITouch>, with event: UIEvent?) {
-        guard let webView = webView,
-              let overlayView = overlayView else {
-            super.touchesEnded(touches, with: event)
-            return
-        }
-
-        if let touch = touches.first {
-            let point = touch.location(in: self)
-            let globalPoint = convert(point, to: nil)
-
-            if labeledFrames.contains(where: { $0.frame.contains(globalPoint) }) {
-                overlayView.touchesEnded(touches, with: event)
-            } else {
-                webView.touchesEnded(touches, with: event)
-                overlayView.touchesEnded(touches, with: event)
-            }
-        }
-
-        super.touchesEnded(touches, with: event)
-    }
-
-    override func touchesCancelled(_ touches: Set<UITouch>, with event: UIEvent?) {
-        guard let webView = webView,
-              let overlayView = overlayView else {
-            super.touchesCancelled(touches, with: event)
-            return
-        }
-
-        if let touch = touches.first {
-            let point = touch.location(in: self)
-            let globalPoint = convert(point, to: nil)
-
-            if labeledFrames.contains(where: { $0.frame.contains(globalPoint) }) {
-                overlayView.touchesCancelled(touches, with: event)
-            } else {
-                webView.touchesCancelled(touches, with: event)
-                overlayView.touchesCancelled(touches, with: event)
-            }
-        }
-
-        super.touchesCancelled(touches, with: event)
-    }
-
-    override func point(inside point: CGPoint, with event: UIEvent?) -> Bool {
-        return true
-    }
-
-    override func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {
-        guard let webView = webView,
-              let overlayView = overlayView else {
-            return super.hitTest(point, with: event)
-        }
-
-        // Convert point to global coordinates for labeled frame checking
-        let globalPoint = convert(point, to: nil)
-
-        // print("TouchInterceptView - Hit test at global point: \(globalPoint)")
-        // print("Current labeled frames: \(labeledFrames.map { "\($0.label): \($0.frame)" }.joined(separator: ", "))")
-
-        // Convert point for both views
-        let webViewPoint = convert(point, to: webView)
-        let overlayPoint = convert(point, to: overlayView)
-
-        // First check if the point is inside any labeled frame
-        for labeledFrame in labeledFrames {
-            if labeledFrame.frame.contains(globalPoint) {
-                // print("Hit labeled frame: \(labeledFrame.label)")
-                // If it's in a labeled frame, let the overlay handle it
-                if overlayView.point(inside: overlayPoint, with: event),
-                   let overlayHitView = overlayView.hitTest(overlayPoint, with: event) {
-                    return overlayHitView
-                }
-            }
-        }
-
-        // If not in a labeled frame, let webview try first
-        if webView.point(inside: webViewPoint, with: event),
-           let webViewHitView = webView.hitTest(webViewPoint, with: event) {
-            return webViewHitView
-        }
-
-        // Finally check if overlay wants to handle the touch
-        if overlayView.point(inside: overlayPoint, with: event),
-           let overlayHitView = overlayView.hitTest(overlayPoint, with: event) {
-            return overlayHitView
-        }
-
-        return super.hitTest(point, with: event)
-    }
-
-    func updateLabeledFrames(_ frames: [ViewFramePreferenceData]) {
-        print("TouchInterceptView - Updating labeled frames:")
-        print("Number of frames: \(frames.count)")
-        frames.forEach { frame in
-            print("Label: \(frame.label), Frame: \(frame.frame)")
-        }
-        self.labeledFrames = frames
-    }
-}