While loop doesn't seem to work with .putFile when uploading multiple images to Firebase storage in Kotlin

Question

I have been trying to upload multiple images to Firebase Storage. But, I am not able to do it successfully. I could successfully upload the image (single) to the storage and add the URL of the image to the Firestore, now that I revised my code to upload up to five images, it could be any number of images from 1 to 5.

    R.id.btn_submit -> {
    if (validateDetails()) {
        uploadImage()
    }
}

The above code, calls the following function after validating the fields, which then calls the function uploadImageToCloudStorage. mSelectedImageFileUriList is private var mSelectedImageFileUriList: MutableList<Uri?>? = null. It all seems to work correctly.

    private fun uploadImage() {
    showProgressDialog(resources.getString(R.string.please_wait))
    FirestoreClass().uploadImageToCloudStorage(
        this@AddProductActivity,
        mSelectedImageFileUriList,
        Constants.PRODUCT_IMAGE,
        Constants.PRODUCT_IMAGE_DIRECTORY_NAME,
        et_product_title.text.toString().trim { it <= ' ' }
    )
}

Following code is where I guess is a mistake.

    fun uploadImageToCloudStorage(
     activity: AddProductActivity,
     imageFileURI: MutableList<Uri?>?,
     imageType: String,
     directoryName: String,
     title: String
 ) {

     var i = 0
     val imageURLList = ArrayList<String>()
     val itr = imageFileURI?.iterator()

     if (itr != null) {

         while (itr.hasNext()) {

             val sRef: StorageReference = FirebaseStorage.getInstance().getReference(
                 "/$directoryName/" + imageType + "." + Constants.getFileExtension(
                     activity,
                     imageFileURI[i]
                 )
             )
            
             sRef.putFile(imageFileURI[i]!!)
                 .addOnSuccessListener { taskSnapshot ->  
                     taskSnapshot.metadata!!.reference!!.downloadUrl
                         .addOnSuccessListener { uri ->
                             
                             if (i < imageFileURI.size) {
                                 i += 1
                                 imageURLList.add(uri.toString())

                             } else {
                                 activity.imageUploadSuccess(imageURLList)
                             }
                         }
                 }
                 .addOnFailureListener { exception ->
                     activity.hideProgressDialog()
                   Log.e(
                         activity.javaClass.simpleName,
                         exception.message,
                         exception
                     )
                 }

         }
     } else {
         Toast.makeText(
             activity,
             "There is no images in the ArrayList of URI",
             Toast.LENGTH_SHORT
         ).show()
     }
 }

EDIT: After receiving the first answer.

I have created a QueueSyn.kt file and added the code in the Answer. The activity where the images and the button are changed to

class AddProductActivity : BaseActivity(), View.OnClickListener, QueueSyncCallback {

The following function is called when the button is hit.

    private fun uploadProductImage() {

    showProgressDialog(resources.getString(R.string.please_wait))

   QueueSync(
        mSelectedImageFileUriList,
        Constants.PRODUCT_IMAGE,
        Constants.PRODUCT_IMAGE_DIRECTORY_NAME,
        et_product_title.text.toString().trim { it <= ' ' },
        this
    ).startUploading()

}

I have also implemented these two methods in the class AddProductActivity, but I don't know what should go inside this.

    override fun completed(successList: MutableList<Uri>, failureList: MutableList<Uri>) {
    TODO("Not yet implemented")
}

override fun getFileExtension(uri: Uri): String {
    TODO("Not yet implemented")
}

Error:

Answer 1

This should work

import android.net.Uri
import com.google.firebase.storage.FirebaseStorage
import com.google.firebase.storage.StorageReference
import java.util.*
import kotlin.collections.ArrayList

interface QueueSyncCallback {
    fun completed(successList: MutableList<Uri>, failureList: MutableList<Uri>)
    fun getFileExtension(uri: Uri): String
}

class QueueSync(
    imageFileURI: MutableList<Uri?>?,
    private val imageType: String,
    private val directoryName: String,
    private val title: String,
    private val callback: QueueSyncCallback,
    private val maxActive: Int = 5
) {
    private val queue: LinkedList<Uri> = LinkedList()
    private val runningQueue: MutableList<Uri> = Collections.synchronizedList(
        object : ArrayList<Uri>() {
            override fun remove(element: Uri): Boolean {
                val removed = super.remove(element)

                if (isEmpty() && queue.isEmpty()) {
                    callback.completed(successList, failureList)
                } else if (queue.isNotEmpty()) {
                    addToRunningQueue()
                }
                return removed
            }
        }
    )
    private val successList: MutableList<Uri> = Collections.synchronizedList(ArrayList())
    private val failureList: MutableList<Uri> = Collections.synchronizedList(ArrayList())

    init {
        if (imageFileURI != null)
            for (uri in imageFileURI) {
                if (uri != null)
                    queue.add(uri)
            }
    }

    private fun getLocation(uri: Uri) = "/$directoryName/$imageType.${callback.getFileExtension(uri)}"

    fun startUploading() {
        var i = 0

        if (queue.isEmpty()) {
            callback.completed(successList, failureList)
            return
        }

        while (i < maxActive && queue.isNotEmpty()) {
            addToRunningQueue()
            i++
        }
    }

    private fun addToRunningQueue() {
        val uri = queue.poll()!!
        runningQueue.add(uri)
        uploadImageToCloudStorage(uri)
    }

    private fun uploadImageToCloudStorage(locationUri: Uri) {
        val sRef: StorageReference = FirebaseStorage.getInstance().getReference(getLocation(locationUri))

        sRef.putFile(locationUri)
            .addOnSuccessListener { taskSnapshot ->
                taskSnapshot.metadata!!.reference!!.downloadUrl
                    .addOnSuccessListener { uri ->
                        successList.add(uri)
                        runningQueue.remove(locationUri)
                    }
            }
            .addOnFailureListener {
                failureList.add(locationUri)
                runningQueue.remove(locationUri)
            }
    }
}

Since your need requires usage of threads so to prevent race conditions I had to use Collections.synchronizedList. To use this you need to implement QueueSyncCallback in your activity and pass it as a reference to QueueSync. Make sure that any piece of code written inside completed is wrapped inside runOnMainThread if it is going to access views in any way since completed will not run on main thread as far as I know. This should work however I am not able to test it since it is based on your current code.

Edit:- Answering after edit

override fun completed(successList: MutableList<Uri>, failureList: MutableList<Uri>) {
    imageUploadSuccess(successList)
    hideProgressDialog()
}

override fun getFileExtension(uri: Uri): String {
    Constants.getFileExtension(this, imageFileURI[i])
}