feat: add QR support to scanner to support scanning desktop QRs

bmc08gt · bmc08gt · commit 9885ecfb7e19 · 2026-02-24T11:23:48.000-05:00
Signed-off-by: Brandon McAnsh &lt;git@bmcreations.dev&gt;
diff --git a/apps/flipcash/features/scanner/build.gradle.kts b/apps/flipcash/features/scanner/build.gradle.kts
@@ -58,13 +58,15 @@ dependencies {
     implementation(project(":apps:flipcash:shared:appupdates"))
     implementation(project(":apps:flipcash:shared:bills"))
     implementation(project(":apps:flipcash:shared:bill-customization"))
+    implementation(project(":apps:flipcash:shared:router"))
     implementation(project(":apps:flipcash:shared:session"))
 
+    implementation(project(":libs:code-detection"))
     implementation(project(":libs:datetime"))
     implementation(project(":libs:logging"))
     implementation(project(":libs:messaging"))
     implementation(project(":libs:permissions:bindings"))
-    implementation(project(":ui:analytics"))
+    implementation(project(":libs:vibrator:bindings"))
     implementation(project(":ui:biometrics"))
     implementation(project(":ui:core"))
     implementation(project(":ui:components"))
diff --git a/apps/flipcash/features/scanner/src/main/kotlin/com/flipcash/app/scanner/internal/Scanner.kt b/apps/flipcash/features/scanner/src/main/kotlin/com/flipcash/app/scanner/internal/Scanner.kt
@@ -16,22 +16,29 @@ import androidx.lifecycle.Lifecycle
 import cafe.adriel.voyager.core.registry.ScreenRegistry
 import cafe.adriel.voyager.navigator.currentOrThrow
 import com.flipcash.app.core.navigation.DeeplinkType
+import com.flipcash.app.router.LocalRouter
 import com.flipcash.app.scanner.internal.bills.BillContainer
 import com.flipcash.app.session.LocalSessionController
 import com.flipcash.features.scanner.R
+import com.getcode.libs.code.detection.CodeScanResult
 import com.getcode.manager.BottomBarManager
 import com.getcode.navigation.core.LocalCodeNavigator
 import com.getcode.opencode.model.financial.orZero
 import com.getcode.ui.components.OnLifecycleEvent
 import com.getcode.ui.scanner.CodeScanner
 import com.getcode.ui.scanner.NoCamerasAvailableException
+import com.getcode.util.vibration.LocalVibrator
 import com.getcode.utils.ErrorUtils
+import com.kik.kikx.kikcodes.implementation.KikCodeResult
+import dev.theolm.rinku.DeepLink
+import kotlinx.coroutines.delay
 import timber.log.Timber
 import java.util.Timer
 import kotlin.concurrent.schedule
 
 @Composable
 internal fun Scanner(deepLink: DeeplinkType?) {
+    val router = LocalRouter.currentOrThrow
     val navigator = LocalCodeNavigator.current
     val session = LocalSessionController.currentOrThrow
     val state by session.state.collectAsState()
@@ -58,12 +65,20 @@ internal fun Scanner(deepLink: DeeplinkType?) {
 
     val context = LocalContext.current
 
+    var deepLinkSaved by remember(deepLink) {
+        mutableStateOf(deepLink)
+    }
+
+    val vibrator = LocalVibrator.current
+
     ScannerDeepLinkHandler(
-        deepLink = deepLink,
+        deepLink = deepLinkSaved,
         previewing = previewing,
         session = session,
         navigator = navigator
-    )
+    ) {
+        deepLinkSaved = null
+    }
 
     @SuppressLint("LocalContextGetResourceValueCall")
     BillContainer(
@@ -97,7 +112,24 @@ internal fun Scanner(deepLink: DeeplinkType?) {
                     cameraAvailable = true
                     previewing = it
                 },
-                onCodeScanned = session::onCodeScan,
+                onCodeScanned = { result ->
+                    when (result) {
+                        is CodeScanResult.QrCode -> {
+                            val urls = result.results
+                            val deeplink = urls.firstNotNullOfOrNull { url ->
+                                router.processType(DeepLink(url))
+                            }
+                            println("deeplink type = $deeplink")
+                            if (deeplink != null) {
+                                vibrator.vibrate(duration = 50)
+                                deepLinkSaved = deeplink
+                            }
+                        }
+                        is KikCodeResult -> {
+                            session.onCodeScan(result.kikCode)
+                        }
+                    }
+                },
                 onError = {
                     if (it is NoCamerasAvailableException) {
                         cameraAvailable = false
diff --git a/apps/flipcash/features/scanner/src/main/kotlin/com/flipcash/app/scanner/internal/ScannerDeepLinkHandler.kt b/apps/flipcash/features/scanner/src/main/kotlin/com/flipcash/app/scanner/internal/ScannerDeepLinkHandler.kt
@@ -18,11 +18,9 @@ internal fun ScannerDeepLinkHandler(
     deepLink: DeeplinkType?,
     previewing: Boolean?,
     session: SessionController,
-    navigator: CodeNavigator
+    navigator: CodeNavigator,
+    onDeeplinkHandled: () -> Unit,
 ) {
-    var deepLinkSaved by remember {
-        mutableStateOf(deepLink)
-    }
 
     val focusManager = LocalFocusManager.current
     val biometricsState = LocalBiometricsState.current
@@ -36,7 +34,7 @@ internal fun ScannerDeepLinkHandler(
     LaunchedEffect(
         biometricsState,
         previewing,
-        deepLinkSaved
+        deepLink
     ) {
         if (previewing == true) {
             focusManager.clearFocus()
@@ -48,19 +46,19 @@ internal fun ScannerDeepLinkHandler(
             session.onCameraScanning(previewing)
         }
 
-        val deeplink = deepLinkSaved ?: return@LaunchedEffect
+        val link = deepLink ?: return@LaunchedEffect
 
-        when (deeplink) {
+        when (link) {
             is DeeplinkType.CashLink -> {
-                session.openCashLink(deeplink.entropy)
+                session.openCashLink(link.entropy)
             }
 
             is DeeplinkType.Login -> Unit
             is DeeplinkType.Navigatable -> {
-                stateRestorer.restoreState(deeplink, animationScale)
+                stateRestorer.restoreState(link, animationScale)
             }
         }
 
-        deepLinkSaved = null
+        onDeeplinkHandled()
     }
 }
diff --git a/apps/flipcash/features/scanner/src/main/kotlin/com/flipcash/app/scanner/internal/ScannerQrHandler.kt b/apps/flipcash/features/scanner/src/main/kotlin/com/flipcash/app/scanner/internal/ScannerQrHandler.kt
@@ -0,0 +1,8 @@
+package com.flipcash.app.scanner.internal
+
+import androidx.compose.runtime.Composable
+
+@Composable
+internal fun ScannerQrHandler() {
+
+}
diff --git a/buildSrc/src/main/java/Dependencies.kt b/buildSrc/src/main/java/Dependencies.kt
@@ -54,6 +54,7 @@ object Versions {
     const val crashlytics_gradle: String = "3.0.2"
     const val play_service_auth = "21.4.0"
     const val play_service_auth_phone = "18.3.0"
+    const val play_service_ml_barcode = "18.3.1"
     const val google_play_billing = "8.0.0"
     const val google_play_updates = "2.1.0"
 
@@ -286,6 +287,9 @@ object Libs {
     const val play_service_auth_phone =
         "com.google.android.gms:play-services-auth-api-phone:${Versions.play_service_auth_phone}"
 
+    const val play_service_ml_barcode =
+       "com.google.android.gms:play-services-mlkit-barcode-scanning:${Versions.play_service_ml_barcode}"
+
     const val google_play_billing_runtime =
         "com.android.billingclient:billing:${Versions.google_play_billing}"
     const val google_play_billing_ktx =
diff --git a/libs/code-detection/.gitignore b/libs/code-detection/.gitignore
@@ -0,0 +1,2 @@
+build/
+.gradle/
diff --git a/libs/code-detection/build.gradle.kts b/libs/code-detection/build.gradle.kts
@@ -0,0 +1,48 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
+buildscript {
+    repositories {
+        mavenCentral()
+    }
+    dependencies {
+        classpath(Libs.kotlinx_serialization_json)
+    }
+}
+
+plugins {
+    id(Plugins.android_library)
+    id(Plugins.kotlin_android)
+    id(Plugins.kotlin_kapt)
+    id(Plugins.kotlin_serialization)
+}
+
+android {
+    namespace = "${Gradle.codeNamespace}.libs.code.detection"
+    compileSdk = Android.compileSdkVersion
+    defaultConfig {
+        minSdk = Android.minSdkVersion
+        testInstrumentationRunner = Android.testInstrumentationRunner
+    }
+}
+
+kotlin {
+    jvmToolchain {
+        languageVersion.set(JavaLanguageVersion.of(Versions.java))
+    }
+
+    compilerOptions {
+        jvmTarget.set(JvmTarget.fromTarget(Versions.java))
+        optIn.addAll(
+            "kotlin.time.ExperimentalTime",
+            "kotlin.ExperimentalUnsignedTypes",
+            "kotlin.RequiresOptIn"
+        )
+    }
+}
+
+dependencies {
+    implementation(Libs.inject)
+    implementation(Libs.hilt)
+
+    api(Libs.androidx_camerax_core)
+}
diff --git a/libs/code-detection/src/main/kotlin/com/getcode/libs/code/detection/CodeDetector.kt b/libs/code-detection/src/main/kotlin/com/getcode/libs/code/detection/CodeDetector.kt
@@ -0,0 +1,14 @@
+package com.getcode.libs.code.detection
+
+import androidx.camera.core.ImageProxy
+
+interface CodeScanResult {
+
+    data class QrCode(
+        val results: List<String>,
+    ) : CodeScanResult
+}
+
+interface CodeDetector<T> {
+    suspend fun detect(image: ImageProxy): CodeScanResult?
+}
diff --git a/libs/quickresponse/build.gradle.kts b/libs/quickresponse/build.gradle.kts
@@ -42,12 +42,14 @@ kotlin {
 }
 
 dependencies {
+    implementation(project(":libs:code-detection"))
+
     //Jetpack compose
     implementation(platform(Libs.compose_bom))
     implementation(Libs.compose_ui)
 
-    api(Libs.zxing)
-
+    implementation(Libs.zxing)
+    implementation(Libs.play_service_ml_barcode)
     implementation(Libs.inject)
 
 
diff --git a/libs/quickresponse/src/main/AndroidManifest.xml b/libs/quickresponse/src/main/AndroidManifest.xml
@@ -0,0 +1,9 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <application>
+        <meta-data
+            android:name="com.google.mlkit.vision.DEPENDENCIES"
+            android:value="barcode" />
+    </application>
+
+</manifest>
diff --git a/libs/quickresponse/src/main/kotlin/com/getcode/libs/qr/QRCodeGenerator.kt b/libs/quickresponse/src/main/kotlin/com/getcode/libs/qr/QRCodeGenerator.kt
@@ -2,25 +2,12 @@ package com.getcode.libs.qr
 
 import android.graphics.Bitmap
 import android.graphics.Color
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.graphics.asImageBitmap
-import androidx.compose.ui.graphics.painter.BitmapPainter
-import androidx.compose.ui.platform.LocalDensity
-import androidx.compose.ui.unit.Dp
-import androidx.compose.ui.unit.dp
+import androidx.core.graphics.createBitmap
 import com.google.zxing.BarcodeFormat
 import com.google.zxing.EncodeHintType
 import com.google.zxing.WriterException
 import com.google.zxing.qrcode.QRCodeWriter
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.launch
 import javax.inject.Inject
-import androidx.core.graphics.createBitmap
 
 class QRCodeGenerator @Inject constructor() {
     fun generate(url: String, size: Int): Bitmap? {
diff --git a/libs/quickresponse/src/main/kotlin/com/getcode/libs/qr/QrCodeAnalyzer.kt b/libs/quickresponse/src/main/kotlin/com/getcode/libs/qr/QrCodeAnalyzer.kt
@@ -0,0 +1,100 @@
+package com.getcode.libs.qr
+
+import androidx.annotation.OptIn
+import androidx.camera.core.ExperimentalGetImage
+import androidx.camera.core.ImageProxy
+import com.getcode.libs.code.detection.CodeDetector
+import com.getcode.libs.code.detection.CodeScanResult
+import com.google.mlkit.vision.barcode.BarcodeScannerOptions
+import com.google.mlkit.vision.barcode.BarcodeScanning
+import com.google.mlkit.vision.barcode.common.Barcode
+import com.google.mlkit.vision.common.InputImage
+import kotlinx.coroutines.suspendCancellableCoroutine
+import javax.inject.Inject
+import kotlin.coroutines.resume
+
+class QrCodeAnalyzer @Inject constructor() : CodeDetector<List<String?>> {
+
+    private val scanner = BarcodeScanning.getClient(
+        BarcodeScannerOptions.Builder()
+            .setBarcodeFormats(Barcode.FORMAT_QR_CODE)
+            .build()
+    )
+
+
+    private val recentScans = mutableMapOf<String, Long>()
+    private val debouncePeriod = 3000L
+
+    @OptIn(ExperimentalGetImage::class)
+    override suspend fun detect(
+        image: ImageProxy,
+    ): CodeScanResult? {
+        val imageBytes = image.toNv21Bytes()
+        val inputImage = InputImage.fromByteArray(
+            imageBytes, image.width, image.height, image.imageInfo.rotationDegrees,
+            InputImage.IMAGE_FORMAT_NV21,
+        )
+
+        return suspendCancellableCoroutine { cont ->
+            scanner.process(inputImage)
+                .addOnSuccessListener { barcodes ->
+                    val now = System.currentTimeMillis()
+
+                    val texts = barcodes
+                        .mapNotNull { it.rawValue }
+                        .filter { text ->
+                            val lastSeen = recentScans[text]
+                            val isNew = lastSeen == null || now - lastSeen > debouncePeriod
+                            if (isNew) recentScans[text] = now
+                            isNew
+                        }
+
+                    recentScans.entries.removeAll { now - it.value > debouncePeriod }
+
+                    cont.resume(texts.takeIf { it.isNotEmpty() }?.let(CodeScanResult::QrCode))
+                }
+                .addOnFailureListener {
+                    cont.resume(null)
+                }
+        }
+    }
+}
+
+private fun ImageProxy.toNv21Bytes(): ByteArray {
+    val yPlane = planes[0]
+    val uPlane = planes[1]
+    val vPlane = planes[2]
+
+    val ySize = width * height
+    val uvSize = width * height / 2
+    val nv21 = ByteArray(ySize + uvSize)
+
+    // Y plane — handle row stride padding
+    val yBuffer = yPlane.buffer
+    val yRowStride = yPlane.rowStride
+    if (yRowStride == width) {
+        yBuffer.get(nv21, 0, ySize)
+    } else {
+        for (row in 0 until height) {
+            yBuffer.position(row * yRowStride)
+            yBuffer.get(nv21, row * width, width)
+        }
+    }
+
+    // Interleave V and U for NV21
+    val vBuffer = vPlane.buffer
+    val uBuffer = uPlane.buffer
+    val uvRowStride = vPlane.rowStride
+    val uvPixelStride = vPlane.pixelStride
+
+    var offset = ySize
+    for (row in 0 until height / 2) {
+        for (col in 0 until width / 2) {
+            val bufferIndex = row * uvRowStride + col * uvPixelStride
+            nv21[offset++] = vBuffer.get(bufferIndex)
+            nv21[offset++] = uBuffer.get(bufferIndex)
+        }
+    }
+
+    return nv21
+}
diff --git a/settings.gradle b/settings.gradle
diff --git a/ui/scanner/build.gradle.kts b/ui/scanner/build.gradle.kts
diff --git a/ui/scanner/src/main/kotlin/com/getcode/ui/scanner/CodeScanner.kt b/ui/scanner/src/main/kotlin/com/getcode/ui/scanner/CodeScanner.kt
diff --git a/ui/scanner/src/main/kotlin/com/getcode/ui/scanner/processing/MultiCodeAnalyzer.kt b/ui/scanner/src/main/kotlin/com/getcode/ui/scanner/processing/MultiCodeAnalyzer.kt
diff --git a/vendor/kik/scanner/build.gradle.kts b/vendor/kik/scanner/build.gradle.kts
diff --git a/vendor/kik/scanner/src/main/kotlin/com/kik/kikx/kikcodes/implementation/KikCodeAnalyzer.kt b/vendor/kik/scanner/src/main/kotlin/com/kik/kikx/kikcodes/implementation/KikCodeAnalyzer.kt
