@mleonard9/vin-scanner 0.1.1

package/README.md

@@ -0,0 +1,110 @@
+
+<div align="center">
+
+# @mleonard9/vin-scanner
+
+High-performance VIN detection for React Native powered by Google ML Kit barcode + text recognition and `react-native-vision-camera`.
+
+</div>
+
+## Requirements
+
+- `react-native-vision-camera` >= 3.9.0
+- `react-native-worklets-core` >= 0.4.0
+- iOS 13+ / Android 21+
+
+## Installation
+
+```sh
+yarn add @mleonard9/vin-scanner
+# or
+npm install @mleonard9/vin-scanner
+
+# iOS
+cd ios && pod install
+```
+
+## Usage
+
+```tsx
+import React, { useMemo, useState } from 'react';
+import { StyleSheet, View } from 'react-native';
+import { useCameraDevice } from 'react-native-vision-camera';
+import { Camera as VinScannerCamera } from '@mleonard9/vin-scanner';
+
+export function VinScannerExample(): JSX.Element {
+  const device = useCameraDevice('back');
+  const [results, setResults] = useState([]);
+
+  const options = useMemo(
+    () => ({
+      barcode: { formats: ['code-39', 'code-128', 'pdf-417'] },
+      text: { language: 'latin' },
+      detection: { resultMode: 'all' as const },
+    }),
+    []
+  );
+
+  if (device == null) {
+    return null;
+  }
+
+  return (
+    <View style={StyleSheet.absoluteFill}>
+      <VinScannerCamera
+        style={StyleSheet.absoluteFill}
+        device={device}
+        options={options}
+        callback={(event) => {
+          setResults(event.candidates);
+        }}
+      />
+    </View>
+  );
+}
+```
+
+Every frame, the camera runs ML Kit barcode + text recognition, extracts 17-character VIN candidates, validates them (including the optional checksum), and routes a payload to `callback`.
+
+### Callback payload
+
+```ts
+type VinScannerEvent = {
+  mode: 'best' | 'all';
+  timestamp: number;
+  best?: VinCandidate | null;
+  candidates: VinCandidate[];
+  raw: {
+    barcodes: BarcodeDetection[];
+    textBlocks: TextDetection[];
+  };
+};
+```
+
+`VinCandidate` contains `{ value, source: 'barcode' | 'text', confidence, boundingBox }`.  
+`resultMode === 'best'` returns at most one candidate per frame, while `'all'` returns every candidate so you can render overlays/selectors.
+
+### Options
+
+| Path | Type | Description | Default |
+| --- | --- | --- | --- |
+| `options.barcode.enabled` | boolean | Enable barcode scanning | `true` |
+| `options.barcode.formats` | `BarcodeFormat[]` | Restrict ML Kit formats (`'code-39'`, `'code-128'`, `'pdf-417'`, etc.) | `['all']` |
+| `options.text.enabled` | boolean | Enable text recognition | `true` |
+| `options.text.language` | `'latin' \| 'chinese' \| 'devanagari' \| 'japanese' \| 'korean'` | ML Kit language pack | `'latin'` |
+| `options.detection.resultMode` | `'best' \| 'all'` | Emit a single best VIN or every candidate | `'best'` |
+| `options.detection.preferBarcode` | boolean | Prefer barcode hits when selecting the best VIN | `true` |
+| `options.detection.validateChecksum` | boolean | Run VIN checksum validation | `true` |
+| `options.detection.emitDuplicates` | boolean | Emit unchanged payloads every frame | `false` for `'best'`, `true` for `'all'` |
+
+## Publishing (internal use)
+
+This package is scoped (`@mleonard9/vin-scanner`) and marked as `access: restricted`. To release a new build:
+
+```sh
+yarn prepare   # builds /lib via bob
+npm publish --access restricted
+```
+
+Ensure the authenticated npm user has access to the `@mleonard9` scope.
+

package/android/build.gradle

@@ -0,0 +1,102 @@
+buildscript {
+  // Buildscript is evaluated before everything else so we can't use getExtOrDefault
+  def kotlin_version = rootProject.ext.has("kotlinVersion") ? rootProject.ext.get("kotlinVersion") : project.properties["VisionCameraBarcodeScanner_kotlinVersion"]
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:7.2.1"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+  }
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["VisionCameraBarcodeScanner_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["VisionCameraBarcodeScanner_" + name]).toInteger()
+}
+
+def supportsNamespace() {
+  def parsed = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
+  def major = parsed[0].toInteger()
+  def minor = parsed[1].toInteger()
+
+  // Namespace support was added in 7.3.0
+  return (major == 7 && minor >= 3) || major >= 8
+}
+
+android {
+  if (supportsNamespace()) {
+    namespace "com.visioncamerabarcodescanner"
+
+    sourceSets {
+      main {
+        manifest.srcFile "src/main/AndroidManifestNew.xml"
+      }
+    }
+  }
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  // For < 0.71, this will be from the local maven repo
+  // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
+  //noinspection GradleDynamicVersion
+  implementation "com.facebook.react:react-native:+"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  implementation 'com.google.mlkit:barcode-scanning:17.2.0'
+  implementation 'com.google.mlkit:text-recognition:16.0.0'
+  implementation 'com.google.mlkit:text-recognition-chinese:16.0.0'
+  implementation 'com.google.mlkit:text-recognition-devanagari:16.0.0'
+  implementation 'com.google.mlkit:text-recognition-japanese:16.0.0'
+  implementation 'com.google.mlkit:text-recognition-korean:16.0.0'
+  implementation project(':react-native-vision-camera')
+  implementation "androidx.camera:camera-core:1.1.0"
+}
+

package/android/gradle.properties

@@ -0,0 +1,5 @@
+VisionCameraBarcodeScanner_kotlinVersion=1.7.0
+VisionCameraBarcodeScanner_minSdkVersion=21
+VisionCameraBarcodeScanner_targetSdkVersion=31
+VisionCameraBarcodeScanner_compileSdkVersion=31
+VisionCameraBarcodeScanner_ndkversion=21.4.7075529

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,8 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.visioncamerabarcodescanner">
+  <application>
+    <meta-data
+      android:name="com.google.mlkit.vision.DEPENDENCIES"
+      android:value="barcode" />
+  </application>
+</manifest>

package/android/src/main/AndroidManifestNew.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/java/com/visioncamerabarcodescanner/VisionCameraBarcodeScannerModule.kt

@@ -0,0 +1,93 @@
+package com.visioncamerabarcodescanner
+
+import android.media.Image
+import com.facebook.react.bridge.WritableNativeArray
+import com.facebook.react.bridge.WritableNativeMap
+import com.google.android.gms.tasks.Task
+import com.google.android.gms.tasks.Tasks
+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.barcode.common.Barcode.FORMAT_ALL_FORMATS
+import com.google.mlkit.vision.barcode.common.Barcode.FORMAT_AZTEC
+import com.google.mlkit.vision.barcode.common.Barcode.FORMAT_CODABAR
+import com.google.mlkit.vision.barcode.common.Barcode.FORMAT_CODE_128
+import com.google.mlkit.vision.barcode.common.Barcode.FORMAT_CODE_39
+import com.google.mlkit.vision.barcode.common.Barcode.FORMAT_CODE_93
+import com.google.mlkit.vision.barcode.common.Barcode.FORMAT_DATA_MATRIX
+import com.google.mlkit.vision.barcode.common.Barcode.FORMAT_ITF
+import com.google.mlkit.vision.barcode.common.Barcode.FORMAT_PDF417
+import com.google.mlkit.vision.barcode.common.Barcode.FORMAT_QR_CODE
+import com.google.mlkit.vision.barcode.common.Barcode.FORMAT_UPC_A
+import com.google.mlkit.vision.barcode.common.Barcode.FORMAT_UPC_E
+import com.google.mlkit.vision.barcode.common.Barcode.FORMAT_EAN_8
+import com.google.mlkit.vision.barcode.common.Barcode.FORMAT_EAN_13
+import com.google.mlkit.vision.common.InputImage
+import com.mrousavy.camera.frameprocessors.Frame
+import com.mrousavy.camera.frameprocessors.FrameProcessorPlugin
+import com.mrousavy.camera.frameprocessors.VisionCameraProxy
+
+class VisionCameraBarcodeScannerModule(proxy : VisionCameraProxy, options: Map<String, Any>?): FrameProcessorPlugin() {
+
+  override fun callback(frame: Frame, arguments: Map<String, Any>?): Any {
+    try {
+     val optionsBuilder = BarcodeScannerOptions.Builder()
+      if (arguments?.get("code-128").toString().toBoolean()) optionsBuilder.setBarcodeFormats(FORMAT_CODE_128)
+      else if (arguments?.get("code-39").toString().toBoolean()) optionsBuilder.setBarcodeFormats(FORMAT_CODE_39)
+      else if (arguments?.get("code-93").toString().toBoolean()) optionsBuilder.setBarcodeFormats(FORMAT_CODE_93)
+      else if (arguments?.get("codabar").toString().toBoolean()) optionsBuilder.setBarcodeFormats(FORMAT_CODABAR)
+      else if (arguments?.get("ean-13").toString().toBoolean()) optionsBuilder.setBarcodeFormats(FORMAT_EAN_13)
+      else if (arguments?.get("ean-8").toString().toBoolean()) optionsBuilder.setBarcodeFormats(FORMAT_EAN_8)
+      else if (arguments?.get("itf").toString().toBoolean()) optionsBuilder.setBarcodeFormats(FORMAT_ITF)
+      else if (arguments?.get("upc-e").toString().toBoolean()) optionsBuilder.setBarcodeFormats(FORMAT_UPC_E)
+      else if (arguments?.get("upc-a").toString().toBoolean()) optionsBuilder.setBarcodeFormats(FORMAT_UPC_A)
+      else if (arguments?.get("qr").toString().toBoolean()) optionsBuilder.setBarcodeFormats(FORMAT_QR_CODE)
+      else if (arguments?.get("pdf-417").toString().toBoolean()) optionsBuilder.setBarcodeFormats(FORMAT_PDF417)
+      else if (arguments?.get("aztec").toString().toBoolean()) optionsBuilder.setBarcodeFormats(FORMAT_AZTEC)
+      else if (arguments?.get("data-matrix").toString().toBoolean()) optionsBuilder.setBarcodeFormats(FORMAT_DATA_MATRIX)
+      else if (arguments?.get("all").toString().toBoolean()) optionsBuilder.setBarcodeFormats(FORMAT_ALL_FORMATS)
+      else optionsBuilder.setBarcodeFormats(FORMAT_ALL_FORMATS)
+
+      val scanner = BarcodeScanning.getClient(optionsBuilder.build())
+      val mediaImage: Image = frame.image
+      val image = InputImage.fromMediaImage(mediaImage, frame.imageProxy.imageInfo.rotationDegrees)
+      val task: Task<List<Barcode>> = scanner.process(image)
+      val barcodes: List<Barcode> = Tasks.await(task)
+      val array = WritableNativeArray()
+      for (barcode in barcodes) {
+        val map = WritableNativeMap()
+        val bounds = barcode.boundingBox
+        if (bounds != null) {
+          map.putInt("width",bounds.width())
+          map.putInt("height",bounds.height())
+          map.putInt("top",bounds.top)
+          map.putInt("bottom",bounds.bottom)
+          map.putInt("left",bounds.left)
+          map.putInt("right",bounds.right)
+        }
+        val rawValue = barcode.rawValue
+        map.putString("rawValue",rawValue)
+        val valueType = barcode.valueType
+        when (valueType) {
+          Barcode.TYPE_WIFI -> {
+            val ssid = barcode.wifi!!.ssid
+            map.putString("ssid",ssid)
+            val password = barcode.wifi!!.password
+            map.putString("password",password)
+          }
+          Barcode.TYPE_URL -> {
+            val title = barcode.url!!.title
+            map.putString("title",title)
+            val url = barcode.url!!.url
+            map.putString("url",url)
+          }
+        }
+        array.pushMap(map)
+      }
+      return array.toArrayList()
+    } catch (e: Exception) {
+       throw  Exception("Error processing barcode scanner: $e ")
+    }
+  }
+
+}

package/android/src/main/java/com/visioncamerabarcodescanner/VisionCameraBarcodeScannerPackage.kt

@@ -0,0 +1,27 @@
+package com.visioncamerabarcodescanner
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+import com.mrousavy.camera.frameprocessors.FrameProcessorPluginRegistry
+import com.visioncameratextrecognition.VisionCameraTextRecognitionModule
+
+class VisionCameraBarcodeScannerPackage : ReactPackage {
+  companion object {
+    init {
+      FrameProcessorPluginRegistry.addFrameProcessorPlugin("scanBarcodes") {proxy,options ->
+        VisionCameraBarcodeScannerModule(proxy,options)
+      }
+      FrameProcessorPluginRegistry.addFrameProcessorPlugin("scanText") { proxy, options ->
+        VisionCameraTextRecognitionModule(proxy, options)
+      }
+    }
+  }
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+    return emptyList()
+  }
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+    return emptyList()
+  }
+}

package/android/src/main/java/com/visioncameratextrecognition/VisionCameraTextRecognitionModule.kt

@@ -0,0 +1,130 @@
+package com.visioncameratextrecognition
+
+import android.media.Image
+import com.facebook.react.bridge.WritableNativeArray
+import com.facebook.react.bridge.WritableNativeMap
+import com.google.android.gms.tasks.Task
+import com.google.android.gms.tasks.Tasks
+import com.google.mlkit.vision.common.InputImage
+import com.google.mlkit.vision.text.Text
+import com.google.mlkit.vision.text.TextRecognition
+import com.google.mlkit.vision.text.TextRecognizer
+import com.google.mlkit.vision.text.chinese.ChineseTextRecognizerOptions
+import com.google.mlkit.vision.text.devanagari.DevanagariTextRecognizerOptions
+import com.google.mlkit.vision.text.japanese.JapaneseTextRecognizerOptions
+import com.google.mlkit.vision.text.korean.KoreanTextRecognizerOptions
+import com.google.mlkit.vision.text.latin.TextRecognizerOptions
+import com.mrousavy.camera.frameprocessor.Frame
+import com.mrousavy.camera.frameprocessor.FrameProcessorPlugin
+import com.mrousavy.camera.frameprocessor.VisionCameraProxy
+import com.mrousavy.camera.types.Orientation
+import java.util.ArrayList
+
+
+class VisionCameraTextRecognitionModule(proxy : VisionCameraProxy, options: Map<String, Any>?): FrameProcessorPlugin() {
+  private var recognizer: TextRecognizer = TextRecognition.getClient(TextRecognizerOptions.DEFAULT_OPTIONS)
+  private var language = options?.get("language").toString()
+
+  init {
+    recognizer = when (language) {
+      "latin" -> TextRecognition.getClient(TextRecognizerOptions.DEFAULT_OPTIONS)
+      "chinese" -> TextRecognition.getClient(ChineseTextRecognizerOptions.Builder().build())
+      "devanagari" -> TextRecognition.getClient(DevanagariTextRecognizerOptions.Builder().build())
+      "japanese" -> TextRecognition.getClient(JapaneseTextRecognizerOptions.Builder().build())
+      "korean" -> TextRecognition.getClient(KoreanTextRecognizerOptions.Builder().build())
+      else -> TextRecognition.getClient(TextRecognizerOptions.DEFAULT_OPTIONS)
+    }
+  }
+  override fun callback(frame: Frame, arguments: Map<String, Any>?): ArrayList<Any> {
+      try {
+        val mediaImage: Image = frame.image
+        val orientation : Orientation = frame.orientation
+        val array = WritableNativeArray()
+        val image = InputImage.fromMediaImage(mediaImage, orientation.toDegrees())
+        val task: Task<Text> = recognizer.process(image)
+        val result: Text? = Tasks.await(task)
+          val resultText = result?.text
+          for (block in result?.textBlocks!!) {
+            val map = WritableNativeMap()
+            map.putString("resultText",resultText)
+            val blockText = block.text
+            map.putString("blockText",blockText)
+            val blockCornerPoints = block.cornerPoints?.size
+            if (blockCornerPoints != null) {
+              map.putInt("size",blockCornerPoints)
+            }
+            val blockFrameBottom = block.boundingBox?.bottom
+            val blockFrameTop = block.boundingBox?.top
+            val blockFrameLeft = block.boundingBox?.left
+            val blockFrameRight = block.boundingBox?.right
+            if (blockFrameBottom != null) {
+              map.putInt("blockFrameBottom",blockFrameBottom)
+            }
+            if (blockFrameLeft != null) {
+              map.putInt("blockFrameLeft",blockFrameLeft)
+            }
+            if (blockFrameTop != null) {
+              map.putInt("blockFrameTop",blockFrameTop)
+            }
+            if (blockFrameRight != null) {
+              map.putInt("blockFrameRight",blockFrameRight)
+            }
+            for (line in block.lines) {
+              val lineText = line.text
+              map.putString("lineText",lineText)
+              val lineCornerPoints = line.cornerPoints?.size
+              if (lineCornerPoints != null) {
+                map.putInt("size",lineCornerPoints)
+              }
+              val lineFrameBottom = line.boundingBox?.bottom
+              val lineFrameTop = line.boundingBox?.top
+              val lineFrameLeft = line.boundingBox?.left
+              val lineFrameRight = line.boundingBox?.right
+              if (lineFrameBottom != null) {
+                map.putInt("lineFrameBottom",lineFrameBottom)
+              }
+              if (lineFrameLeft != null) {
+                map.putInt("lineFrameLeft",lineFrameLeft)
+              }
+              if (lineFrameTop != null) {
+                map.putInt("lineFrameTop",lineFrameTop)
+              }
+              if (lineFrameRight != null) {
+                map.putInt("lineFrameRight",lineFrameRight)
+              }
+              for (element in line.elements) {
+                val elementText = element.text
+                map.putString("elementText",elementText)
+
+                val elementCornerPoints = line.cornerPoints?.size
+                if (elementCornerPoints != null) {
+                  map.putInt("size",elementCornerPoints)
+                }
+                val elementFrameBottom = line.boundingBox?.bottom
+                val elementFrameTop = line.boundingBox?.top
+                val elementFrameLeft = line.boundingBox?.left
+                val elementFrameRight = line.boundingBox?.right
+                if (elementFrameBottom != null) {
+                  map.putInt("elementFrameBottom",elementFrameBottom)
+                }
+                if (elementFrameLeft != null) {
+                  map.putInt("elementFrameLeft",elementFrameLeft)
+                }
+                if (elementFrameTop != null) {
+                  map.putInt("elementFrameTop",elementFrameTop)
+                }
+                if (elementFrameRight != null) {
+                  map.putInt("elementFrameRight",elementFrameRight)
+                }
+              }
+              array.pushMap(map)
+
+            }
+          }
+        return array.toArrayList()
+      } catch (e: Exception) {
+       throw  Exception("Error processing text recognition: $e ")
+      }
+  }
+}
+

package/ios/VisionCameraBarcodeScanner.m

@@ -0,0 +1,175 @@
+#import <MLKitBarcodeScanning/MLKitBarcodeScanning.h>
+#import <MLKitBarcodeScanning/MLKBarcodeScannerOptions.h>
+#import <VisionCamera/FrameProcessorPlugin.h>
+#import <VisionCamera/FrameProcessorPluginRegistry.h>
+#import <VisionCamera/Frame.h>
+#import <React/RCTBridgeModule.h>
+@import MLKitVision;
+
+@interface VisionCameraBarcodeScannerPlugin : FrameProcessorPlugin
+
+@property(nonatomic, strong) NSDictionary *configuration;
+
+@end
+
+@implementation VisionCameraBarcodeScannerPlugin {
+    MLKBarcodeScannerOptions *options;
+}
+
+- (instancetype _Nonnull)initWithProxy:(VisionCameraProxyHolder*)proxy
+                           withOptions:(NSDictionary* _Nullable)options {
+    self = [super initWithProxy:proxy withOptions:options];
+    if (self) {
+        _configuration = options ?: @{};
+    }
+    return self;
+}
+
+- (id _Nullable)callback:(Frame* _Nonnull)frame
+           withArguments:(NSDictionary* _Nullable)arguments {
+    NSDictionary *config = arguments ?: self.configuration ?: @{};
+    MLKBarcodeFormat formatMask = [self formatMaskFromConfig:config];
+    options = [[MLKBarcodeScannerOptions alloc] initWithFormats:formatMask];
+
+    MLKBarcodeScanner *barcodeScanner = [MLKBarcodeScanner barcodeScannerWithOptions:options];
+
+    CMSampleBufferRef buffer = frame.buffer;
+    UIImageOrientation orientation = frame.orientation;
+    MLKVisionImage *image = [[MLKVisionImage alloc] initWithBuffer:buffer];
+    image.orientation = orientation;
+    NSMutableArray *data = [NSMutableArray array];
+    dispatch_group_t dispatchGroup = dispatch_group_create();
+    dispatch_group_enter(dispatchGroup);
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
+        [barcodeScanner processImage:image
+                          completion:^(NSArray<MLKBarcode *> *_Nullable barcodes,
+                                       NSError *_Nullable error) {
+            if (error != nil) {
+                RCTResponseErrorBlock error;
+                return;
+            }
+            if (barcodes.count > 0) {
+                for (MLKBarcode *barcode in barcodes) {
+                    NSMutableDictionary *obj = [[NSMutableDictionary alloc] init];
+
+                    NSString *displayValue = barcode.displayValue;
+                    obj[@"displayValue"] = displayValue;
+                    NSString *rawValue = barcode.rawValue;
+                    obj[@"rawValue"] = rawValue;
+                    obj[@"format"] = [self stringFromFormat:barcode.format];
+                    obj[@"left"] = @(CGRectGetMinX(barcode.frame));
+                    obj[@"top"] = @(CGRectGetMinY(barcode.frame));
+                    obj[@"right"] = @(CGRectGetMaxX(barcode.frame));
+                    obj[@"bottom"] = @(CGRectGetMaxY(barcode.frame));
+                    obj[@"width"] = @(barcode.frame.size.width);
+                    obj[@"height"] = @(barcode.frame.size.height);
+
+                    MLKBarcodeValueType valueType = barcode.valueType;
+
+                    switch (valueType) {
+                        case MLKBarcodeValueTypeWiFi:
+                            obj[@"ssid"] = barcode.wifi.ssid;
+                            obj[@"password"] = barcode.wifi.password;
+                            break;
+                        case MLKBarcodeValueTypeURL:
+                            obj[@"url"] = barcode.URL.url;
+                            obj[@"title"] = barcode.URL.title;
+                            break;
+                        default:
+                            break;
+                    }
+                    [data addObject:obj];
+
+                }
+
+            }
+
+            dispatch_group_leave(dispatchGroup);
+        }];
+    });
+
+    dispatch_group_wait(dispatchGroup, DISPATCH_TIME_FOREVER);
+    return data;
+}
+
+VISION_EXPORT_FRAME_PROCESSOR(VisionCameraBarcodeScannerPlugin, scanBarcodes)
+
+@end
+
+static BOOL optionEnabled(NSDictionary *config, NSString *key) {
+    id value = config[key];
+    if (!value) {
+        return NO;
+    }
+    if ([value isKindOfClass:[NSNumber class]]) {
+        return [(NSNumber *)value boolValue];
+    }
+    if ([value isKindOfClass:[NSString class]]) {
+        return [value boolValue];
+    }
+    return NO;
+}
+
+@implementation VisionCameraBarcodeScannerPlugin (Configuration)
+
+- (MLKBarcodeFormat)formatMaskFromConfig:(NSDictionary *)config {
+    if (optionEnabled(config, @"all")) {
+        return MLKBarcodeFormatAll;
+    }
+    MLKBarcodeFormat mask = 0;
+    if (optionEnabled(config, @"aztec")) mask |= MLKBarcodeFormatAztec;
+    if (optionEnabled(config, @"code-128")) mask |= MLKBarcodeFormatCode128;
+    if (optionEnabled(config, @"code-39")) mask |= MLKBarcodeFormatCode39;
+    if (optionEnabled(config, @"code-93")) mask |= MLKBarcodeFormatCode93;
+    if (optionEnabled(config, @"codabar")) mask |= MLKBarcodeFormatCodaBar;
+    if (optionEnabled(config, @"data-matrix")) mask |= MLKBarcodeFormatDataMatrix;
+    if (optionEnabled(config, @"ean-13")) mask |= MLKBarcodeFormatEAN13;
+    if (optionEnabled(config, @"ean-8")) mask |= MLKBarcodeFormatEAN8;
+    if (optionEnabled(config, @"itf")) mask |= MLKBarcodeFormatITF;
+    if (optionEnabled(config, @"pdf-417")) mask |= MLKBarcodeFormatPDF417;
+    if (optionEnabled(config, @"qr")) mask |= MLKBarcodeFormatQRCode;
+    if (optionEnabled(config, @"upc-a")) mask |= MLKBarcodeFormatUPCA;
+    if (optionEnabled(config, @"upc-e")) mask |= MLKBarcodeFormatUPCE;
+
+    if (mask == 0) {
+        mask = MLKBarcodeFormatAll;
+    }
+    return mask;
+}
+
+- (NSString *)stringFromFormat:(MLKBarcodeFormat)format {
+    switch (format) {
+        case MLKBarcodeFormatAztec:
+            return @"aztec";
+        case MLKBarcodeFormatCode128:
+            return @"code-128";
+        case MLKBarcodeFormatCode39:
+            return @"code-39";
+        case MLKBarcodeFormatCode93:
+            return @"code-93";
+        case MLKBarcodeFormatCodaBar:
+            return @"codabar";
+        case MLKBarcodeFormatDataMatrix:
+            return @"data-matrix";
+        case MLKBarcodeFormatEAN13:
+            return @"ean-13";
+        case MLKBarcodeFormatEAN8:
+            return @"ean-8";
+        case MLKBarcodeFormatITF:
+            return @"itf";
+        case MLKBarcodeFormatPDF417:
+            return @"pdf-417";
+        case MLKBarcodeFormatQRCode:
+            return @"qr";
+        case MLKBarcodeFormatUPCA:
+            return @"upc-a";
+        case MLKBarcodeFormatUPCE:
+            return @"upc-e";
+        case MLKBarcodeFormatAll:
+            return @"all";
+        default:
+            return @"unknown";
+    }
+}
+
+@end