Initial commit (#1)

Author: CasperMok

.gitignore

@@ -0,0 +1,83 @@
+# Xcode
+#
+# gitignore contributors: remember to update Global/Xcode.gitignore, Objective-C.gitignore & Swift.gitignore
+
+## User settings
+xcuserdata/
+
+## compatibility with Xcode 8 and earlier (ignoring not required starting Xcode 9)
+*.xcscmblueprint
+*.xccheckout
+
+## compatibility with Xcode 3 and earlier (ignoring not required starting Xcode 4)
+build/
+DerivedData/
+*.moved-aside
+*.pbxuser
+!default.pbxuser
+*.mode1v3
+!default.mode1v3
+*.mode2v3
+!default.mode2v3
+*.perspectivev3
+!default.perspectivev3
+
+## Obj-C/Swift specific
+*.hmap
+
+## App packaging
+*.ipa
+*.dSYM.zip
+*.dSYM
+
+## Playgrounds
+timeline.xctimeline
+playground.xcworkspace
+
+# Swift Package Manager
+#
+# Add this line if you want to avoid checking in source code from Swift Package Manager dependencies.
+# Packages/
+# Package.pins
+# Package.resolved
+# *.xcodeproj
+#
+# Xcode automatically generates this directory with a .xcworkspacedata file and xcuserdata
+# hence it is not needed unless you have added a package configuration file to your project
+.swiftpm
+
+.build/
+
+# CocoaPods
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# Pods/
+#
+# Add this line if you want to avoid checking in source code from the Xcode workspace
+# *.xcworkspace
+
+# Carthage
+#
+# Add this line if you want to avoid checking in source code from Carthage dependencies.
+# Carthage/Checkouts
+
+Carthage/Build/
+
+# Accio dependency management
+Dependencies/
+.accio/
+
+# fastlane
+#
+# It is recommended to not store the screenshots in the git repo.
+# Instead, use fastlane to re-generate the screenshots whenever they are needed.
+# For more information about the recommended setup visit:
+# https://docs.fastlane.tools/best-practices/source-control/#source-control
+
+fastlane/report.xml
+fastlane/Preview.html
+fastlane/screenshots/**/*.png
+fastlane/test_output

Package.resolved

@@ -0,0 +1,59 @@
+// swift-tools-version: 5.7
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+    name: "DolbyIORTSUIKit",
+    defaultLocalization: "en",
+    platforms: [.iOS(.v15)],
+    products: [
+        .library(
+            name: "DolbyIOUIKit",
+            targets: ["DolbyIOUIKit"]),
+        .library(
+            name: "DolbyIORTSCore",
+            targets: ["DolbyIORTSCore"]),
+        .library(
+            name: "DolbyIORTSUIKit",
+            targets: ["DolbyIORTSUIKit"])
+    ],
+    dependencies: [
+        .package(url: "https://github.com/millicast/millicast-sdk-swift-package", from: "1.5.0")
+    ],
+    targets: [
+        // Targets are the basic building blocks of a package. A target can define a module or a test suite.
+        // Targets can depend on other targets in this package, and on products in packages this package depends on.
+        .target(
+            name: "DolbyIOUIKit",
+            dependencies: [],
+            path: "Sources/DolbyIOUIKit",
+            resources: [.process("Resources")]
+            ),
+        .target(
+            name: "DolbyIORTSCore",
+            dependencies: [
+                .product(name: "MillicastSDK", package: "millicast-sdk-swift-package")
+            ],
+            path: "Sources/DolbyIORTSCore"
+        ),
+        .target(
+            name: "DolbyIORTSUIKit",
+            dependencies: [
+                "DolbyIOUIKit",
+                "DolbyIORTSCore"
+            ],
+            path: "Sources/DolbyIORTSUIKit",
+            resources: [.process("Resources")]
+        ),
+        .testTarget(
+            name: "DolbyIOUIKitTests",
+            dependencies: ["DolbyIOUIKit"]),
+        .testTarget(
+            name: "DolbyIORTSCoreTests",
+            dependencies: ["DolbyIORTSCore"]),
+        .testTarget(
+            name: "DolbyIORTSUIKitTests",
+            dependencies: ["DolbyIORTSUIKit", "DolbyIORTSCore"])
+    ]
+)

Package.swift

@@ -0,0 +1,147 @@
+//
+//  StreamSourceBuilder.swift
+//
+
+import Foundation
+import MillicastSDK
+
+final class StreamSourceBuilder {
+
+    enum BuildError: Error {
+        case missingVideoTrack
+        case missingAudioTrack
+    }
+
+    struct TrackItem {
+        let trackType: StreamSource.TrackType
+        let mediaType: StreamSource.MediaType
+
+        /// Initialises the Track Item, if possible from the passed-in String
+        /// - Parameter track: A string value passed in by the SDK and is expected to be of format `{mediaType}/{trackType}`
+        init?(track: String) {
+            let trackInfoList = track.split(separator: "/")
+
+            guard
+                trackInfoList.count == 2,
+                let mediaType = StreamSource.MediaType(rawValue: String(trackInfoList[0])),
+                let trackType = StreamSource.TrackType(rawValue: String(trackInfoList[1]))
+            else {
+                return nil
+            }
+            self.mediaType = mediaType
+            self.trackType = trackType
+        }
+    }
+
+    let identifier: UUID
+    private(set) var streamId: String
+    private(set) var sourceId: StreamSource.SourceId
+    private(set) var supportedTrackItems: [TrackItem]
+    private(set) var videoTrack: StreamSource.VideoTrackInfo?
+    private(set) var audioTracks: [StreamSource.AudioTrackInfo] = []
+    private(set) var availableVideoQualityList: [StreamSource.VideoQuality] = [.auto]
+    private(set) var preferredVideoQuality: StreamSource.VideoQuality = .auto
+    private(set) var isPlayingAudio = false
+    private(set) var isPlayingVideo = false
+
+    init(streamId: String, sourceId: String?, tracks: [String]) {
+        identifier = UUID()
+        self.streamId = streamId
+        self.sourceId = StreamSource.SourceId(id: sourceId)
+
+        supportedTrackItems = tracks
+            .compactMap { TrackItem(track: $0) }
+    }
+
+    func addAudioTrack(_ track: MCAudioTrack, mid: String) {
+        let trackItems = supportedTrackItems.filter({ $0.mediaType == .audio })
+        guard
+            !trackItems.isEmpty,
+            audioTracks.count < trackItems.count
+        else {
+            return
+        }
+        let trackItem = trackItems[0]
+        audioTracks.append(
+            StreamSource.AudioTrackInfo(
+                mid: mid,
+                trackType: trackItem.trackType,
+                mediaType: trackItem.mediaType,
+                track: track)
+        )
+    }
+
+    func addVideoTrack(_ track: MCVideoTrack, mid: String) {
+        guard let trackItem = supportedTrackItems.first(where: { $0.mediaType == .video }) else {
+            return
+        }
+
+        videoTrack = StreamSource.VideoTrackInfo(
+            mid: mid,
+            trackType: trackItem.trackType,
+            mediaType: trackItem.mediaType,
+            track: track
+        )
+    }
+
+    func updatePreferredVideoQuality(_ videoQuality: StreamSource.VideoQuality) {
+        guard availableVideoQualityList.contains(where: { $0 == videoQuality }) else {
+            preferredVideoQuality = .auto
+            return
+        }
+
+        preferredVideoQuality = videoQuality
+    }
+
+    func setAvailableVideoQualityList(_ list: [StreamSource.VideoQuality]) {
+        availableVideoQualityList = list
+    }
+
+    func setPlayingAudio(_ enable: Bool) {
+        isPlayingAudio = enable
+    }
+
+    func setPlayingVideo(_ enable: Bool) {
+        isPlayingVideo = enable
+    }
+
+    func build() throws -> StreamSource {
+        guard !hasMissingAudioTrack else {
+            throw BuildError.missingAudioTrack
+        }
+
+        guard !hasMissingVideoTrack else {
+            throw BuildError.missingVideoTrack
+        }
+
+        return StreamSource(
+            id: identifier,
+            streamId: streamId,
+            sourceId: sourceId,
+            availableVideoQualityList: availableVideoQualityList,
+            preferredVideoQuality: preferredVideoQuality,
+            isPlayingAudio: isPlayingAudio,
+            isPlayingVideo: isPlayingVideo,
+            audioTracks: audioTracks,
+            videoTrack: videoTrack
+        )
+    }
+}
+
+// MARK: Helper functions
+// Note: Currently the Millicast SDK callbacks do not give us a way to associate the track we receive in onAudioTrack(..) and onVideoTrack(..) callbacks to a particular SourceId
+// The current implementation worked around it be checking for the missing `audio or video tracks` by comparing it with the `supportedTrackItems` - this SDK limitation leads
+// us in making assumptions that the mediaType will either be "audio" or "video".
+// TODO: Refactor this implementation when the SDK Callback API's are refined.
+
+extension StreamSourceBuilder {
+    var hasMissingAudioTrack: Bool {
+        let audioTrackItems = supportedTrackItems.filter { $0.mediaType == .audio }
+        return audioTracks.count < audioTrackItems.count
+    }
+
+    var hasMissingVideoTrack: Bool {
+        let hasVideoTrack = supportedTrackItems.contains { $0.mediaType == .video }
+        return hasVideoTrack && videoTrack == nil
+    }
+}

Sources/DolbyIORTSCore/Builder/StreamSourceBuilder.swift

@@ -0,0 +1,62 @@
+//
+//  RendererRegistry.swift
+//
+
+import Foundation
+import MillicastSDK
+import os
+
+protocol RendererRegistryProtocol: AnyObject {
+    func registerRenderer(_ renderer: StreamSourceViewRenderer, for track: MCVideoTrack) async
+    func deregisterRenderer(_ renderer: StreamSourceViewRenderer, for track: MCVideoTrack) async
+
+    func hasActiveRenderer(for track: MCVideoTrack) async -> Bool
+
+    func reset() async
+}
+
+final actor RendererRegistry: RendererRegistryProtocol {
+    private var rendererDictionary: [String: NSHashTable<StreamSourceViewRenderer>] = [:]
+
+    func registerRenderer(_ renderer: StreamSourceViewRenderer, for track: MCVideoTrack) {
+        guard let trackID = track.getId() else {
+            fatalError("Expect to have dictionary entry for the track before querying for renderer")
+        }
+
+        if let renderers = rendererDictionary[trackID] {
+            guard !renderers.contains(renderer) else {
+                return
+            }
+            renderers.add(renderer)
+        } else {
+            let renderers = NSHashTable<StreamSourceViewRenderer>(options: .weakMemory)
+            renderers.add(renderer)
+            rendererDictionary[trackID] = renderers
+        }
+    }
+
+    func deregisterRenderer(_ renderer: StreamSourceViewRenderer, for track: MCVideoTrack) {
+        guard let trackID = track.getId() else {
+            fatalError("Expect to have dictionary entry for the track before querying for renderer")
+        }
+
+        if let renderers = rendererDictionary[trackID] {
+            renderers.remove(renderer)
+        }
+    }
+
+    func hasActiveRenderer(for track: MCVideoTrack) -> Bool {
+        guard
+            let trackID = track.getId(),
+            let renderers = rendererDictionary[trackID]
+        else {
+            return false
+        }
+
+        return renderers.count != 0
+    }
+
+    func reset() {
+        rendererDictionary.removeAll()
+    }
+}