doc: Example App v1 (#15)

* Add FakeBackend skeleton

* Add the fake backend rest objects

* Do the upload backend

* Some widgets and colors

* Styles or views

* Some comments

* Add prototype to nav

* Ok

* Minor indentation fixes

* Minor formatting fix

* I have mastered your puny buttons

* Figuring it out

* Ok now we're getting somewhere hypothetically

* one last update

* Don't need an environment object

* Start with the pick flow

* I guess we don't need the width

* And a little tweaking

* Upload CTA can be smarter than this

* now for a view model

* Move over permission request

* Permission Request Success

* No crash probs

* up

* Now to extract a thumbnail

* Thumbnail extraction test

* Ready to add other states

* Error View

* Do Processing View

* now to hook it up

* This thumbnail sucks

* Ok now the thumbnail is in at least

* Try to post an upload

* Working authorization

* Add some more headers for the fake backend

* Add credentials but the data is off

* Fake backend now works

* Still works

* TODO done

* Time to start uploading

* Fix bug in forceRestart

* come back to that

* Progress updates look broken

* Fix the upload POST body

* Cool regression

* Debug

* Fix the thumbnail rendering

* Now what

* Add listener for Uploads Updated

* Auto acknowledge uploads

* not time for nav

* Rearrange the Upload CTA stuff

* Updating more stuff

* now we're navigating

* Figuring it out

* Time to start on the upload list

* Added more listy stuff

* list container

* Now it works

* Empty list

* Hashable

* Notify delegates but something doesn't seem to be working

* Now working it out

* Making it work

* Thumbnail in the list items maybe

* OK I got it

* Figured out thumbnails

* Work on it

* Work

* So far so good

* ugh

* Making progress

* Progress View

* Ok

* Now we're talking

* Ok now we have a status line

* Now we are good

* Appropriately scope the create-upload viewmodel

* Now we are getting to the end

* Save old uploads for a while

* ont an error

* Remove old example UI

* cleanup

* project

* Remove another old UI component

* Yknow this isn't really mvvm to begin with

* Label cleanup

* oh dang forgot the app icon

* oh wow that didn't build

* Add a Mux Asset catalog

* Add Mux assets to a catalog

* CTA vis

* The list needs to actually scroll

* Rename *Screen to *View

* Use task instead of onAppear

* Don't commit those

* Fix permission prompt

* AnyObject

* Brackets

* Update Sources/MuxUploadSDK/Public API/UploadManager.swift

Co-authored-by: AJ Lauer Barinov <[email protected]>

* Generics

---------

Co-authored-by: Liam Lindner <[email protected]>
Co-authored-by: AJ Lauer Barinov <[email protected]>

Author: 3 people

Sources/MuxUploadSDK/Internal Utilities/ChunkedFile.swift

@@ -28,7 +28,7 @@ class ChunkedFile {
 
     /// Reads the next chunk from the file, advancing the file for the next read
     ///  This method does synchronous I/O, so call it in the background
-    public func readNextChunk() -> Result<FileChunk, Error> {
+    func readNextChunk() -> Result<FileChunk, Error> {
         MuxUploadSDK.logger?.info("--readNextChunk(): called")
         do {
             guard fileHandle != nil else {

Sources/MuxUploadSDK/Public API/MuxUpload.swift

@@ -12,8 +12,8 @@ import Foundation
 
  TODO: usage here
  */
-public final class MuxUpload {
-    
+public final class MuxUpload : Hashable, Equatable {
+ 
     private let uploadInfo: UploadInfo
     private let manageBySDK: Bool
     private let id: Int
@@ -26,7 +26,7 @@ public final class MuxUpload {
     /**
      Represents the state of an upload in progress.
      */
-    public struct Status : Sendable {
+    public struct Status : Sendable, Hashable {
         public let progress: Progress?
         public let updatedTime: TimeInterval
         public let startTime: TimeInterval
@@ -53,7 +53,7 @@ public final class MuxUpload {
     public convenience init(
         uploadURL: URL,
         videoFileURL: URL,
-        chunkSize: Int = 8 * 1024 * 1024, // Google recommends *at least* 8M,
+        chunkSize: Int = 8 * 1024 * 1024, // Google recommends at least 8M
         retriesPerChunk: Int = 3,
         optOutOfEventTracking: Bool = false
     ) {
@@ -82,7 +82,7 @@ public final class MuxUpload {
      */
     public var progressHandler: StateHandler?
 
-    public struct Success : Sendable {
+    public struct Success : Sendable, Hashable {
         public let finalState: Status
     }
 
@@ -105,7 +105,12 @@ public final class MuxUpload {
     /**
      True if this upload is currently in progress and not paused
      */
-    var inProgress: Bool { get { fileWorker != nil } }
+    public var inProgress: Bool { get { fileWorker != nil && !complete } }
+    
+    /**
+     True if this upload was completed
+     */
+    public var complete: Bool { get { lastSeenStatus.progress?.completedUnitCount ?? 0 > 0 && lastSeenStatus.progress?.fractionCompleted ?? 0 >= 1.0 } }
 
     /**
     URL to the file that will be uploaded
@@ -126,12 +131,12 @@ public final class MuxUpload {
             // See if there's anything in progress already
             fileWorker = uploadManager.findUploaderFor(videoFile: videoFile)
         }
-        guard !forceRestart && fileWorker == nil else {
+        if fileWorker != nil && !forceRestart {
             MuxUploadSDK.logger?.warning("start() called but upload is in progress")
             return
         }
         if forceRestart {
-            fileWorker?.cancel()
+            cancel()
         }
         let completedUnitCount = UInt64({ self.lastSeenStatus.progress?.completedUnitCount ?? 0 }())
         let fileWorker = ChunkedFileUploader(uploadInfo: uploadInfo, startingAtByte: completedUnitCount)
@@ -140,6 +145,7 @@ public final class MuxUpload {
             InternalUploaderDelegate { [weak self] state in self?.handleStateUpdate(state) }
         )
         fileWorker.start()
+        uploadManager.registerUploader(fileWorker, withId: id)
         self.fileWorker = fileWorker
     }
 
@@ -154,7 +160,7 @@ public final class MuxUpload {
     }
 
     /**
-     Cancels an ongoing download. Temp files will be deleted asynchronously. State and Delegates will be cleared. Your delegates will recieve no further calls
+     Cancels an ongoing download. State and Delegates will be cleared. Your delegates will recieve no further calls
      */
     public func cancel() {
         fileWorker?.cancel()
@@ -207,6 +213,17 @@ public final class MuxUpload {
         }
     }
 
+    public static func == (lhs: MuxUpload, rhs: MuxUpload) -> Bool {
+        lhs.videoFile == rhs.videoFile
+        && lhs.uploadURL == rhs.uploadURL
+    }
+    
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(videoFile)
+        hasher.combine(uploadURL)
+    }
+   
+    
     private init (uploadInfo: UploadInfo, manage: Bool = true, uploadManager: UploadManager) {
         self.uploadInfo = uploadInfo
         self.manageBySDK = manage
@@ -220,7 +237,7 @@ public final class MuxUpload {
 
         handleStateUpdate(uploader.currentState)
         uploader.addDelegate(
-            withToken: id,
+            withToken: self.id,
             InternalUploaderDelegate { [weak self] state in self?.handleStateUpdate(state) }
         )
     }

Sources/MuxUploadSDK/Public API/UploadManager.swift

@@ -22,8 +22,9 @@ import Foundation
 public final class UploadManager {
 
     private var uploadersByURL: [URL : ChunkedFileUploader] = [:]
+    private var uploadsUpdateDelegatesByToken: [ObjectIdentifier : any UploadsUpdatedDelegate] = [:]
     private let uploadActor = UploadCacheActor()
-    private lazy var uploaderDelegate: FileUploaderDelegate = FileUploaderDelegate(onBehalfOf: self)
+    private lazy var uploaderDelegate: FileUploaderDelegate = FileUploaderDelegate(manager: self)
 
     /// Finds an upload already in-progress and returns a new ``MuxUpload`` that can be observed
     /// to track and control its state
@@ -43,19 +44,6 @@ public final class UploadManager {
         return uploadersByURL.compactMap { (key, value) in MuxUpload(wrapping: value, uploadManager: self) }
     }
 
-    /// Call to remove a finished upload from the manger (so it will no longer be returned by other methods in this class).
-    /// If it was in-progress, it will be canceled
-    public func acknowledgeUpload(ofFile url: URL) {
-        if let uploader = uploadersByURL[url] {
-            uploader.cancel()
-        }
-        uploadersByURL.removeValue(forKey: url)
-        Task.detached {
-            await self.uploadActor.remove(uploadAt:url)
-        }
-    }
-    
-    
     /// Attempts to resume an upload that was previously paused or interrupted by process death
     ///  If no upload was found in the cache, this method returns null without taking any action
     public func resumeUpload(ofFile: URL) async -> MuxUpload? {
@@ -89,18 +77,51 @@ public final class UploadManager {
         }
     }
 
+    /// Adds an ``UploadsUpdatedDelegate`` You can add as many of these as you like
+    public func addUploadsUpdatedDelegate<Delegate: UploadsUpdatedDelegate>(_ delegate: Delegate) {
+        uploadsUpdateDelegatesByToken[ObjectIdentifier(delegate)] = delegate
+    }
+    
+    /// Removes an ``UploadsUpdatedDelegate``
+    public func removeUploadsUpdatedDelegate<Delegate: UploadsUpdatedDelegate>(_ delegate: Delegate) {
+        uploadsUpdateDelegatesByToken.removeValue(forKey: ObjectIdentifier(delegate))
+    }
+    
+    internal func acknowledgeUpload(ofFile url: URL) {
+        if let uploader = uploadersByURL[url] {
+            uploader.cancel()
+        }
+        uploadersByURL.removeValue(forKey: url)
+        Task.detached {
+            await self.uploadActor.remove(uploadAt:url)
+            self.notifyDelegates()
+        }
+    }
+    
     internal func findUploaderFor(videoFile url: URL) -> ChunkedFileUploader? {
         return uploadersByURL[url]
     }
 
     internal func registerUploader(_ fileWorker: ChunkedFileUploader, withId id: Int) {
         uploadersByURL.updateValue(fileWorker, forKey: fileWorker.uploadInfo.videoFile)
-        fileWorker.addDelegate(withToken: id, uploaderDelegate)
+        fileWorker.addDelegate(withToken: id + 1, uploaderDelegate)
         Task.detached {
             await self.uploadActor.updateUpload(
                 fileWorker.uploadInfo,
                 withUpdate: fileWorker.currentState
             )
+            self.notifyDelegates()
+        }
+    }
+    
+    private func notifyDelegates() {
+        Task.detached {
+            await MainActor.run {
+                self.uploadsUpdateDelegatesByToken
+                    .map { it in it.value }
+                    .forEach { it in it.uploadListUpdated(with: self.allManagedUploads()) }
+                
+            }
         }
     }
 
@@ -109,21 +130,27 @@ public final class UploadManager {
     private init() { }
 
     private struct FileUploaderDelegate : ChunkedFileUploaderDelegate {
-        let onBehalfOf: UploadManager
+        let manager: UploadManager
 
         func chunkedFileUploader(_ uploader: ChunkedFileUploader, stateUpdated state: ChunkedFileUploader.InternalUploadState) {
+            Task.detached {
+                await manager.uploadActor.updateUpload(uploader.uploadInfo, withUpdate: state)
+                manager.notifyDelegates()
+            }
             switch state {
-            case .canceled: onBehalfOf.acknowledgeUpload(ofFile: uploader.uploadInfo.videoFile)
+            case .success(_), .canceled: manager.acknowledgeUpload(ofFile: uploader.uploadInfo.videoFile)
             default: do { }
             }
-            
-            Task.detached {
-                await onBehalfOf.uploadActor.updateUpload(uploader.uploadInfo, withUpdate: state)
-            }
         }
     }
 }
 
+/// A delegate that handles changes to the list of active uploads
+public protocol UploadsUpdatedDelegate: AnyObject {
+    func uploadListUpdated(with list: [MuxUpload])
+}
+
+
 /// Isolates/synchronizes multithreaded access to the upload cache.
 internal actor UploadCacheActor {
     private let persistence: UploadPersistence

apps/Test App/Test App/Assets.xcassets/AppIcon.appiconset/Contents.json

@@ -1,6 +1,7 @@
 {
   "images" : [
     {
+      "filename" : "Upload-App-Icon.png",
       "idiom" : "universal",
       "platform" : "ios",
       "size" : "1024x1024"

apps/Test App/Test App/Assets.xcassets/AppIcon.appiconset/Upload-App-Icon.png

@@ -9,13 +9,35 @@ import PhotosUI
 import MuxUploadSDK
 
 struct ContentView: View {
+    @EnvironmentObject var uploadListModel: UploadListModel
+    
     var body: some View {
-        UploadScreen()
+        NavigationView {
+            ZStack(alignment: .bottomTrailing) {
+                UploadListScreen()
+                NavigationLink {
+                    CreateUploadView()
+                        .navigationBarHidden(true)
+                } label : {
+                    if !uploadListModel.lastKnownUploads.isEmpty {
+                        ZStack {
+                            Image("Mux-y Add")
+                                .padding()
+                                .background(Green50.clipShape(Circle()))
+                        }
+                        .padding(24.0)
+                    }
+                }
+            }
+        }
+        .preferredColorScheme(.dark)
     }
 }
 
 struct ContentView_Previews: PreviewProvider {
     static var previews: some View {
         ContentView()
+            .environmentObject(UploadCreationModel())
+            .environmentObject(UploadListModel())
     }
 }

apps/Test App/Test App/ContentView.swift

@@ -0,0 +1,101 @@
+//
+//  FakeBackend.swift
+//  Test App
+//
+//  Created by Emily Dixon on 5/8/23.
+//
+
+import Foundation
+
+/// This class "fakes" the server backend necessary to compvare an upload workflow.
+/// In your production use case, a backend server should take care of creating upload URLs
+///
+/// **You should never build Mux server API ceredentials into a real app**. We do it in this example for brevity only
+class FakeBackend {
+    
+    func createDirectUpload() async throws -> URL {
+        let request = try {
+            var req = try URLRequest(url:fullURL(forEndpoint: "uploads"))
+            req.httpBody = try jsonEncoder.encode(CreateUploadPost())
+            req.httpMethod = "POST"
+            req.addValue("application/json", forHTTPHeaderField: "Content-Type")
+            req.addValue("application/json", forHTTPHeaderField: "accept")
+            
+            let basicAuthCredential = "\(MUX_ACCESS_TOKEN_ID):\(MUX_ACCESS_SECRET_KEY)".data(using: .utf8)!.base64EncodedString()
+            req.addValue("Basic \(basicAuthCredential)", forHTTPHeaderField: "Authorization")
+            
+            return req
+        }()
+        
+        let (data, response) = try await urlSession.data(for: request)
+        let httpResponse = response as! HTTPURLResponse
+        if (200...299).contains(httpResponse.statusCode) {
+            let responseData = try jsonDecoder.decode(CreateUploadResponseContainer.self, from: data).data
+            guard let uploadURL = URL(string:responseData.url) else {
+                throw CreateUploadError(message: "invalid upload url")
+            }
+            return uploadURL
+        } else {
+            self.logger.error("Upload POST failed: HTTP \(httpResponse.statusCode):\n\(String(decoding: data, as: UTF8.self))")
+            throw CreateUploadError(message: "Upload POST failed: HTTP \(httpResponse.statusCode):\n\(String(decoding: data, as: UTF8.self))")
+        }
+    }
+    
+    /// Generates a full URL for a given endpoint in the Mux Video public API
+    private func fullURL(forEndpoint: String) throws -> URL {
+        guard let url = URL(string: "https://api.mux.com/video/v1/\(forEndpoint)") else {
+            throw CreateUploadError(message: "bad endpoint")
+        }
+        return url
+    }
+    
+    private let logger = Test_AppApp.logger
+    
+    let urlSession: URLSession
+    let jsonEncoder: JSONEncoder
+    let jsonDecoder: JSONDecoder
+    
+    let MUX_ACCESS_TOKEN_ID = "YOUR ACCESS TOKEN ID HERE"
+    let MUX_ACCESS_SECRET_KEY = "YOUR SECRET KEY HERE"
+    
+    init(urlSession: URLSession) {
+        self.urlSession = urlSession
+        self.jsonEncoder = JSONEncoder()
+        self.jsonEncoder.keyEncodingStrategy = JSONEncoder.KeyEncodingStrategy.convertToSnakeCase
+        self.jsonDecoder = JSONDecoder()
+        self.jsonDecoder.keyDecodingStrategy = JSONDecoder.KeyDecodingStrategy.convertFromSnakeCase
+    }
+    
+    convenience init() {
+        self.init(urlSession: URLSession(configuration: URLSessionConfiguration.default))
+    }
+}
+
+struct CreateUploadError : Error {
+    let message: String
+}
+
+
+fileprivate struct CreateUploadPost: Codable {
+    var newAssetSettings: NewAssetSettings = NewAssetSettings()
+    var corsOrigin: String = "*"
+}
+
+fileprivate struct NewAssetSettings: Codable {
+    var playbackPolicy: [String] = ["public"]
+    var passthrough: String = "Extra video data. This can be any data and it's for your use"
+    var mp4Support: String = "standard"
+    var normalizeAudio: Bool = true
+    var test: Bool = false
+}
+
+fileprivate struct CreateUploadResponse: Decodable {
+    var url: String
+    var id: String
+    var timeout: Int64
+    var status: String
+}
+
+fileprivate struct CreateUploadResponseContainer: Decodable {
+    var data: CreateUploadResponse
+}

apps/Test App/Test App/Fake Server Backend/FakeBackend.swift

@@ -0,0 +1,6 @@
+{
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}