Input Standardization Part 1

Add scaffolding

Add initializers

Add internal and external state mapping

Remove duplicate status enum and add inline docs to external status

Add inline API docs to PHAsset-based MuxUpload constructor

Author: andrewjl-mux

Sources/MuxUploadSDK/InputInspection/UploadInputInspectionWorker.swift

@@ -0,0 +1,14 @@
+//
+//  UploadInputInspectionWorker.swift
+//  
+
+import AVFoundation
+import Foundation
+
+class UploadInputInspectionWorker {
+
+    var sourceInput: AVAsset?
+
+
+
+}

Sources/MuxUploadSDK/InputInspection/UploadInputInspector.swift

@@ -0,0 +1,12 @@
+//
+//  UploadInputInspector.swift
+//
+
+import AVFoundation
+import Foundation
+
+class UploadInputInspector {
+    
+}
+
+

Sources/MuxUploadSDK/InputStandardization/UploadInputStandardizationWorker.swift

@@ -0,0 +1,13 @@
+//
+//  UploadInputStandardizationWorker.swift
+//  
+
+import AVFoundation
+import Foundation
+
+class UploadInputStandardizationWorker {
+
+    var sourceInput: AVAsset?
+
+    var standardizedInput: AVAsset?
+}

Sources/MuxUploadSDK/InputStandardization/UploadInputStandardizer.swift

@@ -0,0 +1,10 @@
+//
+//  UploadInputStandardizer.swift
+//  
+
+import AVFoundation
+import Foundation
+
+class UploadInputStandardizer {
+    
+}

Sources/MuxUploadSDK/InternalUtilities/UploadInput.swift

@@ -0,0 +1,83 @@
+//
+//  UploadInput.swift
+//
+
+import AVFoundation
+import Foundation
+
+// Internal representation of the upload input as it is
+// undergoing non-standard
+struct UploadInput {
+
+    internal enum Status {
+        case ready(AVAsset)
+        case started(AVAsset)
+        case underInspection(AVAsset)
+        case standardizing(AVAsset)
+        case standardizationSucceeded(AVAsset)
+        case standardizationFailed(AVAsset)
+        case awaitingUploadConfirmation(UploadInfo)
+        case uploadInProgress(UploadInfo)
+        case uploadPaused(UploadInfo)
+        case uploadSucceeded(UploadInfo)
+        case uploadFailed(UploadInfo)
+    }
+
+    var status: Status
+
+    var sourceAsset: AVAsset {
+        switch status {
+        case .ready(let sourceAsset):
+            return sourceAsset
+        case .started(let sourceAsset):
+            return sourceAsset
+        case .underInspection(let sourceAsset):
+            return sourceAsset
+        case .standardizing(let sourceAsset):
+            return sourceAsset
+        case .standardizationSucceeded(let sourceAsset):
+            return sourceAsset
+        case .standardizationFailed(let sourceAsset):
+            return sourceAsset
+        case .awaitingUploadConfirmation(let uploadInfo):
+            return uploadInfo.sourceAsset()
+        case .uploadInProgress(let uploadInfo):
+            return uploadInfo.sourceAsset()
+        case .uploadSucceeded(let uploadInfo):
+            return uploadInfo.sourceAsset()
+        case .uploadFailed(let uploadInfo):
+            return uploadInfo.sourceAsset()
+        case .uploadPaused(let uploadInfo):
+            return uploadInfo.sourceAsset()
+        }
+    }
+
+    var uploadInfo: UploadInfo? {
+        switch status {
+        case .ready:
+            return nil
+        case .started:
+            return nil
+        case .underInspection:
+            return nil
+        case .standardizing:
+            return nil
+        case .standardizationSucceeded:
+            return nil
+        case .standardizationFailed:
+            return nil
+        case .awaitingUploadConfirmation(let uploadInfo):
+            return uploadInfo
+        case .uploadInProgress(let uploadInfo):
+            return uploadInfo
+        case .uploadPaused(let uploadInfo):
+            return uploadInfo
+        case .uploadSucceeded(let uploadInfo):
+            return uploadInfo
+        case .uploadFailed(let uploadInfo):
+            return uploadInfo
+        }
+    }
+
+
+}

Sources/MuxUploadSDK/PublicAPI/MuxUpload+AVFoundation.swift

@@ -0,0 +1,29 @@
+//
+//  MuxUpload+AVFoundation.swift
+//
+
+import AVFoundation
+import Foundation
+
+extension MuxUpload {
+
+    public convenience init(
+        uploadURL: URL,
+        inputAsset: AVAsset,
+        transportSettings: TransportSettings = TransportSettings(),
+        optOutOfEventTracking: Bool,
+        standardizationSettings: StandardizationSettings = .enabled(resolution: .preset1920x1080)
+    ) {
+
+        let input = UploadInput(status: .ready(inputAsset))
+
+        self.init(
+            input: input,
+            transportSettings: transportSettings,
+            optOutOfEventTracking: optOutOfEventTracking,
+            standardizationSettings: standardizationSettings,
+            uploadManager: .shared
+        )
+    }
+
+}

Sources/MuxUploadSDK/PublicAPI/MuxUpload+Photos.swift

@@ -0,0 +1,58 @@
+//
+//  MuxUpload+PhotosKit.swift
+//
+
+import Foundation
+import Photos
+
+extension MuxUpload {
+    /// Asynchronously creates a MuxUpload using a ``PHAsset``
+    ///
+    /// - Parameters:
+    ///    - imageManager: Photos image manager
+    ///    - inputAsset: the upload input asset, its
+    ///    ``PHAsset.mediaType`` needs to be ``PHAssetMediaType.video``
+    ///    - uploadURL: the direct upload URL
+    ///    - transportSettings: upload transport settings
+    ///    - optOutOfEventTracking: opts out of SDK event reporting
+    ///    - standardizationSettings: if enabled the SDK checks
+    ///    if the input file is in a standard input format,
+    ///    attempts local conversion if it is non-standard
+    ///    - completion: receives the initialized MuxUpload
+    ///    when it is ready, receives nil if initialization
+    ///    failed
+    public static func makeByExporting(
+        from imageManager: PHImageManager = .default(),
+        using inputAsset: PHAsset,
+        requestOptions: PHVideoRequestOptions,
+        uploadURL: URL,
+        transportsettings: TransportSettings = TransportSettings(),
+        optOutOfEventTracking: Bool,
+        standardizationSettings: StandardizationSettings = .enabled(resolution: .preset1920x1080),
+        completion: @escaping (MuxUpload?) -> ()
+    ) {
+
+        if inputAsset.mediaType != .video {
+            completion(nil)
+            return
+        }
+
+        imageManager
+            .requestAVAsset(
+                forVideo: inputAsset,
+                options: requestOptions
+            ) { asset, audioMix, params in
+                let upload: MuxUpload? = asset.map { unwrappedAsset in
+                    MuxUpload(
+                        uploadURL: uploadURL,
+                        inputAsset: unwrappedAsset,
+                        transportSettings: transportsettings,
+                        optOutOfEventTracking: optOutOfEventTracking,
+                        standardizationSettings: standardizationSettings
+                    )
+                }
+
+                completion(upload)
+            }
+    }
+}

Sources/MuxUploadSDK/PublicAPI/MuxUpload+Transport.swift

@@ -0,0 +1,24 @@
+//
+//  MuxUpload+Transport.swift
+//
+
+import Foundation
+
+extension MuxUpload {
+
+    /// Transport-related settings
+    public struct TransportSettings {
+        /// // Google recommends *at least* 8M
+        public var chunkSize: Int
+        public var retriesPerChunk: Int
+
+        public init(
+            chunkSize: Int = 8 * 1024 * 1024,
+            retriesPerChunk: Int = 3
+        ) {
+            self.chunkSize = chunkSize
+            self.retriesPerChunk = retriesPerChunk
+        }
+    }
+
+}