@trustchex/react-native-sdk 1.512.1 → 1.513.0

package/android/src/main/java/com/trustchex/reactnativesdk/camera/TrustchexCameraView.kt

@@ -414,8 +414,15 @@ class TrustchexCameraView(context: ThemedReactContext) : FrameLayout(context) {
             // 3. Process at lower resolution (720x1280 portrait) for real-time detection
             // 4. Use ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST for frame dropping
             // 5. Close ImageProxy immediately after ML Kit processing completes
-            val hasAnyDetection = frameProcessingEnabled && (faceDetectionEnabled || textRecognitionEnabled || barcodeScanningEnabled)
-            if (!hasAnyDetection) {
+            // Emit a frame when EITHER a detector is enabled OR the JS side just
+            // wants the image (includeBase64). The latter lets a screen do a
+            // manual still capture without paying for a per-frame ML Kit pass it
+            // never reads. With no detector the `tasks` list below is empty and
+            // the frame event carries brightness + base64 only.
+            val wantsFrame = frameProcessingEnabled &&
+                (faceDetectionEnabled || textRecognitionEnabled ||
+                    barcodeScanningEnabled || includeBase64)
+            if (!wantsFrame) {
                 isProcessing.set(false)
                 imageProxy.close()
                 return

package/android/src/main/java/com/trustchex/reactnativesdk/opencv/OpenCVModule.kt

@@ -1022,6 +1022,60 @@ class OpenCVModule(reactContext: ReactApplicationContext) : ReactContextBaseJava
         }
     }
 
+    /**
+     * Downscale + JPEG-recompress an image, for shrinking diagnostic uploads.
+     *
+     * The scan captures full-resolution frames; bundling several of them as
+     * base64 into one diagnostic POST produces a multi-MB body that is slow to
+     * JSON-stringify on the JS thread and slow to upload. These images are only
+     * for a support inbox, so full resolution is wasteful. This scales the image
+     * down so its longest edge is at most `maxDim` (never upscales) and re-encodes
+     * JPEG at `quality` (0-100), typically cutting the payload 5-20x.
+     *
+     * Runs on a background thread (decode/encode of a large bitmap is heavy).
+     * Best-effort: on any failure it resolves the ORIGINAL base64 so the report
+     * still sends — a slower upload is better than a dropped diagnostic.
+     *
+     * @param base64Image Base64 JPEG/PNG (no data-URI prefix)
+     * @param maxDim      Longest-edge cap in pixels (e.g. 1024)
+     * @param quality     JPEG quality 0-100 (e.g. 70)
+     * @param promise     Returns the shrunk base64 JPEG (or the original on failure)
+     */
+    @ReactMethod
+    fun resizeAndCompress(base64Image: String, maxDim: Int, quality: Int, promise: Promise) {
+        Thread {
+            try {
+                val bytes = Base64.decode(base64Image, Base64.NO_WRAP)
+                val src = BitmapFactory.decodeByteArray(bytes, 0, bytes.size)
+                if (src == null) {
+                    promise.resolve(base64Image)
+                    return@Thread
+                }
+
+                val longest = maxOf(src.width, src.height)
+                // Only downscale; never enlarge a small image.
+                val scale = if (maxDim > 0 && longest > maxDim) maxDim.toDouble() / longest else 1.0
+                val scaled = if (scale < 1.0) {
+                    val w = (src.width * scale).toInt().coerceAtLeast(1)
+                    val h = (src.height * scale).toInt().coerceAtLeast(1)
+                    Bitmap.createScaledBitmap(src, w, h, true)
+                } else {
+                    src
+                }
+
+                val stream = ByteArrayOutputStream()
+                scaled.compress(Bitmap.CompressFormat.JPEG, quality.coerceIn(1, 100), stream)
+                if (scaled !== src) scaled.recycle()
+                src.recycle()
+
+                promise.resolve(Base64.encodeToString(stream.toByteArray(), Base64.NO_WRAP))
+            } catch (e: Exception) {
+                // Fall back to the original so the report still uploads.
+                promise.resolve(base64Image)
+            }
+        }.start()
+    }
+
     private fun base64ToMat(base64: String): Mat? {
         return try {
             val bytes = Base64.decode(base64, Base64.NO_WRAP)

package/ios/Camera/TrustchexCameraView.swift

@@ -808,8 +808,12 @@ extension TrustchexCameraView: AVCaptureVideoDataOutputSampleBufferDelegate {
 
     func captureOutput(_ output: AVCaptureOutput, didOutput sampleBuffer: CMSampleBuffer, from connection: AVCaptureConnection) {
         autoreleasepool {
-            let hasAnyDetection = _frameProcessingEnabled && (enableFaceDetection || enableTextRecognition || enableBarcodeScanning)
-            guard hasAnyDetection else { return }
+            // Emit a frame when EITHER a detector is enabled OR the JS side just
+            // wants the image (includeBase64). The latter lets a screen do a
+            // manual still capture without paying for a per-frame ML Kit pass it
+            // never reads.
+            let wantsFrame = _frameProcessingEnabled && (enableFaceDetection || enableTextRecognition || enableBarcodeScanning || includeBase64)
+            guard wantsFrame else { return }
             
             // Check flag on videoQueue (serial) to prevent re-entry
             guard !isProcessing else { return }

package/ios/OpenCV/OpenCVModule.mm

@@ -88,6 +88,65 @@ RCT_EXPORT_MODULE();
     return image;
 }
 
+/**
+ * Downscale + JPEG-recompress an image, for shrinking diagnostic uploads.
+ *
+ * The scan captures full-resolution frames; bundling several as base64 into one
+ * diagnostic POST produces a multi-MB body that is slow to JSON-stringify on the
+ * JS thread and slow to upload. These images are only for a support inbox, so
+ * full resolution is wasteful. This scales the image down so its longest edge is
+ * at most `maxDim` (never upscales) and re-encodes JPEG at `quality` (0-100),
+ * typically cutting the payload 5-20x.
+ *
+ * Runs on a background queue (decode/encode of a large image is heavy).
+ * Best-effort: on any failure it resolves the ORIGINAL base64 so the report
+ * still sends — a slower upload beats a dropped diagnostic.
+ */
+RCT_EXPORT_METHOD(resizeAndCompress:(NSString *)base64Image
+                  maxDim:(NSInteger)maxDim
+                  quality:(NSInteger)quality
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    @try {
+        UIImage *src = [self base64ToImage:base64Image];
+        if (!src) {
+            resolve(base64Image);
+            return;
+        }
+
+        CGFloat w = src.size.width;
+        CGFloat h = src.size.height;
+        CGFloat longest = MAX(w, h);
+        // Only downscale; never enlarge a small image.
+        CGFloat scale = (maxDim > 0 && longest > maxDim) ? (CGFloat)maxDim / longest : 1.0;
+
+        UIImage *scaled = src;
+        if (scale < 1.0) {
+            CGSize newSize = CGSizeMake(MAX(1.0, w * scale), MAX(1.0, h * scale));
+            UIGraphicsImageRendererFormat *fmt = [UIGraphicsImageRendererFormat defaultFormat];
+            fmt.scale = 1.0; // pixels, not points — avoid Retina 2x/3x inflation
+            fmt.opaque = YES;
+            UIGraphicsImageRenderer *renderer = [[UIGraphicsImageRenderer alloc] initWithSize:newSize format:fmt];
+            scaled = [renderer imageWithActions:^(UIGraphicsImageRendererContext *_Nonnull ctx) {
+                [src drawInRect:CGRectMake(0, 0, newSize.width, newSize.height)];
+            }];
+        }
+
+        CGFloat q = MIN(1.0, MAX(0.01, (CGFloat)quality / 100.0));
+        NSData *jpeg = UIImageJPEGRepresentation(scaled, q);
+        if (!jpeg) {
+            resolve(base64Image);
+            return;
+        }
+        resolve([jpeg base64EncodedStringWithOptions:0]);
+    } @catch (NSException *exception) {
+        // Fall back to the original so the report still uploads.
+        resolve(base64Image);
+    }
+    });
+}
+
 RCT_EXPORT_METHOD(cropFaceImages:(NSString *)base64Image
                   faceBounds:(NSArray *)faceBounds
                   imageWidth:(NSInteger)imageWidth