@capgo/capacitor-stream-call 0.0.6 → 0.0.19

package/ios/Sources/StreamCallPlugin/StreamCallPlugin.swift

@@ -23,9 +23,10 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
         CAPPluginMethod(name: "setMicrophoneEnabled", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "setCameraEnabled", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "acceptCall", returnType: CAPPluginReturnPromise),
-        CAPPluginMethod(name: "isCameraEnabled", returnType: CAPPluginReturnPromise)
+        CAPPluginMethod(name: "isCameraEnabled", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getCallStatus", returnType: CAPPluginReturnPromise)
     ]
-    
+
     private enum State {
         case notInitialized
         case initializing
@@ -37,7 +38,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?
@@ -45,19 +46,47 @@ 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?
-    
+
+    // Store current call info for getCallStatus
+    private var currentCallId: String = ""
+    private var currentCallState: String = ""
+
     @Injected(\.callKitAdapter) var callKitAdapter
     @Injected(\.callKitPushNotificationAdapter) var callKitPushNotificationAdapter
     private var webviewDelegate: WebviewNavigationDelegate?
-    
+
     // Add class property to store call states
     private var callStates: [String: (members: [MemberResponse], participantResponses: [String: String], createdAt: Date, timer: Timer?)] = [:]
-    
+
+    // 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
+        currentCallId = callId
+        currentCallState = state
+
+        // Create data dictionary with only the fields in the CallEvent interface
+        var data: [String: Any] = [
+            "callId": callId,
+            "state": state
+        ]
+
+        if let userId = userId {
+            data["userId"] = userId
+        }
+
+        if let reason = reason {
+            data["reason"] = reason
+        }
+
+        // Notify listeners
+        notifyListeners("callEvent", data: data)
+    }
+
     override public func load() {
         // Read API key from Info.plist
         if let apiKey = Bundle.main.object(forInfoDictionaryKey: "CAPACITOR_STREAM_VIDEO_APIKEY") as? String {
@@ -66,7 +95,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)")
@@ -74,21 +103,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()
@@ -114,7 +143,7 @@ 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"])
@@ -125,17 +154,17 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
             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 }
@@ -161,26 +190,23 @@ 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 {
-                        notifyListeners("callEvent", data: [
-                            "callId": ringingEvent.callCid,
-                            "state": "ringing"
-                        ])
+                        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
@@ -190,20 +216,22 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
                                 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
@@ -212,22 +240,18 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
                                 self.callStates[callCid] = callState
                             }
                         }
-                        
+
                         print("CallRejectedEvent \(userId)")
-                        notifyListeners("callEvent", data: [
-                            "callId": callCid,
-                            "state": "rejected",
-                            "userId": userId
-                        ])
-                        
+                        updateCallStatusAndNotify(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
@@ -236,73 +260,74 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
                                 self.callStates[callCid] = callState
                             }
                         }
-                        
+
                         print("CallMissedEvent \(userId)")
-                        notifyListeners("callEvent", data: [
-                            "callId": callCid,
-                            "state": "missed",
-                            "userId": userId
-                        ])
-                        
+                        updateCallStatusAndNotify(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) {
+                        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)")
-                            
+                        guard let participantsCount = await MainActor.run(body: {
+                            if call.id == streamVideo.state.activeCall?.id {
+                                return (call.state.session?.participants.count) ?? streamVideo.state.activeCall?.state.participants.count
+                            } else {
+                                return (call.state.session?.participants.count)
+                            }
+                        }) else {
+                            print("CallSessionParticipantLeftEvent no participantsCount")
+                            continue
+                        }
+
+                        if participantsCount - 1 <= 1 {
+
+                            print("We are left solo in a call. Ending. cID: \(participantLeftEvent.callCid). participantsCount: \(participantsCount)")
+
                             Task {
                                 if let activeCall = streamVideo.state.activeCall {
                                     activeCall.leave()
+                                } else {
+                                    print("Active call isn't the one?")
                                 }
                             }
                         }
                     }
-                    
+
                     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
-                        ])
+                        updateCallStatusAndNotify(callId: callCid, state: "accepted", userId: userId)
                         continue
                     }
-                    
-                    notifyListeners("callEvent", data: [
-                        "callId": streamVideo.state.activeCall?.callId ?? "",
-                        "state": event.type
-                    ])
+
+                    updateCallStatusAndNotify(callId: streamVideo.state.activeCall?.callId ?? "", state: event.type)
                 }
             }
         }
@@ -311,60 +336,54 @@ 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"
-                        ])
+                        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.notifyListeners("callEvent", data: [
-                            "callId": endingCallId ?? "",
-                            "state": "left"
-                        ])
-                        
+                        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
                     }
@@ -374,45 +393,45 @@ 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 {
@@ -422,23 +441,19 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
                                 self.callStates[callCid] = updatedCallState
                             }
                         }
-                        
+
                         // Notify listeners
                         await MainActor.run {
-                            self.notifyListeners("callEvent", data: [
-                                "callId": callCid,
-                                "state": "missed",
-                                "userId": memberId
-                            ])
+                            self.updateCallStatusAndNotify(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()
@@ -447,74 +462,66 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
                     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"
-                    ])
+                    self.updateCallStatusAndNotify(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 && 
+        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
+
+            // 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"
-                ])
+                self.updateCallStatusAndNotify(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"),
@@ -522,7 +529,7 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
             call.reject("Missing required parameters")
             return
         }
-        
+
         let imageURL = call.getString("imageURL")
         let user = User(
             id: userId,
@@ -530,31 +537,31 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
             imageURL: imageURL.flatMap { URL(string: $0) },
             customData: [:]
         )
-        
+
         let credentials = UserCredentials(user: user, tokenValue: token)
         SecureUserRepository.shared.save(user: credentials)
         // 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 {
@@ -565,16 +572,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)
@@ -582,19 +589,19 @@ 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
@@ -629,6 +636,7 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
 
             let callType = call.getString("type") ?? "default"
             let shouldRing = call.getBool("ring") ?? true
+            let team = call.getString("team")
 
             // Generate a unique call ID
             let callId = UUID().uuidString
@@ -640,6 +648,7 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
                     print("- Call Type: \(callType)")
                     print("- Users: \(members)")
                     print("- Should Ring: \(shouldRing)")
+                    print("- Team: \(team)")
 
                     // Create the call object
                     let streamCall = streamVideo?.call(callType: callType, callId: callId)
@@ -649,7 +658,7 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
                     try await streamCall?.create(
                         memberIds: members,
                         custom: [:],
-                        ring: shouldRing
+                        team: team, ring: shouldRing
                     )
 
                     // Join the call
@@ -788,6 +797,7 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
                     print("Accepting and joining call \(streamCall!.cId)...")
                     try await streamCall?.accept()
                     try await streamCall?.join(create: false)
+                    try await streamCall?.get()
                     print("Successfully joined call")
 
                     // Update the CallOverlayView with the active call
@@ -900,4 +910,17 @@ public class StreamCallPlugin: CAPPlugin, CAPBridgedPlugin {
             ])
         }
     }
+
+    @objc func getCallStatus(_ call: CAPPluginCall) {
+        // Use stored state rather than accessing SDK state directly
+        if currentCallId.isEmpty || currentCallState == "left" {
+            call.reject("Not in a call")
+            return
+        }
+
+        call.resolve([
+            "callId": currentCallId,
+            "state": currentCallState
+        ])
+    }
 }