🚀 Building an Image Compression Library in Android (Kotlin) Part-1

In Part-1, we will see how to create library for Image compress and use locally in Android Studio. In Part-2 will discuss how to pulish library.

Uploading large images in Android apps can lead to slow uploads, high data usage, and failed server requests. To tackle this, we can build a reusable Kotlin library that compresses images before uploading them to a server or Firebase.

In this article, you’ll learn:

• Why image compression is important
• How to create a reusable Kotlin image compressor library
• Code snippets for different compression needs
• Code explanations
• How to use it in your app

📦 Why Compress Images in Android?

• 🚀 Faster uploads: Reduce image file size.
• 📱 Better user experience: Prevent upload failures.
• ☁️ Save bandwidth and storage.
• 🔄 Efficient sync with Firebase or backend APIs.

🛠️ Step 1: Create a Kotlin Library Module

Go to Android Studio:

• File > New > New Module > Android Library
• Name it imagecompressor

📁 Step 2: Add Compressor Code

In imagecompressor module, create a Kotlin file: ImageCompressor.kt

package com.imagecompressor

import android.content.Context
import android.graphics.Bitmap
import android.graphics.BitmapFactory
import android.net.Uri
import java.io.ByteArrayOutputStream
import java.io.File
import java.io.FileOutputStream
import java.io.InputStream
import java.util.UUID

object ImageCompressor {

    fun compressImage(context: Context, imageUri: Uri, quality: Int = 80): File? {
        return try {
            val inputStream: InputStream? = context.contentResolver.openInputStream(imageUri)
            val bitmap = BitmapFactory.decodeStream(inputStream)
            inputStream?.close()

            val file = File(context.cacheDir, "compressed_${UUID.randomUUID()}.jpg")
            val outputStream = FileOutputStream(file)
            bitmap.compress(Bitmap.CompressFormat.JPEG, quality, outputStream)
            outputStream.flush()
            outputStream.close()
            file
        } catch (e: Exception) {
            e.printStackTrace()
            null
        }
    }

    fun compressBitmap(context: Context, bitmap: Bitmap, quality: Int = 80): File? {
        return try {
            val file = File(context.cacheDir, "compressed_${UUID.randomUUID()}.jpg")
            val outputStream = FileOutputStream(file)
            bitmap.compress(Bitmap.CompressFormat.JPEG, quality, outputStream)
            outputStream.flush()
            outputStream.close()
            file
        } catch (e: Exception) {
            e.printStackTrace()
            null
        }
    }

    fun compressToBase64(bitmap: Bitmap, quality: Int = 80): String {
        val outputStream = ByteArrayOutputStream()
        bitmap.compress(Bitmap.CompressFormat.JPEG, quality, outputStream)
        val byteArray = outputStream.toByteArray()
        return android.util.Base64.encodeToString(byteArray, android.util.Base64.NO_WRAP)
    }
}

⚡ Code Explanation

• compressImage: Takes a Uri, converts it to a Bitmap, compresses it to JPEG with the given quality, and saves it as a temporary file.
• compressBitmap: Accepts a Bitmap directly, compresses and saves it as a temporary file.
• compressToBase64: Compresses a Bitmap to JPEG and returns the base64-encoded string (useful for APIs that accept image strings).

Each method uses context.cacheDir to save the temporary files, which makes them safe and easy to clean up.

🔄 Step 3: Use the Library in Your App

Add the module as a dependency in your app’s build.gradle:

implementation project(":imagecompressor")

In your Activity or ViewModel:

val imageUri: Uri = selectedImageUri
val compressedFile = ImageCompressor.compressImage(context, imageUri)

// Use compressedFile with Firebase or upload API

🔥 Bonus: Convert Bitmap to Base64 for API Upload

val base64String = ImageCompressor.compressToBase64(bitmap)
// Send base64String in request body

⚙️ Firebase Example: Upload Compressed Image

val fileUri = Uri.fromFile(compressedFile)
val ref = FirebaseStorage.getInstance().reference.child("images/${fileUri.lastPathSegment}")
ref.putFile(fileUri)
    .addOnSuccessListener { /* success */ }
    .addOnFailureListener { /* error */ }

✅ Best Practices

• Compress before upload to save bandwidth.
• Use 70–80% JPEG quality for balance.
• Cache compressed images temporarily.
• Clean up unused temp files.

📌 Summary

Creating your own image compression library in Kotlin helps you build scalable, reusable, and optimized Android apps. Whether you’re using Firebase or a custom backend, pre-processing image uploads can save costs and improve performanc.

Stay tuned for Part-2, where I will explain how to publish Android library.