refactor(AvatarAdjuster): adjuster now crops avatar too

Author: demndevel

app/src/main/java/friendly/android/AvatarAdjuster.kt

@@ -3,122 +3,59 @@ package friendly.android
 import android.content.Context
 import android.graphics.Bitmap
 import android.graphics.BitmapFactory
-import android.graphics.Matrix
 import android.net.Uri
-import android.util.Log
 import androidx.core.graphics.scale
-import androidx.exifinterface.media.ExifInterface
-import kotlinx.io.IOException
 import java.io.ByteArrayInputStream
 import java.io.ByteArrayOutputStream
 import java.io.InputStream
 
-class ImageCompressor(
+private const val newAvatarDimension = 500
+private const val maxAvatarSize = 16_384L
+private const val startQuality = 80
+private const val qualityStep = 10
+private const val minQuality = 40
+
+class AvatarAdjuster(
     private val uri: Uri,
     private val inputStream: InputStream,
-    private val maxImageSize: Long,
-    private val compressionQuality: Int,
-    private val maxFileSizeBytes: Long,
-    private val context: Context,
+    context: Context,
 ) {
     private val contentResolver = context.contentResolver
 
-    fun compress(): Pair<InputStream, Long> = compressImage(uri, inputStream)
+    /**
+     * Resizes, crops with aspect ration 1x1 and compresses avatar
+     */
+    fun adjust(): Pair<InputStream, Long> = adjustAvatar(uri, inputStream)
 
-    private fun compressImage(
+    private fun adjustAvatar(
         uri: Uri,
         inputStream: InputStream,
     ): Pair<InputStream, Long> {
         val bitmap = BitmapFactory.decodeStream(inputStream)
             ?: error("Failed to decode image")
-
-        val rotatedBitmap = handleImageRotation(uri, bitmap)
-
-        val widthIsLarger = rotatedBitmap.width > maxImageSize
-        val heightIsLarger = rotatedBitmap.height > maxImageSize
-        val isScaled = widthIsLarger || heightIsLarger
-
-        val scaledBitmap = if (isScaled) {
-            scaleBitmap(rotatedBitmap)
-        } else {
-            rotatedBitmap
-        }
+        val croppedDimension = minOf(bitmap.width, bitmap.height)
+        val croppedBitmap = Bitmap
+            .createBitmap(bitmap, 0, 0, croppedDimension, croppedDimension)
+        val scaledBitmap = croppedBitmap
+            .scale(newAvatarDimension, newAvatarDimension)
 
         val outputStream = ByteArrayOutputStream()
-        var quality = compressionQuality
-
+        var quality = startQuality
         do {
             outputStream.reset()
             scaledBitmap.compress(
                 Bitmap.CompressFormat.JPEG,
                 quality,
                 outputStream,
             )
-            quality -= 5
-        } while (outputStream.size() > maxFileSizeBytes && quality > 50)
+            quality -= qualityStep
+        } while (outputStream.size() > maxAvatarSize && quality > minQuality)
 
         val byteArray = outputStream.toByteArray()
 
-        if (scaledBitmap != rotatedBitmap) scaledBitmap.recycle()
-        if (rotatedBitmap != bitmap) rotatedBitmap.recycle()
-        bitmap.recycle()
-
-        Log.d(
-            "avatar",
-            "Compressed image: ${byteArray.size} bytes (quality: $quality)",
-        )
-
-        return Pair(ByteArrayInputStream(byteArray), byteArray.size.toLong())
-    }
-
-    private fun handleImageRotation(uri: Uri, bitmap: Bitmap): Bitmap {
-        val inputStream = contentResolver.openInputStream(uri) ?: return bitmap
-
-        return try {
-            val exif = ExifInterface(inputStream)
-            val orientation = exif.getAttributeInt(
-                ExifInterface.TAG_ORIENTATION,
-                ExifInterface.ORIENTATION_NORMAL,
-            )
-
-            val rotation = when (orientation) {
-                ExifInterface.ORIENTATION_ROTATE_90 -> 90f
-                ExifInterface.ORIENTATION_ROTATE_180 -> 180f
-                ExifInterface.ORIENTATION_ROTATE_270 -> 270f
-                else -> 0f
-            }
-
-            if (rotation != 0f) {
-                val matrix = Matrix().apply { postRotate(rotation) }
-                Bitmap.createBitmap(
-                    bitmap,
-                    0,
-                    0,
-                    bitmap.width,
-                    bitmap.height,
-                    matrix,
-                    true,
-                )
-            } else {
-                bitmap
-            }
-        } catch (exception: IOException) {
-            Log.w("avatar", "Failed to read EXIF data", exception)
-            bitmap
-        } finally {
-            inputStream.close()
-        }
-    }
-
-    private fun scaleBitmap(bitmap: Bitmap): Bitmap {
-        val ratio = minOf(
-            maxImageSize.toFloat() / bitmap.width,
-            maxImageSize.toFloat() / bitmap.height,
+        return Pair(
+            first = ByteArrayInputStream(outputStream.toByteArray()),
+            second = byteArray.size.toLong(),
         )
-
-        val newWidth = (bitmap.width * ratio).toInt()
-        val newHeight = (bitmap.height * ratio).toInt()
-
-        return bitmap.scale(newWidth, newHeight)
     }
 }

app/src/main/java/friendly/android/AvatarUploadUseCase.kt

@@ -21,12 +21,6 @@ class AvatarUploadUseCase(
     private val client: FriendlyClient,
     private val context: Context,
 ) {
-    companion object {
-        private const val MAX_IMAGE_SIZE = 2048L
-        private const val COMPRESSION_QUALITY = 75
-        private const val MAX_FILE_SIZE_BYTES = 2L * 1024L
-    }
-
     @JvmInline
     value class UploadingPercentage(val double: Double)
 
@@ -49,18 +43,16 @@ class AvatarUploadUseCase(
         val inputStream = contentResolver
             .openInputStream(avatarUri)
             ?: error("Couldn't read $avatarUri from the storage")
+
         val fileName = getFileName(avatarUri)
         val fileDescriptorUploadResult = CompletableDeferred<UploadFileResult>()
-        val compressor = ImageCompressor(
+        val compressor = AvatarAdjuster(
             uri = avatarUri,
             inputStream = inputStream,
-            maxImageSize = MAX_IMAGE_SIZE,
-            compressionQuality = COMPRESSION_QUALITY,
-            maxFileSizeBytes = MAX_FILE_SIZE_BYTES,
             context = context,
         )
 
-        val (compressedInputStream, compressedSize) = compressor.compress()
+        val (compressedInputStream, compressedSize) = compressor.adjust()
 
         compressedInputStream.use { inputStream ->
             val flow = channelFlow {
@@ -79,7 +71,9 @@ class AvatarUploadUseCase(
                 UploadingResult.IOError(result.cause)
             }
 
-            is UploadFileResult.ServerError -> UploadingResult.ServerError
+            is UploadFileResult.ServerError -> {
+                UploadingResult.ServerError
+            }
 
             is UploadFileResult.Success -> {
                 UploadingResult.Success(result.descriptor)