cordova-plugin-mlkit-suite 0.1.0 → 0.2.0

package/src/android/java/SubjectSegmentationModuleInstaller.java

@@ -0,0 +1,154 @@
+package com.andreszs.plugins.mlkitsuite;
+
+import android.app.Activity;
+
+import com.google.android.gms.common.moduleinstall.InstallStatusListener;
+import com.google.android.gms.common.moduleinstall.ModuleInstall;
+import com.google.android.gms.common.moduleinstall.ModuleInstallClient;
+import com.google.android.gms.common.moduleinstall.ModuleInstallRequest;
+import com.google.android.gms.common.moduleinstall.ModuleInstallStatusCodes;
+import com.google.android.gms.common.moduleinstall.ModuleInstallStatusUpdate;
+import com.google.mlkit.vision.segmentation.subject.SubjectSegmentation;
+import com.google.mlkit.vision.segmentation.subject.SubjectSegmenter;
+import com.google.mlkit.vision.segmentation.subject.SubjectSegmenterOptions;
+
+import org.json.JSONObject;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+
+final class SubjectSegmentationModuleInstaller {
+    interface Callback {
+        void onReady(JSONObject result);
+        void onError(JSONObject error);
+    }
+
+    interface AvailabilityCallback {
+        void onResult(Boolean ready);
+    }
+
+    private SubjectSegmentationModuleInstaller() { }
+
+    static void checkAvailability(Activity activity, AvailabilityCallback callback) {
+        SubjectSegmenter segmenter = segmenter();
+        ModuleInstall.getClient(activity).areModulesAvailable(segmenter)
+            .addOnSuccessListener(response -> {
+                segmenter.close();
+                callback.onResult(response.areModulesAvailable());
+            })
+            .addOnFailureListener(error -> {
+                segmenter.close();
+                callback.onResult(null);
+            });
+    }
+
+    static void prepare(Activity activity, String loadingMessage,
+                        MlKitLocalization localization, Callback callback) {
+        SubjectSegmenter segmenter = segmenter();
+        ModuleInstallClient client = ModuleInstall.getClient(activity);
+        client.areModulesAvailable(segmenter)
+            .addOnSuccessListener(response -> {
+                if (response.areModulesAvailable()) {
+                    segmenter.close();
+                    callback.onReady(readyResult(true));
+                } else {
+                    MlKitLoadingDialog loadingDialog = new MlKitLoadingDialog(
+                        activity, loadingMessage
+                    );
+                    loadingDialog.show();
+                    install(client, segmenter, loadingDialog, localization, callback);
+                }
+            })
+            .addOnFailureListener(error -> {
+                segmenter.close();
+                callback.onError(MlKitSuitePlugin.error(
+                    "MODULE_UNAVAILABLE",
+                    localization.text("subject_check_failed"),
+                    true
+                ));
+            });
+    }
+
+    private static SubjectSegmenter segmenter() {
+        return SubjectSegmentation.getClient(
+            new SubjectSegmenterOptions.Builder().enableForegroundBitmap().build()
+        );
+    }
+
+    private static void install(ModuleInstallClient client, SubjectSegmenter segmenter,
+                                MlKitLoadingDialog loadingDialog,
+                                MlKitLocalization localization, Callback callback) {
+        AtomicBoolean finished = new AtomicBoolean(false);
+        InstallStatusListener[] listenerHolder = new InstallStatusListener[1];
+        listenerHolder[0] = update -> {
+            int state = update.getInstallState();
+            if (state == ModuleInstallStatusUpdate.InstallState.STATE_COMPLETED) {
+                finishSuccess(
+                    client, listenerHolder[0], segmenter, loadingDialog, callback, finished, false
+                );
+            } else if (state == ModuleInstallStatusUpdate.InstallState.STATE_CANCELED) {
+                finishError(
+                    client, listenerHolder[0], segmenter, loadingDialog, callback, finished,
+                    "MODULE_DOWNLOAD_CANCELLED",
+                    localization.text("subject_download_cancelled")
+                );
+            } else if (state == ModuleInstallStatusUpdate.InstallState.STATE_FAILED) {
+                String status = ModuleInstallStatusCodes.getStatusCodeString(update.getErrorCode());
+                finishError(
+                    client, listenerHolder[0], segmenter, loadingDialog, callback, finished,
+                    "MODULE_DOWNLOAD_FAILED",
+                    localization.format("subject_download_failed", status)
+                );
+            }
+        };
+
+        ModuleInstallRequest request = ModuleInstallRequest.newBuilder()
+            .addApi(segmenter)
+            .setListener(listenerHolder[0])
+            .build();
+        client.installModules(request)
+            .addOnSuccessListener(response -> {
+                if (response.areModulesAlreadyInstalled()) {
+                    finishSuccess(
+                        client, listenerHolder[0], segmenter, loadingDialog,
+                        callback, finished, true
+                    );
+                }
+            })
+            .addOnFailureListener(error -> finishError(
+                client, listenerHolder[0], segmenter, loadingDialog, callback, finished,
+                "MODULE_DOWNLOAD_FAILED",
+                localization.text("subject_download_start_failed")
+            ));
+    }
+
+    private static void finishSuccess(ModuleInstallClient client, InstallStatusListener listener,
+                                      SubjectSegmenter segmenter,
+                                      MlKitLoadingDialog loadingDialog, Callback callback,
+                                      AtomicBoolean finished, boolean alreadyAvailable) {
+        if (!finished.compareAndSet(false, true)) return;
+        client.unregisterListener(listener);
+        loadingDialog.dismiss();
+        segmenter.close();
+        callback.onReady(readyResult(alreadyAvailable));
+    }
+
+    private static void finishError(ModuleInstallClient client, InstallStatusListener listener,
+                                    SubjectSegmenter segmenter,
+                                    MlKitLoadingDialog loadingDialog, Callback callback,
+                                    AtomicBoolean finished, String code, String message) {
+        if (!finished.compareAndSet(false, true)) return;
+        client.unregisterListener(listener);
+        loadingDialog.dismiss();
+        segmenter.close();
+        callback.onError(MlKitSuitePlugin.error(code, message, true));
+    }
+
+    private static JSONObject readyResult(boolean alreadyAvailable) {
+        JSONObject result = new JSONObject();
+        try {
+            result.put("status", "ready");
+            result.put("alreadyAvailable", alreadyAvailable);
+        } catch (Exception ignored) { }
+        return result;
+    }
+}

package/src/android/java/SubjectSegmentationProcessor.java

@@ -0,0 +1,189 @@
+package com.andreszs.plugins.mlkitsuite;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.Matrix;
+import android.net.Uri;
+
+import androidx.exifinterface.media.ExifInterface;
+
+import com.google.mlkit.vision.common.InputImage;
+import com.google.mlkit.vision.segmentation.subject.SubjectSegmentation;
+import com.google.mlkit.vision.segmentation.subject.SubjectSegmenter;
+import com.google.mlkit.vision.segmentation.subject.SubjectSegmenterOptions;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.InputStream;
+import java.util.UUID;
+import java.util.concurrent.Executor;
+
+final class SubjectSegmentationProcessor {
+    interface Callback {
+        void onSuccess(Result result);
+        void onFailure(String code, String message, boolean recoverable);
+    }
+
+    static final class Result {
+        final File file;
+        final int width;
+        final int height;
+
+        Result(File file, int width, int height) {
+            this.file = file;
+            this.width = width;
+            this.height = height;
+        }
+    }
+
+    private SubjectSegmentationProcessor() { }
+
+    static void process(Context context, String rawPath, File cacheDirectory, int maxDimension,
+                        Executor callbackExecutor, MlKitLocalization localization,
+                        Callback callback) {
+        final Bitmap source;
+        try {
+            Uri uri = StaticImageProcessor.resolveUri(rawPath, cacheDirectory);
+            source = loadOrientedBitmap(context, uri, maxDimension);
+        } catch (Exception exception) {
+            callback.onFailure("INVALID_IMAGE", localization.text("image_open_failed"), false);
+            return;
+        }
+
+        SubjectSegmenterOptions options = new SubjectSegmenterOptions.Builder()
+            .enableForegroundBitmap()
+            .build();
+        SubjectSegmenter segmenter = SubjectSegmentation.getClient(options);
+        segmenter.process(InputImage.fromBitmap(source, 0))
+            .addOnSuccessListener(callbackExecutor, result -> {
+                Bitmap foreground = result.getForegroundBitmap();
+                try {
+                    if (foreground == null) {
+                        throw new IllegalStateException("ML Kit returned no foreground bitmap.");
+                    }
+                    callback.onSuccess(writePng(foreground, cacheDirectory));
+                } catch (Exception exception) {
+                    callback.onFailure(
+                        "PROCESSING_FAILED",
+                        localization.text("subject_segmentation_failed"),
+                        true
+                    );
+                } finally {
+                    if (foreground != null && foreground != source) foreground.recycle();
+                    source.recycle();
+                    segmenter.close();
+                }
+            })
+            .addOnFailureListener(callbackExecutor, error -> {
+                source.recycle();
+                segmenter.close();
+                callback.onFailure(
+                    "PROCESSING_FAILED",
+                    localization.text("subject_segmentation_failed"),
+                    true
+                );
+            });
+    }
+
+    private static Result writePng(Bitmap bitmap, File directory) throws Exception {
+        if (!directory.exists() && !directory.mkdirs()) {
+            throw new IllegalStateException("Unable to create the image cache directory.");
+        }
+        File destination = new File(
+            directory,
+            "subject-" + UUID.randomUUID().toString().toLowerCase() + ".png"
+        );
+        try (FileOutputStream stream = new FileOutputStream(destination)) {
+            if (!bitmap.compress(Bitmap.CompressFormat.PNG, 100, stream)) {
+                throw new IllegalStateException("Unable to encode the segmented PNG.");
+            }
+        }
+        return new Result(destination, bitmap.getWidth(), bitmap.getHeight());
+    }
+
+    private static Bitmap loadOrientedBitmap(Context context, Uri uri, int maxDimension)
+        throws Exception {
+        BitmapFactory.Options bounds = new BitmapFactory.Options();
+        bounds.inJustDecodeBounds = true;
+        try (InputStream stream = context.getContentResolver().openInputStream(uri)) {
+            if (stream == null) throw new IllegalStateException("Unable to open image.");
+            BitmapFactory.decodeStream(stream, null, bounds);
+        }
+        int sampleSize = 1;
+        int largestBound = Math.max(bounds.outWidth, bounds.outHeight);
+        while (largestBound > 0 && largestBound / sampleSize > maxDimension * 2) {
+            sampleSize *= 2;
+        }
+        BitmapFactory.Options decodeOptions = new BitmapFactory.Options();
+        decodeOptions.inSampleSize = sampleSize;
+        decodeOptions.inPreferredConfig = Bitmap.Config.ARGB_8888;
+
+        Bitmap raw;
+        try (InputStream stream = context.getContentResolver().openInputStream(uri)) {
+            if (stream == null) throw new IllegalStateException("Unable to open image.");
+            raw = BitmapFactory.decodeStream(stream, null, decodeOptions);
+        }
+        if (raw == null) throw new IllegalStateException("Unable to decode image.");
+
+        int orientation = ExifInterface.ORIENTATION_NORMAL;
+        try (InputStream stream = context.getContentResolver().openInputStream(uri)) {
+            if (stream != null) {
+                orientation = new ExifInterface(stream).getAttributeInt(
+                    ExifInterface.TAG_ORIENTATION,
+                    ExifInterface.ORIENTATION_NORMAL
+                );
+            }
+        } catch (Exception ignored) { }
+
+        Matrix matrix = orientationMatrix(orientation);
+        Bitmap oriented = Bitmap.createBitmap(
+            raw, 0, 0, raw.getWidth(), raw.getHeight(), matrix, true
+        );
+        if (oriented != raw) raw.recycle();
+
+        int largest = Math.max(oriented.getWidth(), oriented.getHeight());
+        if (largest <= maxDimension) return oriented;
+        float scale = maxDimension / (float) largest;
+        Bitmap resized = Bitmap.createScaledBitmap(
+            oriented,
+            Math.max(1, Math.round(oriented.getWidth() * scale)),
+            Math.max(1, Math.round(oriented.getHeight() * scale)),
+            true
+        );
+        if (resized != oriented) oriented.recycle();
+        return resized;
+    }
+
+    private static Matrix orientationMatrix(int orientation) {
+        Matrix matrix = new Matrix();
+        switch (orientation) {
+            case ExifInterface.ORIENTATION_FLIP_HORIZONTAL:
+                matrix.postScale(-1f, 1f);
+                break;
+            case ExifInterface.ORIENTATION_ROTATE_180:
+                matrix.postRotate(180f);
+                break;
+            case ExifInterface.ORIENTATION_FLIP_VERTICAL:
+                matrix.postScale(1f, -1f);
+                break;
+            case ExifInterface.ORIENTATION_TRANSPOSE:
+                matrix.postRotate(90f);
+                matrix.postScale(-1f, 1f);
+                break;
+            case ExifInterface.ORIENTATION_ROTATE_90:
+                matrix.postRotate(90f);
+                break;
+            case ExifInterface.ORIENTATION_TRANSVERSE:
+                matrix.postRotate(-90f);
+                matrix.postScale(-1f, 1f);
+                break;
+            case ExifInterface.ORIENTATION_ROTATE_270:
+                matrix.postRotate(-90f);
+                break;
+            default:
+                break;
+        }
+        return matrix;
+    }
+}

package/src/android/mlkit-suite.gradle

@@ -106,10 +106,28 @@ def readModuleMode = { String variableName ->
 def faceMode = readModuleMode('ANDROID_MLKIT_FACE_MODE')
 def barcodeMode = readModuleMode('ANDROID_MLKIT_BARCODE_MODE')
 def ocrMode = readModuleMode('ANDROID_MLKIT_OCR_MODE')
+def imageLabelingMode = readModuleMode('ANDROID_MLKIT_IMAGE_LABELING_MODE')
+def rawSubjectSegmentationMode = mlKitSuiteReadPluginVariable(
+    'ANDROID_MLKIT_SUBJECT_SEGMENTATION_MODE', 'inherit'
+)
+def subjectSegmentationMode = rawSubjectSegmentationMode == null
+    || rawSubjectSegmentationMode.trim().isEmpty()
+    || rawSubjectSegmentationMode.equalsIgnoreCase('inherit')
+        ? (defaultMode == 'bundled' ? 'install-time' : defaultMode)
+        : mlKitSuiteNormalizeMode(
+            rawSubjectSegmentationMode, 'ANDROID_MLKIT_SUBJECT_SEGMENTATION_MODE'
+        )
+if (subjectSegmentationMode == 'bundled') {
+    throw new GradleException(
+        'cordova-plugin-mlkit-suite: Subject Segmentation only supports install-time or first-use.'
+    )
+}
 def installTimeModules = []
 if (faceMode == 'install-time') installTimeModules.add('face')
 if (barcodeMode == 'install-time') installTimeModules.add('barcode')
 if (ocrMode == 'install-time') installTimeModules.add('ocr')
+if (imageLabelingMode == 'install-time') installTimeModules.add('ica')
+if (subjectSegmentationMode == 'install-time') installTimeModules.add('subject_segment')
 
 if (cordovaConfig.MIN_SDK_VERSION < 24) {
     cordovaConfig.MIN_SDK_VERSION = 24
@@ -135,6 +153,9 @@ logger.lifecycle(
     "Face ${faceMode} (${faceMode == 'bundled' ? mlKitFaceVersion : '17.1.0'}), " +
     "Barcode ${barcodeMode} (${barcodeMode == 'bundled' ? '17.2.0' : '18.3.1'}), " +
     "OCR ${ocrMode} (${ocrMode == 'bundled' ? '16.0.1' : '19.0.1'}), " +
+    "Image Labeling ${imageLabelingMode} (${imageLabelingMode == 'bundled' ? '17.0.9' : '16.0.8'}), " +
+    "Selfie Segmentation bundled (16.0.0-beta6), " +
+    "Subject Segmentation ${subjectSegmentationMode} (16.0.0-beta1), " +
     'Document Scanner 16.0.0'
 )
 
@@ -143,6 +164,8 @@ android {
         manifestPlaceholders.mlKitSuiteFaceMode = faceMode
         manifestPlaceholders.mlKitSuiteBarcodeMode = barcodeMode
         manifestPlaceholders.mlKitSuiteOcrMode = ocrMode
+        manifestPlaceholders.mlKitSuiteImageLabelingMode = imageLabelingMode
+        manifestPlaceholders.mlKitSuiteSubjectSegmentationMode = subjectSegmentationMode
         if (!installTimeModules.isEmpty()) {
             manifestPlaceholders.mlKitSuiteDependencyMetadataName =
                 'com.google.mlkit.vision.DEPENDENCIES'
@@ -181,7 +204,14 @@ dependencies {
     } else {
         implementation 'com.google.android.gms:play-services-mlkit-text-recognition:19.0.1'
     }
+    if (imageLabelingMode == 'bundled') {
+        implementation 'com.google.mlkit:image-labeling:17.0.9'
+    } else {
+        implementation 'com.google.android.gms:play-services-mlkit-image-labeling:16.0.8'
+    }
     implementation 'com.google.android.gms:play-services-mlkit-document-scanner:16.0.0'
+    implementation 'com.google.mlkit:segmentation-selfie:16.0.0-beta6'
+    implementation 'com.google.android.gms:play-services-mlkit-subject-segmentation:16.0.0-beta1'
     compileOnly "androidx.webkit:webkit:${webKitByCordova[cordovaAndroidMajor]}"
 }
 

package/src/android/res/values/mlkit_suite_strings.xml

@@ -43,6 +43,7 @@
     <string name="mlkit_suite_barcode_searching">Looking for a barcode</string>
     <string name="mlkit_suite_barcode_center">Center the barcode inside the frame</string>
     <string name="mlkit_suite_barcode_detected">Detected %1$s — hold steady (%2$d/%3$d)</string>
+    <string name="mlkit_suite_barcode_success">Code detected</string>
     <string name="mlkit_suite_barcode_analyze_failed">Unable to analyze the camera image</string>
     <string name="mlkit_suite_barcode_timeout">No barcode was confirmed before the timeout.</string>
     <string name="mlkit_suite_barcode_cancelled">Barcode scanning was cancelled by the user.</string>
@@ -68,6 +69,13 @@
     <string name="mlkit_suite_image_open_failed">Unable to open imagePath.</string>
     <string name="mlkit_suite_text_recognition_failed">Unable to recognize text in the image.</string>
     <string name="mlkit_suite_barcode_image_failed">Unable to scan barcodes in the image.</string>
+    <string name="mlkit_suite_image_labeling_failed">Unable to label the image.</string>
+    <string name="mlkit_suite_selfie_segmentation_failed">Unable to segment the person in the image.</string>
+    <string name="mlkit_suite_subject_segmentation_failed">Unable to segment the subjects in the image.</string>
+    <string name="mlkit_suite_subject_check_failed">Unable to check the Subject Segmentation module.</string>
+    <string name="mlkit_suite_subject_download_cancelled">Subject Segmentation module download was cancelled.</string>
+    <string name="mlkit_suite_subject_download_failed">Unable to download the Subject Segmentation module (%1$s).</string>
+    <string name="mlkit_suite_subject_download_start_failed">Unable to start the Subject Segmentation module download.</string>
     <string name="mlkit_suite_camera_permission_denied">Camera permission was denied.</string>
     <string name="mlkit_suite_busy">Another interactive ML Kit session is already active.</string>
 </resources>

package/src/android/res/values-es/mlkit_suite_strings.xml

@@ -43,6 +43,7 @@
     <string name="mlkit_suite_barcode_searching">Buscando un código</string>
     <string name="mlkit_suite_barcode_center">Centrá el código dentro del recuadro</string>
     <string name="mlkit_suite_barcode_detected">%1$s detectado — mantené firme (%2$d/%3$d)</string>
+    <string name="mlkit_suite_barcode_success">Código detectado</string>
     <string name="mlkit_suite_barcode_analyze_failed">No se pudo analizar la imagen de la cámara</string>
     <string name="mlkit_suite_barcode_timeout">No se confirmó ningún código antes de agotar el tiempo.</string>
     <string name="mlkit_suite_barcode_cancelled">El usuario canceló el escaneo de códigos.</string>
@@ -68,6 +69,13 @@
     <string name="mlkit_suite_image_open_failed">No se pudo abrir imagePath.</string>
     <string name="mlkit_suite_text_recognition_failed">No se pudo reconocer texto en la imagen.</string>
     <string name="mlkit_suite_barcode_image_failed">No se pudieron detectar códigos en la imagen.</string>
+    <string name="mlkit_suite_image_labeling_failed">No se pudo clasificar la imagen.</string>
+    <string name="mlkit_suite_selfie_segmentation_failed">No se pudo segmentar la persona en la imagen.</string>
+    <string name="mlkit_suite_subject_segmentation_failed">No se pudieron segmentar los sujetos de la imagen.</string>
+    <string name="mlkit_suite_subject_check_failed">No se pudo verificar el módulo de segmentación de sujetos.</string>
+    <string name="mlkit_suite_subject_download_cancelled">Se canceló la descarga del módulo de segmentación de sujetos.</string>
+    <string name="mlkit_suite_subject_download_failed">No se pudo descargar el módulo de segmentación de sujetos (%1$s).</string>
+    <string name="mlkit_suite_subject_download_start_failed">No se pudo iniciar la descarga del módulo de segmentación de sujetos.</string>
     <string name="mlkit_suite_camera_permission_denied">Se denegó el permiso de cámara.</string>
     <string name="mlkit_suite_busy">Ya hay otra sesión interactiva de ML Kit activa.</string>
 </resources>

package/src/ios/BarcodeOverlayView.swift

@@ -5,6 +5,12 @@ final class BarcodeOverlayView: UIView {
     private let guideColor: UIColor?
     private var message: String
     private var candidateVisible = false
+    private var successVisible = false
+    private var displayedGuide: CGRect?
+    private var animationStart = CGRect.zero
+    private var animationTarget = CGRect.zero
+    private var animationStartedAt: CFTimeInterval = 0
+    private var displayLink: CADisplayLink?
 
     init(instruction: String, guideColor: UIColor?, initialMessage: String) {
         self.instruction = instruction
@@ -27,23 +33,60 @@ final class BarcodeOverlayView: UIView {
     }
 
     func contains(barcodeFrame: CGRect, imageSize: CGSize) -> Bool {
+        guard let mapped = mappedFrame(barcodeFrame, imageSize: imageSize) else { return false }
+        return guideRect(in: bounds).contains(mapped)
+    }
+
+    func showSuccess(barcodeFrame: CGRect, imageSize: CGSize, message: String) {
+        let initial = guideRect(in: bounds)
+        let mapped = mappedFrame(barcodeFrame, imageSize: imageSize) ?? initial
+        let padded = mapped.insetBy(dx: -10, dy: -10).intersection(bounds)
+        animationStart = initial
+        animationTarget = padded.isNull || padded.isEmpty ? initial : padded
+        displayedGuide = initial
+        self.message = message
+        candidateVisible = true
+        successVisible = true
+        displayLink?.invalidate()
+        animationStartedAt = CACurrentMediaTime()
+        let link = CADisplayLink(target: self, selector: #selector(advanceSuccessAnimation(_:)))
+        link.add(to: .main, forMode: .common)
+        displayLink = link
+        setNeedsDisplay()
+    }
+
+    private func mappedFrame(_ barcodeFrame: CGRect, imageSize: CGSize) -> CGRect? {
         guard imageSize.width > 0, imageSize.height > 0, !barcodeFrame.isNull,
-              !barcodeFrame.isEmpty else { return false }
-        let guide = guideRect(in: bounds)
+              !barcodeFrame.isEmpty else { return nil }
         let scale = max(bounds.width / imageSize.width, bounds.height / imageSize.height)
         let offsetX = (bounds.width - imageSize.width * scale) / 2
         let offsetY = (bounds.height - imageSize.height * scale) / 2
-        let mapped = CGRect(
+        return CGRect(
             x: barcodeFrame.minX * scale + offsetX,
             y: barcodeFrame.minY * scale + offsetY,
             width: barcodeFrame.width * scale,
             height: barcodeFrame.height * scale
         )
-        return guide.contains(mapped)
+    }
+
+    @objc private func advanceSuccessAnimation(_ link: CADisplayLink) {
+        let progress = min(1, max(0, (CACurrentMediaTime() - animationStartedAt) / 0.22))
+        let eased = 1 - pow(1 - CGFloat(progress), 3)
+        displayedGuide = CGRect(
+            x: interpolate(animationStart.minX, animationTarget.minX, eased),
+            y: interpolate(animationStart.minY, animationTarget.minY, eased),
+            width: interpolate(animationStart.width, animationTarget.width, eased),
+            height: interpolate(animationStart.height, animationTarget.height, eased)
+        )
+        setNeedsDisplay()
+        if progress >= 1 {
+            link.invalidate()
+            displayLink = nil
+        }
     }
 
     override func draw(_ rect: CGRect) {
-        let guide = guideRect(in: rect)
+        let guide = successVisible ? (displayedGuide ?? guideRect(in: rect)) : guideRect(in: rect)
 
         let shade = UIBezierPath(rect: rect)
         shade.append(UIBezierPath(roundedRect: guide, cornerRadius: 18))
@@ -67,7 +110,7 @@ final class BarcodeOverlayView: UIView {
             ])
         }
 
-        if !instruction.isEmpty {
+        if !successVisible && !instruction.isEmpty {
             drawCentered(
                 instruction,
                 in: CGRect(x: 20, y: max(42, guide.minY - 64), width: rect.width - 40, height: 48),
@@ -139,4 +182,12 @@ final class BarcodeOverlayView: UIView {
             ]
         )
     }
+
+    private func interpolate(_ start: CGFloat, _ end: CGFloat, _ progress: CGFloat) -> CGFloat {
+        start + (end - start) * progress
+    }
+
+    deinit {
+        displayLink?.invalidate()
+    }
 }

package/src/ios/BarcodeScanTypes.swift

@@ -81,6 +81,7 @@ struct BarcodeScanOptions {
     let formats: BarcodeFormat
     let showCloseButton: Bool
     let showTorchButton: Bool
+    let beepEnabled: Bool
     let instructionText: String
     let localization: MlKitLocalization
     let guideColor: UIColor?
@@ -90,7 +91,7 @@ struct BarcodeScanOptions {
         localization = try MlKitLocalization(dictionary: dictionary)
         let known = Set([
             "formats", "showCloseButton", "showTorchButton", "instructionText",
-            "guideColor", "timeoutMs", "moduleLoadingMessage", "locale"
+            "guideColor", "beepEnabled", "timeoutMs", "moduleLoadingMessage", "locale"
         ])
         for key in dictionary.keys where !known.contains(key) {
             throw MlKitSuiteError.invalidArgument("Unknown barcode scan option: \(key).")
@@ -124,6 +125,7 @@ struct BarcodeScanOptions {
         formats = try BarcodeFormatSupport.parse(dictionary["formats"])
         showCloseButton = try boolean("showCloseButton", fallback: true)
         showTorchButton = try boolean("showTorchButton", fallback: true)
+        beepEnabled = try boolean("beepEnabled", fallback: true)
         timeoutMs = try integer("timeoutMs", fallback: 0, minimum: 0, maximum: 600_000)
         if let raw = dictionary["instructionText"], !(raw is NSNull) {
             guard let string = raw as? String else {