Add multichannel viewing support

LocalPackages/RTSCore/Sources/RTSCore/Manager/SubscriptionManager.swift

@@ -8,7 +8,7 @@ import MillicastSDK
 import os
 import SwiftUI
 
-public actor SubscriptionManager {
+public actor SubscriptionManager: ObservableObject {
     private static let logger = Logger(
         subsystem: Bundle.module.bundleIdentifier!,
         category: String(describing: SubscriptionManager.self)

rts-viewer-tvos/RTSViewer.xcworkspace/xcshareddata/swiftpm/Package.resolved

@@ -1,14 +1,15 @@
 {
+  "originHash" : "55c5bb51783dcbfad1b8b5bd2888d3846f22b84ddc7759242400a1260ba1846f",
   "pins" : [
     {
       "identity" : "millicast-sdk-swift-package",
       "kind" : "remoteSourceControl",
       "location" : "https://github.com/millicast/millicast-sdk-swift-package",
       "state" : {
-        "revision" : "d20cb45ff24acbc16191d4df6a0e4be9daa26e24",
-        "version" : "2.0.0-beta.7"
+        "revision" : "a36748fd8b8d8fe8d94608f42972e5002d2dd9f5",
+        "version" : "2.0.0"
       }
     }
   ],
-  "version" : 2
+  "version" : 3
 }

rts-viewer-tvos/RTSViewer/Models/Channel.swift

@@ -0,0 +1,158 @@
+//
+//  SourcedChannel.swift
+//
+
+import Combine
+import Foundation
+import os
+import RTSCore
+
+class Channel: ObservableObject, Identifiable, Hashable, Equatable {
+    private static let logger = Logger(
+        subsystem: Bundle.main.bundleIdentifier!,
+        category: String(describing: Channel.self)
+    )
+
+    @Published var currentlyFocusedChannel: Channel? {
+        didSet {
+            guard let currentlyFocusedChannel else { return }
+            isFocusedChannel = currentlyFocusedChannel.id == id
+        }
+    }
+
+    @Published var isFocusedChannel: Bool = false {
+        didSet {
+            if isFocusedChannel {
+                enableSound()
+            } else {
+                disableSound()
+            }
+        }
+    }
+
+    @Published private(set) var streamStatistics: StreamStatistics?
+    @Published var showStatsView: Bool = false
+    @Published var videoQualityList = [VideoQuality]()
+    @Published var selectedVideoQuality: VideoQuality = .auto
+
+    let id: UUID
+    let streamConfig: StreamConfig
+    let subscriptionManager: SubscriptionManager
+    let videoTracksManager: VideoTracksManager
+    let source: StreamSource
+    private var cancellables = [AnyCancellable]()
+    private var layersEventsObserver: Task<Void, Never>?
+
+    init(unsourcedChannel: UnsourcedChannel, source: StreamSource) {
+        self.id = unsourcedChannel.id
+        self.streamConfig = unsourcedChannel.streamConfig
+        self.subscriptionManager = unsourcedChannel.subscriptionManager
+        self.videoTracksManager = unsourcedChannel.videoTracksManager
+        self.source = source
+
+        observeStreamStatistics()
+        observeLayerEvents()
+        startSelectedQualityObserver()
+    }
+
+    func shouldShowStatsView(showStats: Bool) {
+        showStatsView = showStats
+    }
+
+    func enableVideo(with quality: VideoQuality = .auto) {
+        let displayLabel = source.sourceId.displayLabel
+        let viewId = "\(ChannelGridView.self).\(displayLabel)"
+        Task {
+            Self.logger.debug("♼ Channel Grid view: Video view appear for \(self.source.sourceId)")
+            await self.videoTracksManager.enableTrack(for: self.source, with: quality, on: viewId)
+        }
+    }
+
+    func disableVideo() {
+        let displayLabel = source.sourceId.displayLabel
+        let viewId = "\(ChannelGridView.self).\(displayLabel)"
+        Task {
+            Self.logger.debug("♼ Channel Grid view: Video view disappear for \(self.source.sourceId)")
+            await self.videoTracksManager.disableTrack(for: self.source, on: viewId)
+        }
+    }
+
+    func enableSound() {
+        Task {
+            try? await self.source.audioTrack?.enable()
+            Self.logger.debug("♼ Channel \(self.source.sourceId) audio enabled")
+        }
+    }
+
+    func disableSound() {
+        Task {
+            try? await self.source.audioTrack?.disable()
+            Self.logger.debug("♼ Channel \(self.source.sourceId) audio disabled")
+        }
+    }
+
+    func updateFocusedChannel(with channel: Channel) {
+        currentlyFocusedChannel = channel
+    }
+
+    static func == (lhs: Channel, rhs: Channel) -> Bool {
+        return lhs.id == rhs.id
+    }
+
+    func hash(into hasher: inout Hasher) {
+        return hasher.combine(id)
+    }
+}
+
+private extension Channel {
+    func observeStreamStatistics() {
+        Task { [weak self] in
+            guard let self else { return }
+            await subscriptionManager.$streamStatistics
+                .sink { statistics in
+                    guard let statistics else { return }
+                    Task {
+                        self.streamStatistics = statistics
+                    }
+                }
+                .store(in: &cancellables)
+        }
+    }
+
+    func observeLayerEvents() {
+        Task { [weak self] in
+            guard let self,
+                  layersEventsObserver == nil else { return }
+
+            Self.logger.debug("♼ Registering layer events for \(source.sourceId)")
+            let layerEventsObservationTask = Task {
+                for await layerEvent in self.source.videoTrack.layers() {
+                    guard !Task.isCancelled else { return }
+
+                    let videoQualities = layerEvent.layers()
+                        .map(VideoQuality.init)
+                        .reduce([.auto]) { $0 + [$1] }
+                    Self.logger.debug("♼ Received layers \(videoQualities.count)")
+                    self.videoQualityList = videoQualities
+                }
+            }
+
+            layersEventsObserver = layerEventsObservationTask
+
+            _ = await layerEventsObservationTask.value
+        }
+    }
+
+    func startSelectedQualityObserver() {
+        Task { [weak self] in
+            guard let self else { return }
+            await self.videoTracksManager.selectedVideoQualityPublisher
+                .map { $0[self.source.sourceId] ?? .auto }
+                .receive(on: DispatchQueue.main)
+                .sink { quality in
+                    self.selectedVideoQuality = quality
+                }
+                .store(in: &cancellables)
+        }
+    }
+}

rts-viewer-tvos/RTSViewer/Models/StreamConfig.swift

@@ -0,0 +1,11 @@
+//
+//  PlayFromConfigs.swift
+//
+
+import Foundation
+
+struct StreamConfig {
+    let apiUrl: String
+    let streamName: String
+    let accountId: String
+}

rts-viewer-tvos/RTSViewer/Models/UnsourcedChannel.swift

@@ -0,0 +1,21 @@
+//
+//  UnsourcedChannel.swift
+//
+
+import Foundation
+import RTSCore
+
+struct UnsourcedChannel: Identifiable, Hashable, Equatable {
+    let id = UUID()
+    let streamConfig: StreamConfig
+    let subscriptionManager: SubscriptionManager
+    let videoTracksManager: VideoTracksManager
+
+    static func == (lhs: UnsourcedChannel, rhs: UnsourcedChannel) -> Bool {
+        return lhs.id == rhs.id
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        return hasher.combine(id)
+    }
+}

rts-viewer-tvos/RTSViewer/Models/VideoQuality.swift

@@ -5,16 +5,7 @@
 import Foundation
 import MillicastSDK
 
-enum VideoQuality: Identifiable {
-    var id: String {
-        switch self {
-        case .auto:
-            "Auto"
-        case let .quality(videoTrackLayer):
-            videoTrackLayer.encodingId
-        }
-    }
-
+enum VideoQuality: Identifiable, Equatable, Comparable {
     case auto
     case quality(MCRTSRemoteTrackLayer)
 
@@ -24,6 +15,28 @@ enum VideoQuality: Identifiable {
 }
 
 extension VideoQuality {
+    static func < (lhs: VideoQuality, rhs: VideoQuality) -> Bool {
+        return switch (lhs, rhs) {
+        case(.quality, .auto):
+            false
+        case(.auto, .quality):
+            false
+        case let (.quality(lhsQuality), .quality(rhsQuality)):
+            lhsQuality == rhsQuality
+        default:
+            true
+        }
+    }
+
+    var id: String {
+        switch self {
+        case .auto:
+            "Auto"
+        case let .quality(videoTrackLayer):
+            videoTrackLayer.encodingId
+        }
+    }
+
     var displayText: String {
         switch self {
         case .auto:
@@ -57,7 +70,7 @@ extension VideoQuality {
         }
         var target: [String] = []
         if let bitrate = layer.targetBitrate {
-            target.append("Bitrate: \(bitrate.intValue/1000) kbps")
+            target.append("Bitrate: \(bitrate.intValue / 1000) kbps")
         }
         if let resolution = layer.resolution {
             target.append("Resolution: \(resolution.width)x\(resolution.height)")

rts-viewer-tvos/RTSViewer/RTSViewer.swift

@@ -10,11 +10,13 @@ import SwiftUI
  */
 @main
 struct RTSViewer: App {
-
     var body: some Scene {
         WindowGroup {
-            ContentView()
-                .preferredColorScheme(.dark)
+            NavigationView {
+                LandingView()
+            }
+            .navigationViewStyle(StackNavigationViewStyle())
+            .preferredColorScheme(.dark)
         }
     }
 }

rts-viewer-tvos/RTSViewer/Resources/Localizable.strings

@@ -11,6 +11,7 @@
 "stream-detail-input.streamName.placeholder.label" = "Enter your stream name";
 "stream-detail-input.accountId.placeholder.label" = "Enter your account ID";
 "stream-detail-input.play.button" = "Play";
+"stream-detail-input.play-from-config.button" = "Play From Config";
 "stream-detail-input.recent-streams.button" = "Saved Streams";
 "stream-detail-input.clear-stream-history.button" = "Clear stream history";
 "stream-detail-input.rememberStream.toggle" = "Remember stream";
@@ -88,3 +89,5 @@
 "stream.stats.total-stream-time.label" = "Total Stream Time";
 "stream.stats.target-bitrate.label" = "Target Bitrate";
 "stream.stats.outgoing-bitrate.label" = "Outgoing Bitrate";
+
+"video-view.main.label" = "Main";

rts-viewer-tvos/RTSViewer/ReusableViews/SimulcastView/SimulcastView.swift

@@ -16,7 +16,12 @@ struct SimulcastView: View {
     private let onSelectVideoQuality: (VideoQuality) -> Void
     @FocusState private var focusedVideoQuality: FocusableField?
 
-    init(source: StreamSource, videoQualityList: [VideoQuality], selectedVideoQuality: VideoQuality, onSelectVideoQuality: @escaping (VideoQuality) -> Void) {
+    init(
+        source: StreamSource,
+        videoQualityList: [VideoQuality],
+        selectedVideoQuality: VideoQuality,
+        onSelectVideoQuality: @escaping (VideoQuality) -> Void
+    ) {
         viewModel = SimulcastViewModel(source: source, videoQualityList: videoQualityList, selectedVideoQuality: selectedVideoQuality)
         self.onSelectVideoQuality = onSelectVideoQuality
     }
@@ -62,16 +67,16 @@ struct SimulcastView: View {
             onSelectVideoQuality(videoQuality)
         }, label: {
             HStack {
-              VStack(alignment: .leading) {
-                Text(videoQuality.displayText)
-                    .font(theme[.avenirNextDemiBold(size: FontSize.body, style: .body)])
-                if let targetInformation = videoQuality.targetInformation {
-                  Text(targetInformation)
-                    .font(theme[.avenirNextRegular(size: FontSize.caption2, style: .caption2)])
-                    .fixedSize(horizontal: false, vertical: true)
-                    .multilineTextAlignment(.leading)
+                VStack(alignment: .leading) {
+                    Text(videoQuality.displayText)
+                        .font(theme[.avenirNextDemiBold(size: FontSize.body, style: .body)])
+                    if let targetInformation = videoQuality.targetInformation {
+                        Text(targetInformation)
+                            .font(theme[.avenirNextRegular(size: FontSize.caption2, style: .caption2)])
+                            .fixedSize(horizontal: false, vertical: true)
+                            .multilineTextAlignment(.leading)
+                    }
                 }
-              }
 
                 Spacer()
                 if videoQuality.encodingId == viewModel.selectedVideoQuality.encodingId {