Fixed crashes due to large images. (#14)

* chore: android working properly.

* chore: ios and jvm image selector working too.

* chore: updated docs for `selectImage` function.

* chore: updated docs for `selectImage` function. (edited doc)

* refactor: made the parameters optional for `selectImage()` function.

* refactor: replaced screen size with window size. that means the image will be selected and down-sampled for the app window size instead of screen size of the device.

* refactor: removed `reqResolution` optional parameter to make it simple simple to use and eliminate the possibility that an invalid resolution is passed.

* bump: bumped version to 1.4.0.

Author: AdiK5050

imageselector/build.gradle.kts

@@ -11,7 +11,7 @@ plugins {
 }
 
 group = "com.wannaverse"
-version = "1.3.0"
+version = "1.4.0"
 
 kotlin {
     androidTarget {

imageselector/src/androidMain/kotlin/com/wannaverse/imageselector/ByteArrayExtension.kt

@@ -36,7 +36,7 @@ actual suspend fun ByteArray.downSamplingToImageBitmap(
     return imageBitmap
 }
 
-private fun calculateInSampleSize(options: BitmapFactory.Options, reqHeight: Int, reqWidth: Int): Int {
+fun calculateInSampleSize(options: BitmapFactory.Options, reqHeight: Int, reqWidth: Int): Int {
     val (height: Int, width: Int) = options.run { outHeight to outWidth }
     var inSampleSize = 1
     if(height > reqHeight || width > reqWidth) {

imageselector/src/androidMain/kotlin/com/wannaverse/imageselector/CalculateScrenSize.android.kt

@@ -0,0 +1,20 @@
+package com.wannaverse.imageselector
+
+import android.content.Context
+import android.os.Build
+import android.view.WindowManager
+
+actual fun getCurrentWindowSize(): WindowSize {
+    val windowManager = getAppContext().getSystemService(Context.WINDOW_SERVICE) as WindowManager
+
+    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+        val metrics = windowManager.currentWindowMetrics
+        val bounds = metrics.bounds
+        WindowSize(width = bounds.width(), height = bounds.height())
+    } else {
+        val display = windowManager.defaultDisplay
+        val point = android.graphics.Point()
+        display.getSize(point)
+        WindowSize(width = point.x, height = point.y)
+    }
+}

imageselector/src/androidMain/kotlin/com/wannaverse/imageselector/ImageSelector.android.kt

@@ -1,42 +1,48 @@
 package com.wannaverse.imageselector
 
+import android.content.Context
+import android.graphics.BitmapFactory
 import android.net.Uri
 import androidx.activity.ComponentActivity
 import androidx.activity.result.ActivityResultLauncher
 import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.ui.graphics.asImageBitmap
+import kotlinx.coroutines.DelicateCoroutinesApi
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.launch
 import kotlinx.coroutines.suspendCancellableCoroutine
-import java.io.IOException
 import kotlin.coroutines.resume
 
 private var imageSelectorLauncher: ActivityResultLauncher<String>? = null
 private var pendingContinuation: ((ImageData?) -> Unit)? = null
 private var currentActivity: ComponentActivity? = null
+private lateinit  var imageLoadingState: ((Boolean) -> Unit)
+private var reqImageResolution: WindowSize? = null
 
 fun setImageSelectorActivity(activity: ComponentActivity) {
     currentActivity = activity
 }
 
+fun getAppContext(): Context {
+    if(currentActivity == null) throw RuntimeException("add `setImageSelectorActivity(this)` in `MainActivity.kt` of your android module!")
+    return currentActivity!!.applicationContext
+}
 fun ComponentActivity.registerImageSelectorLauncher() {
     imageSelectorLauncher =
         registerForActivityResult(ActivityResultContracts.GetContent()) { uri: Uri? ->
-            val activity = currentActivity ?: return@registerForActivityResult
-            val result = uri?.let {
-                try {
-                    val bytes = activity.contentResolver.openInputStream(it)?.use { s -> s.readBytes() }
-                    ImageData(
-                        bytes = bytes
-                    )
-                } catch (e: IOException) {
-                    e.printStackTrace()
-                    null
-                }
+            if (uri != null && reqImageResolution != null) {
+                decodeSampledBitmapFromUri(this, uri, reqImageResolution!!)
+            } else {
+                pendingContinuation?.invoke(null)
+                pendingContinuation = null
             }
-            pendingContinuation?.invoke(result)
-            pendingContinuation = null
         }
 }
 
-actual suspend fun selectImage(): ImageData? = suspendCancellableCoroutine { continuation ->
+actual suspend fun selectImage(loadingState: (Boolean) -> Unit): ImageData? = suspendCancellableCoroutine { continuation ->
+
+    reqImageResolution = getCurrentWindowSize()
     val launcher = imageSelectorLauncher
     if (launcher == null) {
         continuation.resume(null)
@@ -47,5 +53,38 @@ actual suspend fun selectImage(): ImageData? = suspendCancellableCoroutine { con
         continuation.resume(imageData)
     }
 
+    imageLoadingState = { state ->
+        loadingState(state)
+    }
     launcher.launch("image/*")
+}
+
+@OptIn(DelicateCoroutinesApi::class)
+fun decodeSampledBitmapFromUri(context: Context, uri: Uri, reqResolution: WindowSize) = GlobalScope.launch(
+    Dispatchers.Default) {
+    imageLoadingState.invoke(true)
+    var resultData: ImageData? = null
+
+    try {
+        context.contentResolver.openFileDescriptor(uri, "r")?.use { parcelFileDescriptor ->
+            val fileDescriptor = parcelFileDescriptor.fileDescriptor
+
+            val options = BitmapFactory.Options().apply { inJustDecodeBounds = true }
+            BitmapFactory.decodeFileDescriptor(fileDescriptor, null, options)
+
+            options.inSampleSize = calculateInSampleSize(options, reqResolution.width, reqResolution.height)
+            options.inJustDecodeBounds = false
+
+            val bitmap = BitmapFactory.decodeFileDescriptor(fileDescriptor, null, options)
+            if (bitmap != null) {
+                resultData = ImageData(bitmap.asImageBitmap().toByteArray())
+            }
+        }
+    } catch (e: Exception) {
+        e.printStackTrace()
+    } finally {
+        pendingContinuation?.invoke(resultData)
+        pendingContinuation = null
+        imageLoadingState.invoke(false)
+    }
 }

imageselector/src/commonMain/kotlin/com/wannaverse/imageselector/CalculateScrenSize.kt

@@ -0,0 +1,5 @@
+package com.wannaverse.imageselector
+
+data class WindowSize(val width: Int, val height: Int)
+
+expect fun getCurrentWindowSize(): WindowSize

imageselector/src/commonMain/kotlin/com/wannaverse/imageselector/ImageSelector.kt

@@ -3,5 +3,9 @@ package com.wannaverse.imageselector
 /**
  * Opens the platform's image picker and returns the selected [ImageData], or `null`
  * if the user cancels the selection.
+ * The image isn't loaded in the memory in its actual size, it's downsampled according to the
+ * current window size of the app and then loaded into memory as [ImageData] which is lower than the
+ * actual size eliminating the possibility of `OutOfMemoryError`
+ * @param loadingState a callback to pass true if image is processing and false if it has finished processing the image.
  */
-expect suspend fun selectImage(): ImageData?
+expect suspend fun selectImage(loadingState: (Boolean) -> Unit = {}): ImageData?

imageselector/src/iosMain/kotlin/com/wannaverse/imageselector/CalculateScrenSize.ios.kt

@@ -0,0 +1,26 @@
+package com.wannaverse.imageselector
+
+import kotlinx.cinterop.ExperimentalForeignApi
+import kotlinx.cinterop.useContents
+import platform.UIKit.UIApplication
+import platform.UIKit.UIScreen
+import platform.UIKit.UIWindow
+import platform.UIKit.UIWindowScene
+
+@OptIn(ExperimentalForeignApi::class)
+actual fun getCurrentWindowSize(): WindowSize {
+    val activeScene = UIApplication.sharedApplication.connectedScenes
+        .filterIsInstance<UIWindowScene>()
+        .firstOrNull()
+
+    val windowBounds = activeScene?.windows?.filterIsInstance<UIWindow>()
+        ?.firstOrNull { it.isKeyWindow() }?.bounds
+        ?: UIScreen.mainScreen.bounds
+
+    val scale = UIScreen.mainScreen.scale
+
+    val widthPx = (windowBounds.useContents { size.width } * scale).toInt()
+    val heightPx = (windowBounds.useContents { size.height } * scale).toInt()
+
+    return WindowSize(width = widthPx, height = heightPx)
+}

imageselector/src/iosMain/kotlin/com/wannaverse/imageselector/ImageSelector.ios.kt

@@ -1,50 +1,103 @@
 package com.wannaverse.imageselector
 
+import kotlinx.cinterop.BetaInteropApi
 import kotlinx.cinterop.ExperimentalForeignApi
-import kotlinx.cinterop.memScoped
-import kotlinx.cinterop.refTo
+import kotlinx.cinterop.addressOf
+import kotlinx.cinterop.autoreleasepool
+import kotlinx.cinterop.useContents
+import kotlinx.cinterop.usePinned
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
 import kotlinx.coroutines.suspendCancellableCoroutine
-import platform.Foundation.NSData
+import kotlinx.coroutines.withContext
+import platform.UIKit.UIApplication
+import platform.UIKit.UIImage
 import platform.UIKit.UIImagePickerController
-import platform.UIKit.UIImagePickerControllerSourceType
 import platform.UIKit.UIImagePickerControllerDelegateProtocol
-import platform.UIKit.UINavigationControllerDelegateProtocol
 import platform.UIKit.UIImagePickerControllerOriginalImage
-import platform.UIKit.UIImageJPEGRepresentation
-import platform.UIKit.UIApplication
-import platform.UIKit.UIImage
+import platform.UIKit.UIImagePickerControllerSourceType
+import platform.UIKit.UINavigationControllerDelegateProtocol
 import platform.darwin.NSObject
-import platform.posix.memcpy
 import kotlin.coroutines.resume
 
 private var activePickerDelegate: NSObject? = null
 private var activePicker: UIImagePickerController? = null
 
-actual suspend fun selectImage(): ImageData? = suspendCancellableCoroutine { continuation ->
+@OptIn(ExperimentalForeignApi::class, BetaInteropApi::class)
+actual suspend fun selectImage(
+    loadingState: (Boolean) -> Unit
+): ImageData? = suspendCancellableCoroutine { continuation ->
     val picker = UIImagePickerController().apply {
-        sourceType =
-            UIImagePickerControllerSourceType.UIImagePickerControllerSourceTypePhotoLibrary
+        sourceType = UIImagePickerControllerSourceType.UIImagePickerControllerSourceTypePhotoLibrary
         allowsEditing = false
     }
-
-    val delegate = object : NSObject(), UIImagePickerControllerDelegateProtocol, UINavigationControllerDelegateProtocol {
+    val reqResolution = getCurrentWindowSize()
+    val delegate = object : NSObject(), UIImagePickerControllerDelegateProtocol,
+        UINavigationControllerDelegateProtocol {
         override fun imagePickerController(
             picker: UIImagePickerController,
             didFinishPickingMediaWithInfo: Map<Any?, *>
         ) {
-            val image = didFinishPickingMediaWithInfo[UIImagePickerControllerOriginalImage] as? UIImage
-            val data = image?.toJpegData(quality = 1.0)
-            val bytes = data?.toByteArray()
+            loadingState(true)
 
-            picker.dismissViewControllerAnimated(true) {
-                clearActivePickerReferences()
-                continuation.resume(bytes?.let { ImageData(bytes = it) })
+            val originalImage = didFinishPickingMediaWithInfo[UIImagePickerControllerOriginalImage] as? UIImage
+
+            if (originalImage == null) {
+                picker.dismissViewControllerAnimated(true) {
+                    clearActivePickerReferences()
+                    loadingState(false)
+                    continuation.resume(null)
+                }
+                return
             }
-        }
 
+            CoroutineScope(Dispatchers.Default).launch {
+                var resultBytes: ByteArray? = null
+
+                autoreleasepool {
+                    val (srcWidth, srcHeight) = originalImage.size.useContents { width to height }
+
+                    val scaleFactor = minOf(reqResolution.width.toDouble() / srcWidth, reqResolution.height.toDouble() / srcHeight)
+                    val finalScale = if (scaleFactor < 1.0) scaleFactor else 1.0
+                    val targetWidth = srcWidth * finalScale
+                    val targetHeight = srcHeight * finalScale
+
+                    val targetSize = platform.CoreGraphics.CGSizeMake(targetWidth, targetHeight)
+
+                    platform.UIKit.UIGraphicsBeginImageContextWithOptions(targetSize, false, 1.0)
+                    originalImage.drawInRect(platform.CoreGraphics.CGRectMake(0.0, 0.0, targetWidth, targetHeight))
+                    val downsampledImage = platform.UIKit.UIGraphicsGetImageFromCurrentImageContext()
+                    platform.UIKit.UIGraphicsEndImageContext()
+
+                    if (downsampledImage != null) {
+                        val nsData = platform.UIKit.UIImageJPEGRepresentation(downsampledImage, 0.85)
+                        if (nsData != null) {
+                            val byteArray = ByteArray(nsData.length.toInt())
+                            if (byteArray.isNotEmpty()) {
+                                byteArray.usePinned { pinned ->
+                                    platform.posix.memcpy(pinned.addressOf(0), nsData.bytes, nsData.length)
+                                }
+                            }
+                            resultBytes = byteArray
+                        }
+                    }
+                }
+
+                withContext(Dispatchers.Main) {
+                    picker.dismissViewControllerAnimated(true) {
+                        clearActivePickerReferences()
+                        loadingState(false)
+
+                        continuation.resume(resultBytes?.let { ImageData(bytes = it) })
+                    }
+                }
+            }
+        }
         override fun imagePickerControllerDidCancel(picker: UIImagePickerController) {
             picker.dismissViewControllerAnimated(true) {
                 clearActivePickerReferences()
+                loadingState(false)
                 continuation.resume(null)
             }
         }
@@ -73,18 +126,4 @@ private fun clearActivePickerReferences() {
     activePicker?.delegate = null
     activePicker = null
     activePickerDelegate = null
-}
-
-private fun UIImage.toJpegData(quality: Double = 1.0): NSData? {
-    return UIImageJPEGRepresentation(this, quality)
-}
-
-@OptIn(ExperimentalForeignApi::class)
-private fun NSData.toByteArray(): ByteArray {
-    val bytes = ByteArray(this.length.toInt())
-    memScoped {
-        val rawPtr = bytes.refTo(0).getPointer(this)
-        memcpy(rawPtr, this@toByteArray.bytes, this@toByteArray.length)
-    }
-    return bytes
-}
+}

imageselector/src/jvmMain/kotlin/com/wannaverse/imageselector/CalculateScrenSize.jvm.kt

@@ -0,0 +1,18 @@
+package com.wannaverse.imageselector
+
+import java.awt.Window
+
+actual fun getCurrentWindowSize(): WindowSize {
+    val activeWindow = Window.getWindows().firstOrNull { it.isFocused }
+        ?: Window.getWindows().firstOrNull()
+
+    return if (activeWindow != null) {
+        WindowSize(
+            width = activeWindow.width,
+            height = activeWindow.height
+        )
+    } else {
+        val screenSize = java.awt.Toolkit.getDefaultToolkit().screenSize
+        WindowSize(width = screenSize.width, height = screenSize.height)
+    }
+}