Progress closure for async/await APIs (#11289)

Author: paulb777

FirebaseStorage/CHANGELOG.md

@@ -1,3 +1,7 @@
+# Unreleased
+- [added] Add progress tracking capability for `putDataAsync`, `putFileAsync`, and
+  `writeAsync`. (#10574)
+
 # 10.10.0
 - [fixed] Fixed potential memory leak of Storage instances. (#11248)
 

FirebaseStorage/Sources/AsyncAwait.swift

@@ -44,14 +44,32 @@ import Foundation
     ///   - uploadData: The Data to upload.
     ///   - metadata: Optional StorageMetadata containing additional information (MIME type, etc.)
     ///              about the object being uploaded.
+    ///   - onProgress: An optional closure function to return a `Progress` instance while the upload proceeds.
     /// - Throws:
     ///   - An error if the operation failed, for example if Storage was unreachable.
     /// - Returns: StorageMetadata with additional information about the object being uploaded.
     func putDataAsync(_ uploadData: Data,
-                      metadata: StorageMetadata? = nil) async throws -> StorageMetadata {
+                      metadata: StorageMetadata? = nil,
+                      onProgress: ((Progress?) -> Void)? = nil) async throws -> StorageMetadata {
+      guard let onProgress else {
+        return try await withCheckedThrowingContinuation { continuation in
+          self.putData(uploadData, metadata: metadata) { result in
+            continuation.resume(with: result)
+          }
+        }
+      }
+      let uploadTask = putData(uploadData, metadata: metadata)
       return try await withCheckedThrowingContinuation { continuation in
-        _ = self.putData(uploadData, metadata: metadata) { result in
-          continuation.resume(with: result)
+        uploadTask.observe(.progress) {
+          onProgress($0.progress)
+        }
+        uploadTask.observe(.success) { _ in
+          continuation.resume(with: .success(uploadTask.metadata!))
+        }
+        uploadTask.observe(.failure) { snapshot in
+          continuation.resume(with: .failure(
+            snapshot.error ?? StorageError.internalError("Internal Storage Error in putDataAsync")
+          ))
         }
       }
     }
@@ -63,14 +81,32 @@ import Foundation
     ///   - url: A URL representing the system file path of the object to be uploaded.
     ///   - metadata: Optional StorageMetadata containing additional information (MIME type, etc.)
     ///              about the object being uploaded.
+    ///   - onProgress: An optional closure function to return a `Progress` instance while the upload proceeds.
     /// - Throws:
     ///   - An error if the operation failed, for example if no file was present at the specified `url`.
     /// - Returns: `StorageMetadata` with additional information about the object being uploaded.
     func putFileAsync(from url: URL,
-                      metadata: StorageMetadata? = nil) async throws -> StorageMetadata {
+                      metadata: StorageMetadata? = nil,
+                      onProgress: ((Progress?) -> Void)? = nil) async throws -> StorageMetadata {
+      guard let onProgress else {
+        return try await withCheckedThrowingContinuation { continuation in
+          self.putFile(from: url, metadata: metadata) { result in
+            continuation.resume(with: result)
+          }
+        }
+      }
+      let uploadTask = putFile(from: url, metadata: metadata)
       return try await withCheckedThrowingContinuation { continuation in
-        _ = self.putFile(from: url, metadata: metadata) { result in
-          continuation.resume(with: result)
+        uploadTask.observe(.progress) {
+          onProgress($0.progress)
+        }
+        uploadTask.observe(.success) { _ in
+          continuation.resume(with: .success(uploadTask.metadata!))
+        }
+        uploadTask.observe(.failure) { snapshot in
+          continuation.resume(with: .failure(
+            snapshot.error ?? StorageError.internalError("Internal Storage Error in putFileAsync")
+          ))
         }
       }
     }
@@ -79,14 +115,32 @@ import Foundation
     ///
     /// - Parameters:
     ///   - fileUrl: A URL representing the system file path of the object to be uploaded.
+    ///   - onProgress: An optional closure function to return a `Progress` instance while the download proceeds.
     /// - Throws:
     ///   - An error if the operation failed, for example if Storage was unreachable
     ///   or `fileURL` did not reference a valid path on disk.
     /// - Returns: A `URL` pointing to the file path of the downloaded file.
-    func writeAsync(toFile fileURL: URL) async throws -> URL {
+    func writeAsync(toFile fileURL: URL,
+                    onProgress: ((Progress?) -> Void)? = nil) async throws -> URL {
+      guard let onProgress else {
+        return try await withCheckedThrowingContinuation { continuation in
+          _ = self.write(toFile: fileURL) { result in
+            continuation.resume(with: result)
+          }
+        }
+      }
+      let downloadTask = write(toFile: fileURL)
       return try await withCheckedThrowingContinuation { continuation in
-        _ = self.write(toFile: fileURL) { result in
-          continuation.resume(with: result)
+        downloadTask.observe(.progress) {
+          onProgress($0.progress)
+        }
+        downloadTask.observe(.success) { _ in
+          continuation.resume(with: .success(fileURL))
+        }
+        downloadTask.observe(.failure) { snapshot in
+          continuation.resume(with: .failure(
+            snapshot.error ?? StorageError.internalError("Internal Storage Error in writeAsync")
+          ))
         }
       }
     }

FirebaseStorage/Tests/Integration/StorageAsyncAwait.swift

@@ -178,6 +178,25 @@ import XCTest
       XCTAssertNotNil(result)
     }
 
+    func testSimplePutFileWithAsyncProgress() async throws {
+      var checkedProgress = false
+      let ref = storage.reference(withPath: "ios/public/testSimplePutFile")
+      let data = try XCTUnwrap("Hello Swift World".data(using: .utf8), "Data construction failed")
+      let tmpDirURL = URL(fileURLWithPath: NSTemporaryDirectory())
+      let fileURL = tmpDirURL.appendingPathComponent("hello.txt")
+      try data.write(to: fileURL, options: .atomicWrite)
+      var uploadedBytes: Int64 = -1
+      let successMetadata = try await ref.putFileAsync(from: fileURL) { progress in
+        if let completed = progress?.completedUnitCount {
+          checkedProgress = true
+          XCTAssertGreaterThanOrEqual(completed, uploadedBytes)
+          uploadedBytes = completed
+        }
+      }
+      XCTAssertEqual(successMetadata.size, 17)
+      XCTAssertTrue(checkedProgress)
+    }
+
     func testSimpleGetData() async throws {
       let ref = storage.reference(withPath: "ios/public/1mb2")
       let result = try await ref.data(maxSize: 1024 * 1024)
@@ -267,11 +286,10 @@ import XCTest
 
         task.observe(StorageTaskStatus.progress) { snapshot in
           XCTAssertNil(snapshot.error, "Error should be nil")
-          guard let progress = snapshot.progress else {
+          guard snapshot.progress != nil else {
             XCTFail("Missing progress")
             return
           }
-          print("\(progress.completedUnitCount) of \(progress.totalUnitCount)")
         }
         task.observe(StorageTaskStatus.failure) { snapshot in
           XCTAssertNil(snapshot.error, "Error should be nil")
@@ -280,6 +298,28 @@ import XCTest
       waitForExpectations()
     }
 
+    func testSimpleGetFileWithAsyncProgressCallbackAPI() async throws {
+      var checkedProgress = false
+      let ref = storage.reference().child("ios/public/1mb")
+      let url = URL(fileURLWithPath: "\(NSTemporaryDirectory())/hello.txt")
+      let fileURL = url
+      var downloadedBytes: Int64 = 0
+      var resumeAtBytes = 256 * 1024
+      let successURL = try await ref.writeAsync(toFile: fileURL) { progress in
+        if let completed = progress?.completedUnitCount {
+          checkedProgress = true
+          XCTAssertGreaterThanOrEqual(completed, downloadedBytes)
+          downloadedBytes = completed
+          if completed > resumeAtBytes {
+            resumeAtBytes = Int.max
+          }
+        }
+      }
+      XCTAssertTrue(checkedProgress)
+      XCTAssertEqual(successURL, url)
+      XCTAssertEqual(resumeAtBytes, Int.max)
+    }
+
     private func assertMetadata(actualMetadata: StorageMetadata,
                                 expectedContentType: String,
                                 expectedCustomMetadata: [String: String]) {