@capgo/capacitor-stream-call 0.0.2 → 0.0.4

package/ios/Sources/StreamCallPlugin/StreamCallPlugin.swift

@@ -22,9 +22,10 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
         CAPPluginMethod(name: "endCall", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "setMicrophoneEnabled", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "setCameraEnabled", returnType: CAPPluginReturnPromise),
-        CAPPluginMethod(name: "acceptCall", returnType: CAPPluginReturnPromise)
+        CAPPluginMethod(name: "acceptCall", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "isCameraEnabled", returnType: CAPPluginReturnPromise)
     ]
-
+    
     private enum State {
         case notInitialized
         case initializing
@@ -36,7 +37,7 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
     private static let tokenRefreshSemaphore = DispatchSemaphore(value: 1)
     private var currentToken: String?
     private var tokenWaitSemaphore: DispatchSemaphore?
-
+    
     private var overlayView: UIView?
     private var hostingController: UIHostingController<CallOverlayView>?
     private var overlayViewModel: CallOverlayViewModel?
@@ -44,17 +45,19 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
     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?
+    
     @Injected(\.callKitAdapter) var callKitAdapter
     @Injected(\.callKitPushNotificationAdapter) var callKitPushNotificationAdapter
-
-    private var refreshTokenURL: String?
-    private var refreshTokenHeaders: [String: String]?
-
     private var webviewDelegate: WebviewNavigationDelegate?
-
+    
+    // Add class property to store call states
+    private var callStates: [String: (members: [MemberResponse], participantResponses: [String: String], createdAt: Date, timer: Timer?)] = [:]
+    
     override public func load() {
         // Read API key from Info.plist
         if let apiKey = Bundle.main.object(forInfoDictionaryKey: "CAPACITOR_STREAM_VIDEO_APIKEY") as? String {
@@ -63,7 +66,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)")
@@ -71,21 +74,21 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
                 self.initializeStreamVideo()
             }
         }
-
+        
         // Create and set the navigation delegate
         self.webviewDelegate = WebviewNavigationDelegate(
             wrappedDelegate: self.webView?.navigationDelegate,
             onSetupOverlay: { [weak self] in
                 guard let self = self else { return }
                 print("Attempting to setup call view")
-
+                
                 self.setupViews()
             }
         )
-
+        
         self.webView?.navigationDelegate = self.webviewDelegate
     }
-
+    
     //    private func cleanupStreamVideo() {
     //        // Cancel subscriptions
     //        tokenSubscription?.cancel()
@@ -111,125 +114,28 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
     //
     //        state = .notInitialized
     //    }
-
+    
     private func requireInitialized() throws {
         guard state == .initialized else {
             throw NSError(domain: "StreamCallPlugin", code: -1, userInfo: [NSLocalizedDescriptionKey: "StreamVideo not initialized"])
         }
     }
-
-    private func refreshToken() throws -> UserToken {
-        // Acquire the semaphore in a thread-safe way
-        StreamCallPlugin.tokenRefreshQueue.sync {
-            StreamCallPlugin.tokenRefreshSemaphore.wait()
-        }
-
-        defer {
-            // Always release the semaphore when we're done, even if we throw an error
-            StreamCallPlugin.tokenRefreshSemaphore.signal()
-        }
-
-        // Clear current token
-        currentToken = nil
-
-        // Create a local semaphore for waiting on the token
-        let localSemaphore = DispatchSemaphore(value: 0)
-        tokenWaitSemaphore = localSemaphore
-
-        // Capture webView before async context
-        guard let webView = self.webView else {
-            print("WebView not available")
-            tokenWaitSemaphore = nil
-            throw NSError(domain: "StreamCallPlugin", code: -1, userInfo: [NSLocalizedDescriptionKey: "WebView not available"])
-        }
-
-        guard let refreshURL = self.refreshTokenURL else {
-            print("Refresh URL not configured")
-            tokenWaitSemaphore = nil
-            throw NSError(domain: "StreamCallPlugin", code: -1, userInfo: [NSLocalizedDescriptionKey: "Refresh URL not configured"])
-        }
-
-        let headersJSON = (self.refreshTokenHeaders ?? [:]).reduce(into: "") { result, pair in
-            result += "\n'\(pair.key)': '\(pair.value)',"
-        }
-
-        let script = """
-            (function() {
-                console.log('Starting token refresh...');
-                fetch('\(refreshURL)', {
-                    headers: {
-                        \(headersJSON)
-                    }
-                })
-                .then(response => {
-                    console.log('Got response:', response.status);
-                    return response.json();
-                })
-                .then(data => {
-                    console.log('Got data, token length:', data.token?.length);
-                    const tokenA = data.token;
-                    window.Capacitor.Plugins.StreamCall.loginMagicToken({
-                        token: tokenA
-                    });
-                })
-                .catch(error => {
-                    console.error('Token refresh error:', error);
-                });
-            })();
-        """
-
-        if Thread.isMainThread {
-            print("Executing script on main thread")
-            webView.evaluateJavaScript(script, completionHandler: nil)
-        } else {
-            print("Executing script from background thread")
-            DispatchQueue.main.sync {
-                webView.evaluateJavaScript(script, completionHandler: nil)
-            }
-        }
-
-        // Set up a timeout
-        let timeoutQueue = DispatchQueue.global()
-        let timeoutWork = DispatchWorkItem {
-            print("Token refresh timed out")
-            self.tokenWaitSemaphore?.signal()
-            self.tokenWaitSemaphore = nil
-        }
-        timeoutQueue.asyncAfter(deadline: .now() + 10.0, execute: timeoutWork) // 10 second timeout
-
-        // Wait for token to be set via loginMagicToken or timeout
-        localSemaphore.wait()
-        timeoutWork.cancel()
-        tokenWaitSemaphore = nil
-
-        guard let token = currentToken else {
-            print("Failed to get token")
-            throw NSError(domain: "StreamCallPlugin", code: -1, userInfo: [NSLocalizedDescriptionKey: "Failed to get token or timeout occurred"])
-        }
-
-        // Save the token
-        SecureUserRepository.shared.save(token: token)
-
-        print("Got the token!!!")
-        return UserToken(stringLiteral: token)
-    }
-
     @objc func loginMagicToken(_ call: CAPPluginCall) {
         guard let token = call.getString("token") else {
             call.reject("Missing token parameter")
             return
         }
-
+        
         print("loginMagicToken received token")
         currentToken = token
         tokenWaitSemaphore?.signal()
         call.resolve()
     }
-
+    
     private func setupTokenSubscription() {
         // Cancel existing subscription if any
         tokenSubscription?.cancel()
-
+        
         // Create new subscription
         tokenSubscription = callKitPushNotificationAdapter.$deviceToken.sink { [weak self] (updatedDeviceToken: String) in
             guard let self = self else { return }
@@ -255,19 +161,144 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
             }
         }
     }
-
+    
     private func setupActiveCallSubscription() {
         if let streamVideo = streamVideo {
             Task {
                 for await event in streamVideo.subscribe() {
-                    print("Event", event)
+                    // print("Event", event)
                     if let ringingEvent = event.rawValue as? CallRingEvent {
                         notifyListeners("callEvent", data: [
                             "callId": ringingEvent.callCid,
                             "state": "ringing"
                         ])
-                        return
+                        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
+                        }
+                    }
+                    
+                    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)")
+                        notifyListeners("callEvent", data: [
+                            "callId": callCid,
+                            "state": "rejected",
+                            "userId": userId
+                        ])
+                        
+                        await checkAllParticipantsResponded(callCid: callCid)
+                        continue
+                    }
+                    
+                    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)")
+                        notifyListeners("callEvent", data: [
+                            "callId": callCid,
+                            "state": "missed",
+                            "userId": userId
+                        ])
+                        
+                        await checkAllParticipantsResponded(callCid: callCid)
+                        continue
+                    }
+                    
+                    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()
+                                }
+                            }
+                        }
+                    }
+                    
+                    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
+                            }
+                        }
+                        
+                        print("CallAcceptedEvent \(userId)")
+                        notifyListeners("callEvent", data: [
+                            "callId": callCid,
+                            "state": "accepted",
+                            "userId": userId
+                        ])
+                        continue
                     }
+                    
                     notifyListeners("callEvent", data: [
                         "callId": streamVideo.state.activeCall?.callId ?? "",
                         "state": event.type
@@ -280,38 +311,62 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
         // Create new subscription
         activeCallSubscription = streamVideo?.state.$activeCall.sink { [weak self] newState 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.notifyListeners("callEvent", data: [
                             "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
+                        
+                        // Notify that call has ended - use the properly tracked call ID
                         self.notifyListeners("callEvent", data: [
-                            "callId": newState?.cId ?? "",
+                            "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))")
@@ -319,57 +374,187 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
             }
         }
     }
-
+    
+    @objc private func checkCallTimeoutTimer(_ timer: Timer) {
+        guard let callCid = timer.userInfo as? String else { return }
+        
+        Task { [weak self] in
+            guard let self = self else { return }
+            await self.checkCallTimeout(callCid: callCid)
+        }
+    }
+    
+    private func checkCallTimeout(callCid: String) async {
+        // Get a local copy of the call state from the main thread
+        let callState: (members: [MemberResponse], participantResponses: [String: String], createdAt: Date, timer: Timer?)? = await MainActor.run {
+            return self.callStates[callCid]
+        }
+        
+        guard let callState = callState else { return }
+        
+        // Calculate time elapsed since call creation
+        let now = Date()
+        let elapsedSeconds = now.timeIntervalSince(callState.createdAt)
+        
+        // Check if 30 seconds have passed
+        if elapsedSeconds >= 30.0 {
+
+            // Check if anyone has accepted
+            let hasAccepted = callState.participantResponses.values.contains { $0 == "accepted" }
+            
+            if !hasAccepted {
+                print("Call \(callCid) has timed out after \(elapsedSeconds) seconds")
+                print("No one accepted call \(callCid), marking all non-responders as missed")
+                
+                // Mark all members who haven't responded as "missed"
+                for member in callState.members {
+                    let memberId = member.userId
+                    let needsToBeMarkedAsMissed = await MainActor.run {
+                        return self.callStates[callCid]?.participantResponses[memberId] == nil
+                    }
+                    
+                    if needsToBeMarkedAsMissed {
+                        // Update callStates map on main thread
+                        await MainActor.run {
+                            var updatedCallState = self.callStates[callCid]
+                            updatedCallState?.participantResponses[memberId] = "missed"
+                            if let updatedCallState = updatedCallState {
+                                self.callStates[callCid] = updatedCallState
+                            }
+                        }
+                        
+                        // Notify listeners
+                        await MainActor.run {
+                            self.notifyListeners("callEvent", data: [
+                                "callId": callCid,
+                                "state": "missed",
+                                "userId": memberId
+                            ])
+                        }
+                    }
+                }
+                
+                // End the call
+                if let call = streamVideo?.state.activeCall, call.cId == callCid {
+                    call.leave()
+                }
+                
+                // Clean up timer on main thread
+                await MainActor.run {
+                    self.callStates[callCid]?.timer?.invalidate()
+                    var updatedCallState = self.callStates[callCid]
+                    updatedCallState?.timer = nil
+                    if let updatedCallState = updatedCallState {
+                        self.callStates[callCid] = updatedCallState
+                    }
+                    
+                    // Remove from callStates
+                    self.callStates.removeValue(forKey: callCid)
+                }
+                
+                // Update UI
+                await MainActor.run {
+                    self.overlayViewModel?.updateCall(nil)
+                    self.overlayView?.isHidden = true
+                    self.webView?.isOpaque = true
+                    self.notifyListeners("callEvent", data: [
+                        "callId": callCid,
+                        "state": "ended",
+                        "reason": "timeout"
+                    ])
+                }
+            }
+        }
+    }
+    
+    private func checkAllParticipantsResponded(callCid: String) async {
+        // Get a local copy of the call state from the main thread
+        let callState: (members: [MemberResponse], participantResponses: [String: String], createdAt: Date, timer: Timer?)? = await MainActor.run {
+            return self.callStates[callCid]
+        }
+        
+        guard let callState = callState else {
+            print("Call state not found for cId: \(callCid)")
+            return
+        }
+        
+        let totalParticipants = callState.members.count
+        let responseCount = callState.participantResponses.count
+        
+        print("Total participants: \(totalParticipants), Responses: \(responseCount)")
+        
+        let allResponded = responseCount >= totalParticipants
+        let allRejectedOrMissed = allResponded && 
+            callState.participantResponses.values.allSatisfy { $0 == "rejected" || $0 == "missed" }
+        
+        if allResponded && allRejectedOrMissed {
+            print("All participants have rejected or missed the call")
+            
+            // End the call
+            if let call = streamVideo?.state.activeCall, call.cId == callCid {
+                call.leave()
+            }
+            
+            // Clean up timer and remove from callStates on main thread
+            await MainActor.run {
+                // Clean up timer
+                self.callStates[callCid]?.timer?.invalidate()
+                
+                // Remove from callStates
+                self.callStates.removeValue(forKey: callCid)
+                
+                self.overlayViewModel?.updateCall(nil)
+                self.overlayView?.isHidden = true
+                self.webView?.isOpaque = true
+                self.notifyListeners("callEvent", data: [
+                    "callId": callCid,
+                    "state": "ended",
+                    "reason": "all_rejected_or_missed"
+                ])
+            }
+        }
+    }
+    
     @objc func login(_ call: CAPPluginCall) {
         guard let token = call.getString("token"),
               let userId = call.getString("userId"),
-              let name = call.getString("name"),
-              let apiKey = call.getString("apiKey") else {
+              let name = call.getString("name") else {
             call.reject("Missing required parameters")
             return
         }
-
+        
         let imageURL = call.getString("imageURL")
-        let refreshTokenConfig = call.getObject("refreshToken")
-        let refreshTokenURL = refreshTokenConfig?["url"] as? String
-        let refreshTokenHeaders = refreshTokenConfig?["headers"] as? [String: String]
-
         let user = User(
             id: userId,
             name: name,
             imageURL: imageURL.flatMap { URL(string: $0) },
             customData: [:]
         )
-
+        
         let credentials = UserCredentials(user: user, tokenValue: token)
         SecureUserRepository.shared.save(user: credentials)
-
-        // Store API key and refresh config for later use
-        self.refreshTokenURL = refreshTokenURL
-        self.refreshTokenHeaders = refreshTokenHeaders
-
         // Initialize Stream Video with new credentials
         initializeStreamVideo()
-
+        
         if state != .initialized {
             call.reject("Failed to initialize StreamVideo")
             return
         }
-
+        
         // Update the CallOverlayView with new StreamVideo instance
         Task { @MainActor in
             self.overlayViewModel?.updateStreamVideo(self.streamVideo)
         }
-
+        
         call.resolve([
             "success": true
         ])
     }
-
+    
     @objc func logout(_ call: CAPPluginCall) {
         // Remove VOIP token from repository
         SecureUserRepository.shared.save(voipPushToken: nil)
-
+        
         // Try to delete the device from Stream if we have the last token
         if let lastVoIPToken = lastVoIPToken {
             Task {
@@ -380,16 +565,16 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
                 }
             }
         }
-
+        
         // Cancel subscriptions
         tokenSubscription?.cancel()
         tokenSubscription = nil
         activeCallSubscription?.cancel()
         activeCallSubscription = nil
         lastVoIPToken = nil
-
+        
         SecureUserRepository.shared.removeCurrentUser()
-
+        
         // Update the CallOverlayView with nil StreamVideo instance
         Task { @MainActor in
             self.overlayViewModel?.updateCall(nil)
@@ -397,24 +582,41 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
             self.overlayView?.isHidden = true
             self.webView?.isOpaque = true
         }
-
+        
         call.resolve([
             "success": true
         ])
     }
+    
+    @objc func isCameraEnabled(_ call: CAPPluginCall) {
+        do {
+            try requireInitialized()
+        } catch {
+            call.reject("SDK not initialized")
+        }
+        
+        if let activeCall = streamVideo?.state.activeCall {
+            call.resolve([
+                "enabled": activeCall.camera.status == .enabled
+            ])
+        } else {
+            call.reject("No active call")
+        }
+    }
 
     @objc func call(_ call: CAPPluginCall) {
-        guard let userId = call.getString("userId") else {
-            call.reject("Missing required parameter: userId")
+        guard let members = call.getArray("userIds", String.self) else {
+            call.reject("Missing required parameter: userIds (array of user IDs)")
+            return
+        }
+
+        if members.isEmpty {
+            call.reject("userIds array cannot be empty")
             return
         }
 
         // Initialize if needed
         if state == .notInitialized {
-            guard let credentials = SecureUserRepository.shared.loadCurrentUser() else {
-                call.reject("No user credentials found")
-                return
-            }
             initializeStreamVideo()
             if state != .initialized {
                 call.reject("Failed to initialize StreamVideo")
@@ -436,16 +638,16 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
                     print("Creating call:")
                     print("- Call ID: \(callId)")
                     print("- Call Type: \(callType)")
-                    print("- User ID: \(userId)")
+                    print("- Users: \(members)")
                     print("- Should Ring: \(shouldRing)")
 
                     // Create the call object
                     let streamCall = streamVideo?.call(callType: callType, callId: callId)
 
-                    // Start the call with the member
-                    print("Creating call with member...")
+                    // Start the call with the members
+                    print("Creating call with members...")
                     try await streamCall?.create(
-                        memberIds: [userId],
+                        memberIds: members,
                         custom: [:],
                         ring: shouldRing
                     )
@@ -480,26 +682,21 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
             try requireInitialized()
 
             Task {
-                do {
-                    if let activeCall = streamVideo?.state.activeCall {
-                        try await activeCall.leave()
-
-                        // Update view state instead of cleaning up
-                        await MainActor.run {
-                            self.overlayViewModel?.updateCall(nil)
-                            self.overlayView?.isHidden = true
-                            self.webView?.isOpaque = true
-                        }
+                if let activeCall = streamVideo?.state.activeCall {
+                    activeCall.leave()
 
-                        call.resolve([
-                            "success": true
-                        ])
-                    } else {
-                        call.reject("No active call to end")
+                    // Update view state instead of cleaning up
+                    await MainActor.run {
+                        self.overlayViewModel?.updateCall(nil)
+                        self.overlayView?.isHidden = true
+                        self.webView?.isOpaque = true
                     }
-                } catch {
-                    log.error("Error ending call: \(String(describing: error))")
-                    call.reject("Failed to end call: \(error.localizedDescription)")
+
+                    call.resolve([
+                        "success": true
+                    ])
+                } else {
+                    call.reject("No active call to end")
                 }
             }
         } catch {
@@ -625,26 +822,10 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
         }
         print("Initializing with saved credentials for user: \(savedCredentials.user.name)")
 
-        // Create a local reference to refreshToken to avoid capturing self
-        let refreshTokenFn = self.refreshToken
-
         self.streamVideo = StreamVideo(
             apiKey: apiKey,
             user: savedCredentials.user,
-            token: UserToken(stringLiteral: savedCredentials.tokenValue),
-            tokenProvider: { result in
-                print("attempt to refresh")
-                DispatchQueue.global().async {
-                    do {
-                        let newToken = try refreshTokenFn()
-                        print("Refresh successful")
-                        result(.success(newToken))
-                    } catch {
-                        print("Refresh fail")
-                        result(.failure(error))
-                    }
-                }
-            }
+            token: UserToken(stringLiteral: savedCredentials.tokenValue)
         )
 
         state = .initialized