Implemented LiveCommunicationKit as an alternative to CallKit

DemoApp/Sources/Components/AudioTrackPlayer/AudioTrackPlayer.swift

@@ -6,7 +6,7 @@ import AVFoundation
 import Foundation
 import StreamVideo
 
-final class AudioTrackPlayer: NSObject, AVAudioPlayerDelegate, @unchecked Sendable {
+final class AudioTrackPlayer: NSObject, @unchecked Sendable {
     enum Track: String, Equatable, CaseIterable {
         case track1 = "track_1"
         case track2 = "track_2"
@@ -60,15 +60,6 @@ final class AudioTrackPlayer: NSObject, AVAudioPlayerDelegate, @unchecked Sendab
             track = nil
         }
     }
-
-    // MARK: - AVAudioPlayerDelegate
-
-    func audioPlayerDidFinishPlaying(
-        _ player: AVAudioPlayer,
-        successfully flag: Bool
-    ) {
-        stop()
-    }
 }
 
 extension AudioTrackPlayer: InjectionKey {

DemoApp/Sources/Components/Debug/Items/FeatureFlags/DebugMenu+FeatureFlagsView.swift

@@ -13,7 +13,7 @@ extension AppEnvironment {
         var viewProvider: () -> AnyView
     }
 
-    nonisolated(unsafe) static var featureFlags: [FeatureFlag] = [
+    @MainActor static var featureFlags: [FeatureFlag] = [
         .init { .init(DebugMenu.VideoProcessingPipelineToggleView()) },
         .init { .init(DebugMenu.CapturingPipelineToggleView()) },
         .init { .init(DebugMenu.VideoRenderingMenuView()) },

Sources/StreamVideo/CallKit/CallKitAdapter.swift

@@ -17,36 +17,36 @@ open class CallKitAdapter {
 
     /// The icon data used as the template for CallKit.
     open var iconTemplateImageData: Data? {
-        get { callKitService.iconTemplateImageData }
-        set { callKitService.iconTemplateImageData = newValue }
+        get { activeSystemCallingService.iconTemplateImageData }
+        set { updateSystemCallingServices { $0.iconTemplateImageData = newValue } }
     }
 
     /// The ringtone sound to use for CallKit ringing calls.
     open var ringtoneSound: String? {
-        get { callKitService.ringtoneSound }
-        set { callKitService.ringtoneSound = newValue }
+        get { activeSystemCallingService.ringtoneSound }
+        set { updateSystemCallingServices { $0.ringtoneSound = newValue } }
     }
 
     /// Configure whether calls should appear in the Recents app.
     open var includesCallsInRecents: Bool {
-        get { callKitService.includesCallsInRecents }
-        set { callKitService.includesCallsInRecents = newValue }
+        get { activeSystemCallingService.includesCallsInRecents }
+        set { updateSystemCallingServices { $0.includesCallsInRecents = newValue } }
     }
 
-    /// The callSettings to use when joining a call (after accepting it on CallKit)
-    /// default: nil
+    /// The callSettings to use when joining a call after accepting it on the
+    /// system calling UI. Default: `nil`.
     open var callSettings: CallSettings? {
-        didSet { callKitService.callSettings = callSettings }
+        didSet { updateSystemCallingServices { $0.callSettings = callSettings } }
     }
 
-    /// The policy that decides if a CallKit-managed call should leave
+    /// The policy that decides if a system-managed call should leave
     /// automatically when participant state changes.
     open var participantAutoLeavePolicy: ParticipantAutoLeavePolicy {
-        get { callKitService.participantAutoLeavePolicy }
-        set { callKitService.participantAutoLeavePolicy = newValue }
+        get { activeSystemCallingService.participantAutoLeavePolicy }
+        set { updateSystemCallingServices { $0.participantAutoLeavePolicy = newValue } }
     }
 
-    /// The policy defining the availability of CallKit services.
+    /// The policy defining the availability of system calling services.
     ///
     /// - Default: `.regionBased`
     public var availabilityPolicy: CallKitAvailabilityPolicy = .regionBased
@@ -64,8 +64,8 @@ open class CallKitAdapter {
     /// join flow, such as waiting for another participant or validating an
     /// external precondition. Throw from the interceptor to fail the join.
     public var callJoinInterceptor: CallJoinIntercepting? {
-        get { callKitService.callJoinInterceptor }
-        set { callKitService.callJoinInterceptor = newValue }
+        get { activeSystemCallingService.callJoinInterceptor }
+        set { updateSystemCallingServices { $0.callJoinInterceptor = newValue } }
     }
 
     /// Initializes the `CallKitAdapter`.
@@ -87,6 +87,47 @@ open class CallKitAdapter {
         callKitPushNotificationAdapter.unregister()
     }
 
+    private var activeSystemCallingService: SystemCallingService {
+        #if canImport(LiveCommunicationKit)
+        if #available(iOS 27.0, *), shouldUseLiveCommunicationKit {
+            return InjectedValues[\.liveCommunicationKitService]
+        }
+        #endif
+        return callKitService
+    }
+
+    private var shouldUseLiveCommunicationKit: Bool {
+        streamVideo?.videoConfig.useLiveCommunicationKit ?? true
+    }
+
+    private func updateSystemCallingServices(
+        _ update: (SystemCallingService) -> Void
+    ) {
+        update(callKitService)
+        #if canImport(LiveCommunicationKit)
+        if #available(iOS 27.0, *) {
+            update(InjectedValues[\.liveCommunicationKitService])
+        }
+        #endif
+    }
+
+    private func updateSystemCallingServices(with streamVideo: StreamVideo?) {
+        guard let streamVideo else {
+            updateSystemCallingServices { $0.streamVideo = nil }
+            return
+        }
+
+        let useLiveCommunicationKit = streamVideo.videoConfig.useLiveCommunicationKit
+        callKitService.streamVideo = useLiveCommunicationKit ? nil : streamVideo
+        #if canImport(LiveCommunicationKit)
+        if #available(iOS 27.0, *) {
+            InjectedValues[\.liveCommunicationKitService].streamVideo = useLiveCommunicationKit
+                ? streamVideo
+                : nil
+        }
+        #endif
+    }
+
     private func didUpdate(_ streamVideo: StreamVideo?) {
         guard availabilityPolicy.policy.isAvailable else {
             log
@@ -96,7 +137,7 @@ open class CallKitAdapter {
             return
         }
 
-        callKitService.streamVideo = streamVideo
+        updateSystemCallingServices(with: streamVideo)
 
         guard streamVideo != nil else {
             unregisterForIncomingCalls()

Sources/StreamVideo/CallKit/CallKitPushNotificationAdapter.swift

@@ -41,6 +41,43 @@ open class CallKitPushNotificationAdapter: NSObject, PKPushRegistryDelegate, Obs
 
     @Injected(\.callKitService) private var callKitService
 
+    private final class SendableCompletion: @unchecked Sendable {
+        private let completion: () -> Void
+
+        init(_ completion: @escaping () -> Void) {
+            self.completion = completion
+        }
+
+        func callAsFunction() {
+            completion()
+        }
+    }
+
+    private var activeSystemCallingService: SystemCallingService {
+        #if canImport(LiveCommunicationKit)
+        if #available(iOS 27.0, *), shouldUseLiveCommunicationKit {
+            return InjectedValues[\.liveCommunicationKitService]
+        }
+        #endif
+        return callKitService
+    }
+
+    private var configuredStreamVideo: StreamVideo? {
+        if let streamVideo = callKitService.streamVideo {
+            return streamVideo
+        }
+        #if canImport(LiveCommunicationKit)
+        if #available(iOS 27.0, *) {
+            return InjectedValues[\.liveCommunicationKitService].streamVideo
+        }
+        #endif
+        return nil
+    }
+
+    private var shouldUseLiveCommunicationKit: Bool {
+        configuredStreamVideo?.videoConfig.useLiveCommunicationKit ?? true
+    }
+
     /// The push registry used for VoIP push notifications.
     open private(set) lazy var registry: PKPushRegistry = .init(queue: .init(label: "io.getstream.voip"))
 
@@ -106,8 +143,11 @@ open class CallKitPushNotificationAdapter: NSObject, PKPushRegistryDelegate, Obs
         for type: PKPushType,
         completion: @escaping () -> Void
     ) {
-        defer { completion() }
-        guard type == .voIP else { return }
+        let pushCompletion = SendableCompletion(completion)
+        guard type == .voIP else {
+            pushCompletion()
+            return
+        }
 
         let content = decodePayload(payload)
 
@@ -116,7 +156,7 @@ open class CallKitPushNotificationAdapter: NSObject, PKPushRegistryDelegate, Obs
                 "Received VoIP push notification with cid:\(content.cid) callerId:\(content.callerId) callerName:\(content.localizedCallerName)."
             )
 
-        callKitService.reportIncomingCall(
+        activeSystemCallingService.reportIncomingCall(
             content.cid,
             localizedCallerName: content.localizedCallerName,
             callerId: content.callerId,
@@ -125,6 +165,7 @@ open class CallKitPushNotificationAdapter: NSObject, PKPushRegistryDelegate, Obs
                 if let error {
                     log.error(error, subsystems: .callKit)
                 }
+                pushCompletion()
             }
         )
     }