Upload files in Cloud Storage

Cloud Storage provides facilities for developers to quickly and easily upload files to the Google Cloud Storage bucket, which is provided or managed by Firebase. By default, Firebase Authentication is required for uploading files in Cloud Storage buckets. But we can modify our Firebase Security Rules for allowing un-authentication access.

Since the default, Engine app, Google app, and Firebase share this bucket, configuring public access can also make the newly uploaded App Engine file publicly accessible. When you set up authentication, make sure to access our storage bucket again.

For uploading a file to the Cloud Storage, we will first create a reference to the full path of the file with a file name.

// Create a storage reference from our app
val storageRef = storage.reference

// Create a reference to "mountains.jpg"
val mountainsRef = storageRef.child("mountains.jpg")

// Create a reference to 'images/mountains.jpg'
val mountainImagesRef = storageRef.child("images/mountains.jpg")

//When the file names are same, the references point to different files
mountainsRef.name == mountainImagesRef.name // true
mountainsRef.path == mountainImagesRef.path // false

Once we have created an appropriate reference, we then call the putBytes(), putFile(), or putStream() method for uploading the file to Cloud Storage. We can't upload data with reference to the root of our Google Cloud Storage bucket. Our reference must point to a child URL.

Upload from data in memory

The putBytes() method is the simplest way through which we can upload a file to the Cloud Storage easily. The putBytes() method takes a byte[] and returns an UploadTask which we can use to manage and monitor the status of the upload.

// Getting the data from an ImageView as bytes
imageView.isDrawingCacheEnabled = true
imageView.buildDrawingCache()
val bitmap = (imageView.drawable as BitmapDrawable).bitmap
val baos = ByteArrayOutputStream()
bitmap.compress(Bitmap.CompressFormat.JPEG, 100, baos)
val data = baos.toByteArray()

var uploadTask = mountainsRef.putBytes(data)
uploadTask.addOnFailureListener {
    // Handlling unsuccessful uploads
}.addOnSuccessListener {
    // The taskSnapshot.metadata contains file metadata such as content-type, size, etc.
    // ...
}

Because putBytes() accepts a byte[], it requires our app to hold the entire contents of a file in memory at once. We consider putStream() or putFile() to use less memory.

Upload from a stream

The most flexible way to upload a file to Cloud Storage is the use of the putStream() method. This method takes an InputStream and returns an UploadTask, which will use to manage and monitor the status of the upload.

val stream = FileInputStream(File("path/to/images/mountain.jpg"))

uploadTask = mountainsRef.putStream(stream)
uploadTask.addOnFailureListener {
    // Handling unsuccessful uploads
}.addOnSuccessListener {
    // The taskSnapshot.metadata contains file metadata such as content-type, size, etc.
    // ...
}

Upload from a local file

We can upload local files on the device with the putFile() method. This method takes a File as an input and returns an UploadTask which we can use for managing and monitoring the status of the upload.

var file = Uri.fromFile(File("path/to/images/rivers.jpg"))
val riversRef = storageRef.child("images/${file.lastPathSegment}")
uploadTask = riversRef.putFile(file)

// Registering observers to listen for when the download is done or if it fails
uploadTask.addOnFailureListener {
    // Handling unsuccessful uploads
}.addOnSuccessListener {
    // The taskSnapshot.metadata contains file metadata such as content-type, size, etc.
    // ...
}

Getting a download URL after uploading

For downloading the file, it is required that we should have a URL. For getting URL we have to call the getDownloadUrl() method on the StorageReference.

val ref = storageRef.child("images/mountains.jpg")
uploadTask = ref.putFile(file)

val urlTask = uploadTask.continueWithTask { task ->
    if (!task.isSuccessful) {
        task.exception?.let {
            throw it
        }
    }
    ref.downloadUrl
}.addOnCompleteListener { task ->
    if (task.isSuccessful) {
        val downloadUri = task.result
    } else {
        // Handling failures
        // ...
    }
}

Managing Uploads

There are some additional methods available such as pause(), resume(), and cancel(), which are used to pause, resume, or cancel the uploads. Pause, and Progress state changes, respectively, in pause and resume events. Canceling the upload cause the upload to fail with an error indicating that the upload was canceled.

uploadTask = storageRef.child("images/mountains.jpg").putFile(file)

// Pausing the upload
uploadTask.pause()

// Resuming the upload
uploadTask.resume()

// Canceling the upload
uploadTask.cancel()

Full Example

The example of upload with progress monitoring and error handling is as follows:

// Getting File or Blob
file = Uri.fromFile(File("path/to/mountains.jpg"))

// Creating the file metadata
metadata = StorageMetadata.Builder()
        .setContentType("image/jpeg")
        .build()

// Uploading the file and the metadata to the path 'images/mountains.jpg'
uploadTask = storageRef.child("images/${file.lastPathSegment}").putFile(file, metadata)

// Listening for state changes, errors, and completion of the upload.
uploadTask.addOnProgressListener { taskSnapshot ->
    val progress = (100.0 * taskSnapshot.bytesTransferred) / taskSnapshot.totalByteCount
    println("Upload is $progress% done")
}.addOnPausedListener {
    println("Upload is paused")
}.addOnFailureListener {
    // Handling unsuccessful uploads
}.addOnSuccessListener {
    // Handling successful uploads on complete
    // ...
}

Next TopicFirebase Hosting

← prev next →