How to upload multiple image on firebase using swift?

Question

I just want to upload multiple image on firebase using swift. I am now uploading one image but unable to upload multiple image. Here is my code

let photoIdString = NSUUID().uuidString
let storageRef = Storage.storage().reference(forURL: Config.STORAGE_ROOF_REF).child("posts").child(photoIdString)
storageRef.putData(imageData, metadata: nil,completion: {(metadata,error) in

       if error != nil {
            return
       }
       let photoUrl = metadata?.downloadURL()?.absoluteString
       let ref = Database.database().reference()
       let postReference = ref.child("posts")
       let newPostId = postReference.childByAutoId().key
       let newPostReference = postReference.child(newPostId)
       newPostReference.setValue(["photoUrl":photoUrl,"caption":self.textView.text!]) 

Answer 1

With the new concurrency API and the updated Firebase API this got a lot simpler.

func someUpload(someImagesData: [Data]) async throws -> [String]  {
        // your path
        let storageRef = storageRoot.child("somePath")
        
        return try await withThrowingTaskGroup(of: String.self) { group in
            
            // the urlStrings you are eventually returning
            var urlStrings = [String]()
            
            // just using index for testing purposes so each image doesnt rewrites itself
            // of course you can also use a hash or a custom id instead of the index
            
            // looping over each image data and the index
            for (index, data) in someImagesData.enumerated() {
                
                // adding the method of storing our image and retriving the urlString to the task group
                group.addTask(priority: .background) {
                    let _ = try await storageRef.child("\(index)").putDataAsync(data)
                    return try await storageRef.child("\(index)").downloadURL().absoluteString
                }
            }
            
            for try await uploadedPhotoString in group {
                // for each task in the group, add the newly uploaded urlSting to our array...
                urlStrings.append(uploadedPhotoString)
            }
            // ... and lastly returning it
            return urlStrings
        }
    }

Answer 2

Currently there is no direct API to uploading/downloading the files in batch. We can not use loop because all the tasks perform asynchronously. What we can do is to use a recursive function.

Core Logic

let images = [image1, image2, image3, image4]
func uploadImage(forIndex index: Int) {
    if index < images.count {
        /// Perform uploading
        /// After successfully uploading call this method again by increment the **index = index + 1**
        return;
    }

    /// All images have been uploaded successfully
}

Full Code Example

1. I created a custom class for file uploading

import UIKit
import Firebase

class FirFile: NSObject {

    /// Singleton instance
    static let shared: FirFile = FirFile()

    /// Path
    let kFirFileStorageRef = Storage.storage().reference().child("Files")

    /// Current uploading task
    var currentUploadTask: StorageUploadTask?

    func upload(data: Data,
                withName fileName: String,
                block: @escaping (_ url: String?) -> Void) {

        // Create a reference to the file you want to upload
        let fileRef = kFirFileStorageRef.child(fileName)

        /// Start uploading
        upload(data: data, withName: fileName, atPath: fileRef) { (url) in
            block(url)
        }
    }

    func upload(data: Data,
                withName fileName: String,
                atPath path:StorageReference,
                block: @escaping (_ url: String?) -> Void) {

        // Upload the file to the path
        self.currentUploadTask = path.putData(data, metadata: nil) { (metaData, error) in
            let url = metaData?.downloadURL()?.absoluteString
            block(url)
        }
    }

    func cancel() {
        self.currentUploadTask?.cancel()
    }
}

2. Here how can we use this

First of all create a completion block for main function which will let you know when all images will be uploaded successfully.

/// This is your images array
let images = [image1, image2, image3, image4]

/// Here is the completion block
typealias FileCompletionBlock = () -> Void
var block: FileCompletionBlock?

Below are two functions first one is the initial one which will start the uploading and the second one is a recursion which will call itself if there is next image available to upload.

func startUploading(completion: @escaping FileCompletionBlock) {
     if images.count == 0 {
        completion()
        return;
     }

     block = completion
     uploadImage(forIndex: 0)
}

func uploadImage(forIndex index:Int) {

     if index < images.count {
          /// Perform uploading
          let data = UIImagePNGRepresentation(images[index])!
          let fileName = String(format: "%@.png", "yourUniqueFileName")

          FirFile.shared.upload(data: data, withName: fileName, block: { (url) in
              /// After successfully uploading call this method again by increment the **index = index + 1**
              print(url ?? "Couldn't not upload. You can either check the error or just skip this.")
              self.uploadImage(forIndex: index + 1)
           })
        return;
      }

      if block != nil {
         block!()
      }
}

And finally here is the main function with completion block

startUploading {
    /// All the images have been uploaded successfully.
}

EDIT "upload" function for new Firebase:

The only difference is the way of getting downloading url. Here is the new Firebase doc on same.

func upload(data: Data,
            withName fileName: String,
            atPath path:StorageReference,
            block: @escaping (_ url: String?) -> Void) {

    // Upload the file to the path
    self.currentUploadTask = path.putData(data, metadata: nil) { (metaData, error) in
         guard let metadata = metadata else {
              // Uh-oh, an error occurred!
              block(nil)
              return
         }
         // Metadata contains file metadata such as size, content-type.
         // let size = metadata.size
         // You can also access to download URL after upload.
         path.downloadURL { (url, error) in
              guard let downloadURL = url else {
                 // Uh-oh, an error occurred!
                 block(nil)
                 return
              }
             block(url)
         }
    }
}