Merge branch 'develop' of github.com:ohnobug/mobile_scanner into develop

Author: yingshancool

CHANGELOG.md

@@ -54,6 +54,10 @@ Known issues:
 * [Apple] The scan window does not work correctly.
 * [Apple] The camera flash briefly shows when the camera is started.
 
+## 6.0.4
+Bugs fixed:
+* [Android] Fixed UI jank when `returnImage` is true.
+
 ## 6.0.3
 New features:
 * Adds pause function to pause the camera but keep textures in place.

README.md

@@ -38,6 +38,7 @@ See the example app for detailed implementation information.
 | analyzeImage (Gallery) | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark:   | :x: |
 | returnImage            | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark:   | :x: |
 | scanWindow             | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark:   | :x: |
+| autoZoom               | :heavy_check_mark: | :x: | :x:   | :x: |
 
 ## Platform Support
 

android/build.gradle

@@ -9,7 +9,7 @@ buildscript {
     }
 
     dependencies {
-        classpath 'com.android.tools.build:gradle:8.3.2'
+        classpath 'com.android.tools.build:gradle:8.8.0'
         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
     }
 }
@@ -77,9 +77,10 @@ dependencies {
     // See: https://youtrack.jetbrains.com/issue/KT-55297/kotlin-stdlib-should-declare-constraints-on-kotlin-stdlib-jdk8-and-kotlin-stdlib-jdk7
     implementation(platform("org.jetbrains.kotlin:kotlin-bom:1.8.22"))
 
-    implementation 'androidx.camera:camera-lifecycle:1.3.4'
-    implementation 'androidx.camera:camera-camera2:1.3.4'
+    implementation 'androidx.camera:camera-camera2:1.4.1'
+    implementation 'androidx.camera:camera-lifecycle:1.4.1'
+    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3'
 
     testImplementation 'org.jetbrains.kotlin:kotlin-test'
-    testImplementation 'org.mockito:mockito-core:5.15.2'    
+    testImplementation 'org.mockito:mockito-core:5.15.2'
 }

android/src/main/kotlin/dev/steenbakker/mobile_scanner/MobileScanner.kt

@@ -3,7 +3,11 @@ package dev.steenbakker.mobile_scanner
 import android.app.Activity
 import android.content.Context
 import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.ColorMatrix
+import android.graphics.ColorMatrixColorFilter
 import android.graphics.Matrix
+import android.graphics.Paint
 import android.graphics.Rect
 import android.hardware.display.DisplayManager
 import android.net.Uri
@@ -34,6 +38,10 @@ import dev.steenbakker.mobile_scanner.objects.MobileScannerErrorCodes
 import dev.steenbakker.mobile_scanner.objects.MobileScannerStartParameters
 import dev.steenbakker.mobile_scanner.utils.YuvToRgbConverter
 import io.flutter.view.TextureRegistry
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.launch
 import java.io.ByteArrayOutputStream
 import java.io.IOException
 import kotlin.math.roundToInt
@@ -59,6 +67,7 @@ class MobileScanner(
 
     /// Configurable variables
     var scanWindow: List<Float>? = null
+    private var invertImage: Boolean = false
     private var detectionSpeed: DetectionSpeed = DetectionSpeed.NO_DUPLICATES
     private var detectionTimeout: Long = 250
     private var returnImage = false
@@ -79,7 +88,12 @@ class MobileScanner(
     @ExperimentalGetImage
     val captureOutput = ImageAnalysis.Analyzer { imageProxy -> // YUV_420_888 format
         val mediaImage = imageProxy.image ?: return@Analyzer
-        val inputImage = InputImage.fromMediaImage(mediaImage, imageProxy.imageInfo.rotationDegrees)
+
+        val inputImage = if (invertImage) {
+            invertInputImage(imageProxy)
+        } else {
+            InputImage.fromMediaImage(mediaImage, imageProxy.imageInfo.rotationDegrees)
+        }
 
         if (detectionSpeed == DetectionSpeed.NORMAL && scannerTimeout) {
             imageProxy.close()
@@ -97,6 +111,7 @@ class MobileScanner(
 
                     if (newScannedBarcodes == lastScanned) {
                         // New scanned is duplicate, returning
+                        imageProxy.close()
                         return@addOnSuccessListener
                     }
                     if (newScannedBarcodes.isNotEmpty()) {
@@ -118,45 +133,52 @@ class MobileScanner(
                 }
 
                 if (barcodeMap.isEmpty()) {
+                    imageProxy.close()
                     return@addOnSuccessListener
                 }
 
                 val portrait = (camera?.cameraInfo?.sensorRotationDegrees ?: 0) % 180 == 0
 
                 if (!returnImage) {
+                    imageProxy.close()
                     mobileScannerCallback(
                         barcodeMap,
                         null,
-                        if (portrait) mediaImage.width else mediaImage.height,
-                        if (portrait) mediaImage.height else mediaImage.width)
+                        if (portrait) inputImage.width else inputImage.height,
+                        if (portrait) inputImage.height else inputImage.width)
                     return@addOnSuccessListener
                 }
 
-                val bitmap = Bitmap.createBitmap(mediaImage.width, mediaImage.height, Bitmap.Config.ARGB_8888)
-                val imageFormat = YuvToRgbConverter(activity.applicationContext)
+                CoroutineScope(Dispatchers.IO).launch {
+                    val bitmap = Bitmap.createBitmap(mediaImage.width, mediaImage.height, Bitmap.Config.ARGB_8888)
+                    val imageFormat = YuvToRgbConverter(activity.applicationContext)
 
-                imageFormat.yuvToRgb(mediaImage, bitmap)
+                    imageFormat.yuvToRgb(mediaImage, bitmap)
 
-                val bmResult = rotateBitmap(bitmap, camera?.cameraInfo?.sensorRotationDegrees?.toFloat() ?: 90f)
+                    val bmResult = rotateBitmap(bitmap, camera?.cameraInfo?.sensorRotationDegrees?.toFloat() ?: 90f)
 
-                val stream = ByteArrayOutputStream()
-                bmResult.compress(Bitmap.CompressFormat.PNG, 100, stream)
-                val byteArray = stream.toByteArray()
-                val bmWidth = bmResult.width
-                val bmHeight = bmResult.height
-                bmResult.recycle()
+                    val stream = ByteArrayOutputStream()
+                    bmResult.compress(Bitmap.CompressFormat.PNG, 100, stream)
+                    val byteArray = stream.toByteArray()
+                    val bmWidth = bmResult.width
+                    val bmHeight = bmResult.height
+
+                    bmResult.recycle()
+                    imageProxy.close()
+
+                    mobileScannerCallback(
+                        barcodeMap,
+                        byteArray,
+                        bmWidth,
+                        bmHeight
+                    )
+                }
 
-                mobileScannerCallback(
-                    barcodeMap,
-                    byteArray,
-                    bmWidth,
-                    bmHeight
-                )
             }.addOnFailureListener { e ->
                 mobileScannerErrorCallback(
                     e.localizedMessage ?: e.toString()
                 )
-            }.addOnCompleteListener { imageProxy.close() }
+            }
         }
 
         if (detectionSpeed == DetectionSpeed.NORMAL) {
@@ -219,11 +241,13 @@ class MobileScanner(
         mobileScannerStartedCallback: MobileScannerStartedCallback,
         mobileScannerErrorCallback: (exception: Exception) -> Unit,
         detectionTimeout: Long,
-        cameraResolutionWanted: Size?
+        cameraResolutionWanted: Size?,
+        invertImage: Boolean,
     ) {
         this.detectionSpeed = detectionSpeed
         this.detectionTimeout = detectionTimeout
         this.returnImage = returnImage
+        this.invertImage = invertImage
 
         if (camera?.cameraInfo != null && preview != null && textureEntry != null && !isPaused) {
 
@@ -416,14 +440,14 @@ class MobileScanner(
         isPaused = true
     }
 
-    private fun resumeCamera() {
-        // Resume camera by rebinding use cases
-        cameraProvider?.let { provider ->
-            val owner = activity as LifecycleOwner
-            cameraSelector?.let { provider.bindToLifecycle(owner, it, preview) }
-        }
-        isPaused = false
-    }
+//    private fun resumeCamera() {
+//        // Resume camera by rebinding use cases
+//        cameraProvider?.let { provider ->
+//            val owner = activity as LifecycleOwner
+//            cameraSelector?.let { provider.bindToLifecycle(owner, it, preview) }
+//        }
+//        isPaused = false
+//    }
 
     private fun releaseCamera() {
         if (displayListener != null) {
@@ -472,6 +496,50 @@ class MobileScanner(
         }
     }
 
+    /**
+     * Inverts the image colours respecting the alpha channel
+     */
+    @ExperimentalGetImage
+    fun invertInputImage(imageProxy: ImageProxy): InputImage {
+        val image = imageProxy.image ?: throw IllegalArgumentException("Image is null")
+
+        // Convert YUV_420_888 image to RGB Bitmap
+        val bitmap = Bitmap.createBitmap(image.width, image.height, Bitmap.Config.ARGB_8888)
+        try {
+            val imageFormat = YuvToRgbConverter(activity.applicationContext)
+            imageFormat.yuvToRgb(image, bitmap)
+
+            // Create an inverted bitmap
+            val invertedBitmap = invertBitmapColors(bitmap)
+            imageFormat.release()
+
+            return InputImage.fromBitmap(invertedBitmap, imageProxy.imageInfo.rotationDegrees)
+        } finally {
+            // Release resources
+            bitmap.recycle() // Free up bitmap memory
+            imageProxy.close() // Close ImageProxy
+        }
+    }
+
+    // Efficiently invert bitmap colors using ColorMatrix
+    private fun invertBitmapColors(bitmap: Bitmap): Bitmap {
+        val colorMatrix = ColorMatrix().apply {
+            set(floatArrayOf(
+                -1f, 0f, 0f, 0f, 255f,  // Red
+                0f, -1f, 0f, 0f, 255f,  // Green
+                0f, 0f, -1f, 0f, 255f,  // Blue
+                0f, 0f, 0f, 1f, 0f      // Alpha
+            ))
+        }
+        val paint = Paint().apply { colorFilter = ColorMatrixColorFilter(colorMatrix) }
+
+        val invertedBitmap = Bitmap.createBitmap(bitmap.width, bitmap.height, bitmap.config)
+        val canvas = Canvas(invertedBitmap)
+        canvas.drawBitmap(bitmap, 0f, 0f, paint)
+
+        return invertedBitmap
+    }
+
     /**
      * Analyze a single image.
      */
@@ -517,6 +585,11 @@ class MobileScanner(
         camera?.cameraControl?.setLinearZoom(scale.toFloat())
     }
 
+    fun setZoomRatio(zoomRatio: Double) {
+        if (camera == null) throw ZoomWhenStopped()
+        camera?.cameraControl?.setZoomRatio(zoomRatio.toFloat())
+    }
+
     /**
      * Reset the zoom rate of the camera.
      */