Merge pull request #12 from tillhub/develop

v.1.4.3

Author: shekar-allam

sample/src/main/java/de/tillhub/scanengine/sample/MainActivity.kt

@@ -12,65 +12,55 @@ import androidx.compose.material3.Button
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.unit.dp
-import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.lifecycleScope
-import androidx.lifecycle.repeatOnLifecycle
 import de.tillhub.scanengine.ScanEngine
 import de.tillhub.scanengine.ScanEvent
+import de.tillhub.scanengine.Scanner
 import de.tillhub.scanengine.sample.ui.theme.TillhubScanEngineTheme
 import kotlinx.coroutines.launch
 
 class MainActivity : ComponentActivity() {
 
-    private val scanner by lazy { ScanEngine.getInstance(this).attach(this.lifecycle) }
-    private val scanCode = mutableStateOf("")
-
+    private val scanEngine by lazy { ScanEngine.getInstance(applicationContext) }
+    private lateinit var scanner: Scanner
+    private var scanCode = mutableStateOf("")
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
-        lifecycleScope.launch {
-            lifecycle.repeatOnLifecycle(Lifecycle.State.CREATED) {
-                scanner.observeScannerResults()
-                    .collect {
-                        scanCode.value = (it as? ScanEvent.Success)?.value.orEmpty()
-                    }
-            }
-        }
-
+        scanner = scanEngine.newCameraScanner(this).build(this.lifecycle)
         setContent {
             TillhubScanEngineTheme {
                 Surface(
                     modifier = Modifier.fillMaxSize(),
                     color = MaterialTheme.colorScheme.background
                 ) {
-                    Greeting(scanCode.value) {
-                        scanner.startCameraScanner("key")
+                    Column(
+                        modifier = Modifier.fillMaxSize(),
+                        verticalArrangement = Arrangement.Center,
+                        horizontalAlignment = Alignment.CenterHorizontally
+                    ) {
+                        Text(text = scanCode.value)
+                        Spacer(modifier = Modifier.height(36.dp))
+                        Button(
+                            onClick = {
+                                scanner.startCameraScanner("key")
+                            }
+                        ) {
+                            Text(text = "Start camera scanner")
+                        }
                     }
                 }
             }
         }
-    }
-}
+        scanEngine.barcodeScanner.scanWithKey("key")
 
-@Composable
-fun Greeting(value: String, onClick: () -> Unit) {
-    Column(
-        modifier = Modifier.fillMaxSize(),
-        verticalArrangement = Arrangement.Center,
-        horizontalAlignment = Alignment.CenterHorizontally
-    ) {
-        Text(
-            text = value
-        )
-        Spacer(modifier = Modifier.height(36.dp))
-        Button(
-            onClick = onClick
-        ) {
-            Text(text = "Start camera scanner")
+        lifecycleScope.launch {
+            scanEngine.observeScannerResults().collect {
+                scanCode.value = (it as? ScanEvent.Success)?.value.orEmpty()
+            }
         }
     }
 }

scan-engine/build.gradle.kts

@@ -80,7 +80,7 @@ afterEvaluate {
             create<MavenPublication>("scan-engine") {
                 groupId = "de.tillhub.scanengine"
                 artifactId = "scan-engine"
-                version = "1.4.2"
+                version = "1.4.3"
 
                 from(components.getByName("release"))
             }

scan-engine/src/main/AndroidManifest.xml

@@ -12,7 +12,6 @@
         <activity
             android:name="de.tillhub.scanengine.default.ui.GoogleScanningActivity"
             android:exported="false"
-            android:theme="@style/Theme.AppCompat.Light.NoActionBar"
             />
     </application>
 

scan-engine/src/main/java/de/tillhub/scanengine/ScanEngine.kt

@@ -1,24 +1,51 @@
 package de.tillhub.scanengine
 
 import SingletonHolder
+import android.content.Context
 import androidx.activity.ComponentActivity
 import androidx.lifecycle.Lifecycle
+import de.tillhub.scanengine.barcode.BarcodeScanner
+import de.tillhub.scanengine.barcode.DefaultBarcodeScanner
+import de.tillhub.scanengine.barcode.SunmiBarcodeScanner
 import de.tillhub.scanengine.default.DefaultScanner
+import de.tillhub.scanengine.helper.ManagerBuilder
 import de.tillhub.scanengine.sunmi.SunmiScanner
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.SharedFlow
 
-class ScanEngine private constructor(activity: ComponentActivity) {
+class ScanEngine private constructor(context: Context) {
 
-    private val scanner: Scanner by lazy {
-        when (ScannerManufacturer.get()) {
-            ScannerManufacturer.SUNMI -> SunmiScanner(activity)
-            ScannerManufacturer.OTHER -> DefaultScanner(activity)
+    private val mutableScanEvents = MutableSharedFlow<ScanEvent>(extraBufferCapacity = 1)
+    fun observeScannerResults(): SharedFlow<ScanEvent> = mutableScanEvents
+
+    fun newCameraScanner(activity: ComponentActivity): ManagerBuilder<Scanner> {
+        return object : ManagerBuilder<Scanner> {
+            override fun build(lifecycle: Lifecycle): Scanner {
+                return when (ScannerManufacturer.get()) {
+                    ScannerManufacturer.SUNMI -> SunmiScanner(
+                        activity.activityResultRegistry,
+                        activity.savedStateRegistry,
+                        mutableScanEvents
+                    )
+
+                    ScannerManufacturer.OTHER -> DefaultScanner(
+                        activity.activityResultRegistry,
+                        activity.savedStateRegistry,
+                        mutableScanEvents
+                    )
+                }.also {
+                    lifecycle.addObserver(it)
+                }
+            }
         }
     }
 
-    fun attach(lifecycle: Lifecycle): Scanner {
-        lifecycle.addObserver(scanner)
-        return scanner
+    val barcodeScanner: BarcodeScanner by lazy {
+        when (ScannerManufacturer.get()) {
+            ScannerManufacturer.SUNMI -> SunmiBarcodeScanner(context, mutableScanEvents)
+            ScannerManufacturer.OTHER -> DefaultBarcodeScanner(context, mutableScanEvents)
+        }
     }
 
-    companion object : SingletonHolder<ScanEngine, ComponentActivity>(::ScanEngine)
+    companion object : SingletonHolder<ScanEngine, Context>(::ScanEngine)
 }

scan-engine/src/main/java/de/tillhub/scanengine/ScanEventProvider.kt

@@ -4,27 +4,13 @@ import androidx.lifecycle.DefaultLifecycleObserver
 import androidx.savedstate.SavedStateRegistry
 import kotlinx.coroutines.flow.SharedFlow
 
-/**
- * Used for connecting and disconnecting a scanner, issue scan commands and observing scanned codes.
- */
 interface Scanner : DefaultLifecycleObserver, SavedStateRegistry.SavedStateProvider {
-
-    /**
-     * Can be used to observe any scanned code.
-     */
     fun observeScannerResults(): SharedFlow<ScanEvent>
-
-    /**
-     * Start the camera based scanner.
-     */
     fun startCameraScanner(scanKey: String? = null)
 
-    /**
-     * Scan with next key
-     */
-    fun scanNextWithKey(scanKey: String?)
-
     companion object {
+        const val PROVIDER = "scanner"
+        const val SCAN_KEY = "scan_key"
         const val CAMERA_SCANNER_KEY = "CAMERA_SCANNER_KEY"
     }
 }

scan-engine/src/main/java/de/tillhub/scanengine/Scanner.kt

@@ -0,0 +1,38 @@
+package de.tillhub.scanengine
+
+import android.os.Bundle
+import androidx.core.os.bundleOf
+import androidx.lifecycle.LifecycleOwner
+import androidx.savedstate.SavedStateRegistry
+import de.tillhub.scanengine.Scanner.Companion.PROVIDER
+import de.tillhub.scanengine.Scanner.Companion.SCAN_KEY
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.SharedFlow
+
+abstract class ScannerImpl(
+    private val savedStateRegistry: SavedStateRegistry,
+    protected val mutableScanEvents: MutableSharedFlow<ScanEvent>
+) : Scanner {
+
+    protected var scanKey: String? = null
+    override fun onCreate(owner: LifecycleOwner) {
+        super.onCreate(owner)
+        if (savedStateRegistry.getSavedStateProvider(PROVIDER) == null) {
+            savedStateRegistry.registerSavedStateProvider(PROVIDER, this)
+        } else {
+            scanKey = savedStateRegistry.consumeRestoredStateForKey(PROVIDER)
+                ?.getString(SCAN_KEY)
+        }
+    }
+
+    override fun saveState(): Bundle {
+        return bundleOf(SCAN_KEY to scanKey)
+    }
+
+    override fun onDestroy(owner: LifecycleOwner) {
+        super.onDestroy(owner)
+        savedStateRegistry.unregisterSavedStateProvider(PROVIDER)
+    }
+
+    override fun observeScannerResults(): SharedFlow<ScanEvent> = mutableScanEvents
+}

scan-engine/src/main/java/de/tillhub/scanengine/ScannerImpl.kt

@@ -0,0 +1,9 @@
+package de.tillhub.scanengine.barcode
+
+import de.tillhub.scanengine.ScanEvent
+import kotlinx.coroutines.flow.Flow
+
+interface BarcodeScanner {
+    fun observeScannerResults(): Flow<ScanEvent>
+    fun scanWithKey(scanKey: String? = null)
+}

scan-engine/src/main/java/de/tillhub/scanengine/barcode/BarcodeScanner.kt

@@ -0,0 +1,16 @@
+package de.tillhub.scanengine.barcode
+
+import de.tillhub.scanengine.ScanEvent
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableSharedFlow
+
+abstract class BarcodeScannerImpl(protected val mutableScanEvents: MutableSharedFlow<ScanEvent>) : BarcodeScanner {
+
+    protected var scanKey: String? = null
+
+    override fun observeScannerResults(): Flow<ScanEvent> = mutableScanEvents
+
+    override fun scanWithKey(scanKey: String?) {
+        this.scanKey = scanKey
+    }
+}

scan-engine/src/main/java/de/tillhub/scanengine/barcode/BarcodeScannerImpl.kt

@@ -0,0 +1,10 @@
+package de.tillhub.scanengine.barcode
+
+import android.content.Context
+import de.tillhub.scanengine.ScanEvent
+import kotlinx.coroutines.flow.MutableSharedFlow
+
+class DefaultBarcodeScanner(
+    context: Context,
+    mutableScanEvents: MutableSharedFlow<ScanEvent>
+) : BarcodeScannerImpl(mutableScanEvents)