@smileid/usesmileid_huawei_face 12.1.1 → 12.2.0

package/CHANGELOG.md

@@ -1,15 +1,18 @@
 Full release notes: [Smile ID docs](https://docs.usesmileid.com/developer-resources/sdks/mobile/release-notes/react-native-expo).
 
+## 12.2.0
+
+See the repository CHANGELOG for the 12.2.0 release notes.
+
+
 ## 12.1.1
 
 See the repository CHANGELOG for the 12.1.1 release notes.
 
-
 ## 12.1.0
 
 See the repository CHANGELOG for the 12.1.0 release notes.
 
-
 ## 12.0.2
 
 See the repository CHANGELOG for the 12.0.2 release notes.

package/android/build.gradle

@@ -17,7 +17,7 @@ plugins {
 }
 
 group = 'com.usesmileid.huawei.face'
-version = '12.1.1'
+version = '12.2.0'
 
 // HMS ML is published only to Huawei's own Maven repository — none of the
 // com.huawei.hms:ml-computer-vision-* artifacts exist on Maven Central. Expo
@@ -56,7 +56,7 @@ android {
   // android/build.gradle and the rest of the @expo/* modules.
   defaultConfig {
     versionCode 1
-    versionName '12.1.1'
+    versionName '12.2.0'
     // R8 keep-rules to bundle into partner apps that depend on this
     // module. Without these, R8 may rename the Expo module entry
     // point and the JS-bridged member functions, breaking autolinking.
@@ -69,13 +69,13 @@ dependencies {
   // kamera native core: the analyzer executor takes analysis frames from
   // kamera's KameraFrameHub so pixels never cross the JS bridge. Resolves from
   // Maven Central; a local publishToMavenLocal build wins (see kamera.md).
-  implementation 'com.usesmileid:kamera:1.0.6'
+  implementation 'com.usesmileid:kamera:1.1.0'
 
   // Existing Smile ID native AAR — the entire ML pipeline lives here.
   // Targets Huawei AppGallery / no-GMS devices via HMS ML kit. The
   // Expo Module is a thin Kotlin shim that constructs the session
   // and bridges its four methods to JS via Expo Modules.
-  implementation 'com.usesmileid:huawei-face:12.1.1'
+  implementation 'com.usesmileid:huawei-face:12.2.0'
 
 
 }

package/android/src/main/java/com/usesmileid/rn/analyzer/huaweiface/ResizingFrameStorage.kt

@@ -17,9 +17,12 @@ import com.usesmileid.bridge.storage.writeJpegToFileExact
 import com.usesmileid.bridge.util.toArgbBitmap
 import java.io.File
 import java.io.IOException
+import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.ConcurrentLinkedDeque
 import java.util.concurrent.atomic.AtomicReference
+import kotlin.coroutines.cancellation.CancellationException
 import kotlin.math.roundToInt
+import kotlinx.coroutines.CoroutineExceptionHandler
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
@@ -73,20 +76,77 @@ internal class ResizingFrameStorage(
         private const val DOCUMENT_MAX_DIMENSION = 1600
 
         /**
-         * Outward padding fraction applied to the guide-rect crop on each side
-         * before cropping. Fifteen percent of the box's own width/height keeps
-         * the document's corners and edges from being clipped when the card is
-         * framed tight against the on-screen guide.
+         * The hidden border kept around the guide rect: this fraction of the
+         * saved image's short side on every edge, the rule of the native
+         * bridges' `DocumentCropGeometry.DOCUMENT_BORDER_FRACTION` and the
+         * selfie's interior crop. The border is where presentation-attack cues
+         * live; the backend reads it, and the preview shows only the interior.
          */
-        private const val DOCUMENT_CROP_PADDING_FRACTION = 0.15f
+        internal const val DOCUMENT_BORDER_FRACTION = 0.15f
+
+        /**
+         * The uniform border, in pixels, to grow a [left], [top], [right],
+         * [bottom] guide by: the b that is [DOCUMENT_BORDER_FRACTION] of the
+         * grown rect's own short side, b = f × s / (1 − 2f) for the guide's
+         * short side s. Shrinks to the most every edge of a [width] × [height]
+         * image can hold; 0 for an empty guide or one touching an edge.
+         * Mirrors the native bridges' `DocumentCropGeometry.borderAround`.
+         */
+        internal fun borderAround(left: Float, top: Float, right: Float, bottom: Float, width: Int, height: Int): Float {
+            val shortSide = minOf(right - left, bottom - top)
+            if (shortSide <= 0f) return 0f
+            val wanted = DOCUMENT_BORDER_FRACTION * shortSide / (1f - 2f * DOCUMENT_BORDER_FRACTION)
+            val room = minOf(left, top, width - right, height - bottom)
+            return minOf(wanted, room).coerceAtLeast(0f)
+        }
+
+        /**
+         * A [border] of pixels around a [width] × [height] crop as a fraction of the
+         * crop's short side, held to [DOCUMENT_BORDER_FRACTION] so the crop's pixel
+         * rounding never reports more border than was kept; 0 for an empty crop.
+         */
+        internal fun borderFraction(border: Float, width: Int, height: Int): Float {
+            val shortSide = minOf(width, height)
+            if (shortSide <= 0) return 0f
+            return (border / shortSide).coerceIn(0f, DOCUMENT_BORDER_FRACTION)
+        }
     }
 
-    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+    /** A backstop for anything that escapes the write's own catch; [flush] still surfaces it. */
+    private val scope = CoroutineScope(
+        SupervisorJob() + Dispatchers.IO + CoroutineExceptionHandler { _, e -> firstError.compareAndSet(null, e) },
+    )
     private val pending = ConcurrentLinkedDeque<Job>()
     private val firstError = AtomicReference<Throwable?>(null)
 
+    /** Read back as [FrameStorage.cropRegion], which the document transitioner judges the detected document against. */
     @Volatile
-    private var cropRegion: NativeViewportCropRegion? = null
+    override var cropRegion: NativeViewportCropRegion? = null
+        private set
+
+    /**
+     * The hidden border of each document this storage saved with one, by absolute
+     * path, as a fraction of the document's short side. Written on the encode scope
+     * once the file is written, read after [flush].
+     */
+    private val savedBorderFractions = ConcurrentHashMap<String, Float>()
+
+    /**
+     * The hidden border the document at [file] was saved with, as a fraction of its
+     * short side on every edge: [DOCUMENT_BORDER_FRACTION] when the frame had room for
+     * all of it, less where it did not, and 0 for a document saved without a guide
+     * crop or a file this storage did not write. The screens that show the document
+     * hide exactly this much.
+     */
+    fun borderFractionOf(file: File): Float = savedBorderFractions[file.absolutePath] ?: 0f
+
+    private fun recordBorder(file: File, borderFraction: Float) {
+        if (borderFraction > 0f) {
+            savedBorderFractions[file.absolutePath] = borderFraction
+        } else {
+            savedBorderFractions.remove(file.absolutePath)
+        }
+    }
 
     override fun setCropRegion(region: NativeViewportCropRegion?) {
         cropRegion = region
@@ -100,6 +160,7 @@ internal class ResizingFrameStorage(
             FrameKind.Document -> when (documentSide) {
                 DocumentSide.Front -> "document_front.jpg"
                 DocumentSide.Back -> "document_back.jpg"
+                DocumentSide.Visa -> "document_visa.jpg"
             }
         },
     )
@@ -120,9 +181,15 @@ internal class ResizingFrameStorage(
         val job = scope.launch {
             try {
                 encodeAndWrite(frame, file, documentCropRegion)
-            } catch (throwable: Throwable) {
-                firstError.compareAndSet(null, throwable)
-                throw throwable
+            } catch (e: CancellationException) {
+                runCatching { file.delete() }
+                recordBorder(file, 0f)
+                throw e
+            } catch (e: Throwable) {
+                runCatching { file.delete() }
+                recordBorder(file, 0f)
+                // Surfaced by flush; a rethrow here would reach the host's uncaught handler.
+                firstError.compareAndSet(null, e)
             }
         }
         // Add synchronously so flush() cannot race past an in-flight job.
@@ -140,7 +207,10 @@ internal class ResizingFrameStorage(
         // Selfie and document captures share one session directory; delete
         // only this role's own frames.
         sessionDirectory.listFiles()?.forEach { file ->
-            if (ownsForClear(file)) file.delete()
+            if (ownsForClear(file)) {
+                file.delete()
+                recordBorder(file, 0f)
+            }
         }
     }
 
@@ -195,16 +265,23 @@ internal class ResizingFrameStorage(
                     // the whole frame, so a tightly framed card fills the saved pixels.
                     // toFrameBoundingBox returns a normalized 0–1 box in the upright
                     // frame's coordinate space, mapped to pixels by the bitmap dimensions.
-                    // The box is padded outward by DOCUMENT_CROP_PADDING_FRACTION of its
-                    // own size on each side so the document's corners and edges keep
-                    // breathing room and are never clipped when the card is framed tight
-                    // against the guide.
+                    // The box grows by the hidden border (DOCUMENT_BORDER_FRACTION of the
+                    // saved image's short side, uniform on every edge), which the preview
+                    // never shows, so it shows what the user framed.
                     val source = frame.toArgbBitmap(jpegQuality = documentQuality)
                         ?: throw IOException("toArgbBitmap returned null for ${file.name}")
-                    val cropped = if (documentCropRegion != null) {
+                    val (cropped, borderFraction) = if (documentCropRegion != null) {
                         val box = documentCropRegion.toFrameBoundingBox(source.width, source.height)
-                        val padX = box.width * DOCUMENT_CROP_PADDING_FRACTION
-                        val padY = box.height * DOCUMENT_CROP_PADDING_FRACTION
+                        val border = borderAround(
+                            box.left * source.width,
+                            box.top * source.height,
+                            (box.left + box.width) * source.width,
+                            (box.top + box.height) * source.height,
+                            source.width,
+                            source.height,
+                        )
+                        val padX = border / source.width
+                        val padY = border / source.height
                         // Clamp left/top to leave room for at least one pixel and derive
                         // right/bottom from the clamped left/top so the crop never runs past
                         // the bitmap edge. Bitmap.createBitmap throws IllegalArgumentException
@@ -217,9 +294,10 @@ internal class ResizingFrameStorage(
                         val pixelBottom = ((box.top + box.height + padY) * source.height).roundToInt().coerceIn(pixelTop + 1, source.height)
                         val cropWidth = (pixelRight - pixelLeft).coerceAtLeast(1)
                         val cropHeight = (pixelBottom - pixelTop).coerceAtLeast(1)
-                        android.graphics.Bitmap.createBitmap(source, pixelLeft, pixelTop, cropWidth, cropHeight)
+                        android.graphics.Bitmap.createBitmap(source, pixelLeft, pixelTop, cropWidth, cropHeight) to
+                            borderFraction(border, cropWidth, cropHeight)
                     } else {
-                        source
+                        source to 0f
                     }
                     // Downscale the crop so its longest edge is at most
                     // DOCUMENT_MAX_DIMENSION, preserving aspect ratio. Skip when the crop
@@ -238,6 +316,7 @@ internal class ResizingFrameStorage(
                             scaled.compress(android.graphics.Bitmap.CompressFormat.JPEG, documentQuality, it)
                         }
                         if (!success) throw IOException("Bitmap.compress(JPEG) failed for ${file.absolutePath}")
+                        recordBorder(file, borderFraction)
                     } finally {
                         if (scaled !== cropped) scaled.recycle()
                         if (cropped !== source) cropped.recycle()

package/android/src/main/java/com/usesmileid/rn/analyzer/huaweiface/UseSmileIDAnalyzerExecutor.kt

@@ -56,6 +56,13 @@ abstract class UseSmileIDAnalyzerExecutor<
     protected var session: Session? = null
     private var storageRoot: File? = null
 
+    /**
+     * The latest session's storage, read by [handleDocumentBorderFraction] after `flush`. Written by
+     * `configure` on the executor's IO scope and read on the module's async-function thread.
+     */
+    @Volatile
+    private var storage: ResizingFrameStorage? = null
+
     /**
      * Scope used for all `analyze` / `flush` work. Bound to `Dispatchers.IO`
      * + a `SupervisorJob` so a single failed frame analysis doesn't poison
@@ -192,11 +199,29 @@ abstract class UseSmileIDAnalyzerExecutor<
         // clean-up policies can prune them.
         val sessionDir = freshSessionDirectory()
         val storage = buildResizingFrameStorage(sessionDir, storageDocumentSide(config), config as? Map<*, *>)
+        this.storage = storage
         val newSession = createSession(config, storage)
         session = newSession
         onSessionCreated(newSession)
     }
 
+    /**
+     * Implementation behind `documentBorderFraction`: the hidden border the document at [url], a
+     * `file://` URL or a path, was saved with, as a fraction of its short side; 0 for a file the
+     * latest session's storage did not write with one.
+     */
+    fun handleDocumentBorderFraction(url: String): Double {
+        val file = try {
+            if (url.startsWith("file:")) File(java.net.URI(url)) else File(url)
+        } catch (e: java.net.URISyntaxException) {
+            return 0.0
+        } catch (e: IllegalArgumentException) {
+            // Not a hierarchical file: URL.
+            return 0.0
+        }
+        return storage?.borderFractionOf(file)?.toDouble() ?: 0.0
+    }
+
     /**
      * Implementation behind `flush`. Same dispatcher hopping discipline;
      * a missing session is treated as a successful

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smileid/usesmileid_huawei_face",
-  "version": "12.1.1",
+  "version": "12.2.0",
   "description": "Huawei HMS face detection implementation for the UseSmileID React Native (Expo) SDK.",
   "homepage": "https://usesmileid.com",
   "repository": {
@@ -44,8 +44,8 @@
     "CHANGELOG.md"
   ],
   "dependencies": {
-    "@smileid/usesmileid_bridge": "12.1.1",
-    "@smileid/usesmileid_platform_interface": "12.1.1"
+    "@smileid/usesmileid_bridge": "12.2.0",
+    "@smileid/usesmileid_platform_interface": "12.2.0"
   },
   "peerDependencies": {
     "expo": ">=56.0.0",
@@ -53,7 +53,7 @@
     "react-native": ">=0.83.0"
   },
   "devDependencies": {
-    "expo-modules-core": "^57.0.16",
+    "expo-modules-core": "^57.0.19",
     "react-native": "^0.86.3",
     "typescript": "^6.0.3"
   },