Refactoring: Proper data class BitmapLoadingWorkerJob.Result & clean up surroundings. (#515)

Author: vanniktech

cropper/src/main/kotlin/com/canhub/cropper/BitmapCroppingWorkerJob.kt

@@ -133,25 +133,20 @@ internal class BitmapCroppingWorkerJob(
           it.onImageCroppingAsyncComplete(result)
         }
       }
+
       if (!completeCalled && result.bitmap != null) {
-        // fast release of unused bitmap
+        // Fast release of unused bitmap.
         result.bitmap.recycle()
       }
     }
   }
 
-  fun cancel() {
-    job.cancel()
-  }
+  fun cancel() = job.cancel()
 
   internal data class Result(
-    /** The cropped bitmap. */
     val bitmap: Bitmap?,
-    /** The saved cropped bitmap uri. */
     val uri: Uri?,
-    /** The error that occurred during async bitmap cropping. */
     val error: Exception?,
-    /** Sample size used creating the crop bitmap to lower its size. */
     val sampleSize: Int,
   )
 }

cropper/src/main/kotlin/com/canhub/cropper/BitmapLoadingWorkerJob.kt

@@ -15,24 +15,24 @@ import kotlin.coroutines.CoroutineContext
 internal class BitmapLoadingWorkerJob internal constructor(
   private val context: Context,
   cropImageView: CropImageView,
-  val uri: Uri,
+  internal val uri: Uri,
 ) : CoroutineScope {
   private val width: Int
   private val height: Int
   private val cropImageViewReference = WeakReference(cropImageView)
-  private var currentJob: Job = Job()
+  private var job: Job = Job()
 
-  override val coroutineContext: CoroutineContext get() = Dispatchers.Main + currentJob
+  override val coroutineContext: CoroutineContext get() = Dispatchers.Main + job
 
   init {
     val metrics = cropImageView.resources.displayMetrics
-    val densityAdj = if (metrics.density > 1) (1.0 / metrics.density) else 1.0
-    width = (metrics.widthPixels * densityAdj).toInt()
-    height = (metrics.heightPixels * densityAdj).toInt()
+    val densityAdjustment = if (metrics.density > 1) (1.0 / metrics.density) else 1.0
+    width = (metrics.widthPixels * densityAdjustment).toInt()
+    height = (metrics.heightPixels * densityAdjustment).toInt()
   }
 
   fun start() {
-    currentJob = launch(Dispatchers.Default) {
+    job = launch(Dispatchers.Default) {
       try {
         if (isActive) {
           val decodeResult = BitmapUtils.decodeSampledBitmap(
@@ -41,6 +41,7 @@ internal class BitmapLoadingWorkerJob internal constructor(
             reqWidth = width,
             reqHeight = height,
           )
+
           if (isActive) {
             val orientateResult = BitmapUtils.orientateBitmapByExif(
               bitmap = decodeResult.bitmap,
@@ -56,21 +57,27 @@ internal class BitmapLoadingWorkerJob internal constructor(
                 degreesRotated = orientateResult.degrees,
                 flipHorizontally = orientateResult.flipHorizontally,
                 flipVertically = orientateResult.flipVertically,
+                error = null,
               ),
             )
           }
         }
       } catch (e: Exception) {
-        onPostExecute(Result(uri, e))
+        onPostExecute(
+          Result(
+            uri = uri,
+            bitmap = null,
+            loadSampleSize = 0,
+            degreesRotated = 0,
+            flipHorizontally = false,
+            flipVertically = false,
+            error = e,
+          ),
+        )
       }
     }
   }
 
-  /**
-   * Once complete, see if ImageView is still around and set bitmap.
-   *
-   * [result] the result of bitmap loading
-   */
   private suspend fun onPostExecute(result: Result) {
     withContext(Dispatchers.Main) {
       var completeCalled = false
@@ -80,65 +87,23 @@ internal class BitmapLoadingWorkerJob internal constructor(
           it.onSetImageUriAsyncComplete(result)
         }
       }
+
       if (!completeCalled && result.bitmap != null) {
-        // fast release of unused bitmap
+        // Fast release of unused bitmap.
         result.bitmap.recycle()
       }
     }
   }
 
-  fun cancel() {
-    currentJob.cancel()
-  }
-
-  /** The result of BitmapLoadingWorkerJob async loading. */
-  internal companion object class Result {
-    /**
-     * The Android URI of the image to load.
-     */
-    val uriContent: Uri
-
-    /** The loaded bitmap. */
-    val bitmap: Bitmap?
-
-    /** The sample size used to load the given bitmap. */
-    val loadSampleSize: Int
-
-    /** The degrees the image was rotated. */
-    val degreesRotated: Int
-
-    /** If the image was flipped horizontally. */
-    var flipHorizontally: Boolean = false
-
-    /** If the image was flipped vertically. */
-    var flipVertically: Boolean = false
-
-    /** The error that occurred during async bitmap loading. */
-    val error: Exception?
-
-    internal constructor(
-      uri: Uri,
-      bitmap: Bitmap?,
-      loadSampleSize: Int,
-      degreesRotated: Int,
-      flipHorizontally: Boolean,
-      flipVertically: Boolean,
-    ) {
-      uriContent = uri
-      this.bitmap = bitmap
-      this.loadSampleSize = loadSampleSize
-      this.degreesRotated = degreesRotated
-      this.flipHorizontally = flipHorizontally
-      this.flipVertically = flipVertically
-      error = null
-    }
-
-    internal constructor(uri: Uri, error: Exception?) {
-      uriContent = uri
-      bitmap = null
-      loadSampleSize = 0
-      degreesRotated = 0
-      this.error = error
-    }
-  }
+  fun cancel() = job.cancel()
+
+  internal data class Result(
+    val uri: Uri,
+    val bitmap: Bitmap?,
+    val loadSampleSize: Int,
+    val degreesRotated: Int,
+    val flipHorizontally: Boolean,
+    val flipVertically: Boolean,
+    val error: Exception?,
+  )
 }

cropper/src/main/kotlin/com/canhub/cropper/CropImageView.kt

@@ -467,7 +467,13 @@ class CropImageView @JvmOverloads constructor(
       if (resId != 0) {
         mCropOverlayView!!.initialCropWindowRect = null
         val bitmap = BitmapFactory.decodeResource(resources, resId)
-        setBitmap(bitmap, resId, null, 1, 0)
+        setBitmap(
+          bitmap = bitmap,
+          imageResource = resId,
+          imageUri = null,
+          loadSampleSize = 1,
+          degreesRotated = 0,
+        )
       }
     }
 
@@ -727,7 +733,13 @@ class CropImageView @JvmOverloads constructor(
    */
   fun setImageBitmap(bitmap: Bitmap?) {
     mCropOverlayView!!.initialCropWindowRect = null
-    setBitmap(bitmap, 0, null, 1, 0)
+    setBitmap(
+      bitmap = bitmap,
+      imageResource = 0,
+      imageUri = null,
+      loadSampleSize = 1,
+      degreesRotated = 0,
+    )
   }
 
   /**
@@ -754,7 +766,13 @@ class CropImageView @JvmOverloads constructor(
     }
 
     mCropOverlayView!!.initialCropWindowRect = null
-    setBitmap(setBitmap, 0, null, 1, degreesRotated)
+    setBitmap(
+      bitmap = setBitmap,
+      imageResource = 0,
+      imageUri = null,
+      loadSampleSize = 1,
+      degreesRotated = degreesRotated,
+    )
   }
 
   /**
@@ -766,15 +784,11 @@ class CropImageView @JvmOverloads constructor(
    */
   fun setImageUriAsync(uri: Uri?) {
     if (uri != null) {
-      val currentTask =
-        if (bitmapLoadingWorkerJob != null) bitmapLoadingWorkerJob!!.get() else null
-      currentTask?.cancel()
-      // either no existing task is working or we canceled it, need to load new URI
+      bitmapLoadingWorkerJob?.get()?.cancel()
       clearImageInt()
       mCropOverlayView!!.initialCropWindowRect = null
-      bitmapLoadingWorkerJob =
-        WeakReference(BitmapLoadingWorkerJob(context, this, uri))
-      bitmapLoadingWorkerJob!!.get()!!.start()
+      bitmapLoadingWorkerJob = WeakReference(BitmapLoadingWorkerJob(context, this, uri))
+      bitmapLoadingWorkerJob?.get()?.start()
       setProgressBarVisibility()
     }
   }
@@ -908,14 +922,18 @@ class CropImageView @JvmOverloads constructor(
       mFlipHorizontally = result.flipHorizontally
       mFlipVertically = result.flipVertically
       setBitmap(
-        result.bitmap,
-        0,
-        result.uriContent,
-        result.loadSampleSize,
-        result.degreesRotated,
+        bitmap = result.bitmap,
+        imageResource = 0,
+        imageUri = result.uri,
+        loadSampleSize = result.loadSampleSize,
+        degreesRotated = result.degreesRotated,
       )
     }
-    mOnSetImageUriCompleteListener?.onSetImageUriComplete(this, result.uriContent, result.error)
+    mOnSetImageUriCompleteListener?.onSetImageUriComplete(
+      view = this,
+      uri = result.uri,
+      error = result.error,
+    )
   }
 
   /**
@@ -1092,11 +1110,9 @@ class CropImageView @JvmOverloads constructor(
       bundle.putString("LOADED_IMAGE_STATE_BITMAP_KEY", key)
     }
 
-    if (bitmapLoadingWorkerJob != null) {
-      val task = bitmapLoadingWorkerJob!!.get()
-      if (task != null) {
-        bundle.putParcelable("LOADING_IMAGE_URI", task.uri)
-      }
+    val task = bitmapLoadingWorkerJob?.get()
+    if (task != null) {
+      bundle.putParcelable("LOADING_IMAGE_URI", task.uri)
     }
 
     bundle.putParcelable("instanceState", super.onSaveInstanceState())
@@ -1131,7 +1147,13 @@ class CropImageView @JvmOverloads constructor(
             }
             BitmapUtils.mStateBitmap = null
             if (stateBitmap != null && !stateBitmap.isRecycled) {
-              setBitmap(stateBitmap, 0, uri, state.getInt("LOADED_SAMPLE_SIZE"), 0)
+              setBitmap(
+                bitmap = stateBitmap,
+                imageResource = 0,
+                imageUri = uri,
+                loadSampleSize = state.getInt("LOADED_SAMPLE_SIZE"),
+                degreesRotated = 0,
+              )
             }
           }
           imageUri ?: setImageUriAsync(uri)