expo-camera 15.0.2 → 15.0.3

package/CHANGELOG.md

@@ -10,6 +10,12 @@
 
 ### 💡 Others
 
+## 15.0.3 — 2024-04-29
+
+### 🎉 New features
+
+- Support scanning barcodes from a provided image URL. ([#28445](https://github.com/expo/expo/pull/28445) by [@alanjhughes](https://github.com/alanjhughes))
+
 ## 15.0.2 — 2024-04-24
 
 ### 🐛 Bug fixes

package/android/build.gradle

@@ -1,7 +1,7 @@
 apply plugin: 'com.android.library'
 
 group = 'host.exp.exponent'
-version = '15.0.2'
+version = '15.0.3'
 
 def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
 apply from: expoModulesCorePlugin
@@ -14,7 +14,7 @@ android {
   namespace "expo.modules.camera"
   defaultConfig {
     versionCode 32
-    versionName "15.0.2"
+    versionName "15.0.3"
   }
 }
 

package/android/src/main/java/expo/modules/camera/CameraExceptions.kt

@@ -6,4 +6,7 @@ class CameraExceptions {
   class ImageCaptureFailed : CodedException(message = "Failed to capture image")
 
   class VideoRecordingFailed(cause: String?) : CodedException("Video recording failed: $cause")
+
+  class ImageRetrievalException(url: String) :
+    CodedException("Could not get the image from given url: '$url'")
 }

package/android/src/main/java/expo/modules/camera/CameraViewModule.kt

@@ -1,8 +1,12 @@
 package expo.modules.camera
 
 import android.Manifest
+import android.graphics.Bitmap
 import android.util.Log
+import expo.modules.camera.analyzers.BarCodeScannerResultSerializer
+import expo.modules.camera.analyzers.MLKitBarCodeScanner
 import expo.modules.camera.records.BarcodeSettings
+import expo.modules.camera.records.BarcodeType
 import expo.modules.camera.records.CameraMode
 import expo.modules.camera.records.CameraType
 import expo.modules.camera.records.FlashMode
@@ -10,6 +14,7 @@ import expo.modules.camera.records.VideoQuality
 import expo.modules.camera.tasks.ResolveTakenPicture
 import expo.modules.core.errors.ModuleDestroyedException
 import expo.modules.core.utilities.EmulatorUtilities
+import expo.modules.interfaces.imageloader.ImageLoaderInterface
 import expo.modules.interfaces.permissions.Permissions
 import expo.modules.kotlin.Promise
 import expo.modules.kotlin.exception.Exceptions
@@ -33,6 +38,7 @@ val cameraEvents = arrayOf(
 
 class CameraViewModule : Module() {
   private val moduleScope = CoroutineScope(Dispatchers.Main)
+
   override fun definition() = ModuleDefinition {
     Name("ExpoCamera")
 
@@ -70,6 +76,30 @@ class CameraViewModule : Module() {
       )
     }
 
+    AsyncFunction("scanFromURLAsync") { url: String, barcodeTypes: List<BarcodeType>, promise: Promise ->
+      appContext.imageLoader?.loadImageForManipulationFromURL(
+        url,
+        object : ImageLoaderInterface.ResultListener {
+          override fun onSuccess(bitmap: Bitmap) {
+            val scanner = MLKitBarCodeScanner()
+            val formats = barcodeTypes.map { it.mapToBarcode() }
+            scanner.setSettings(formats)
+
+            moduleScope.launch {
+              val barcodes = scanner.scan(bitmap)
+                .filter { formats.contains(it.type) }
+                .map { BarCodeScannerResultSerializer.toBundle(it, 1.0f) }
+              promise.resolve(barcodes)
+            }
+          }
+
+          override fun onFailure(cause: Throwable?) {
+            promise.reject(CameraExceptions.ImageRetrievalException(url))
+          }
+        }
+      )
+    }
+
     OnDestroy {
       try {
         moduleScope.cancel(ModuleDestroyedException())

package/android/src/main/java/expo/modules/camera/analyzers/BarcodeScannerResultSerializer.kt

@@ -0,0 +1,48 @@
+package expo.modules.camera.analyzers
+
+import android.os.Bundle
+import android.util.Pair
+import expo.modules.interfaces.barcodescanner.BarCodeScannerResult
+
+object BarCodeScannerResultSerializer {
+  fun toBundle(result: BarCodeScannerResult, density: Float) =
+    Bundle().apply {
+      putString("data", result.value)
+      putString("raw", result.raw)
+      putInt("type", result.type)
+      val cornerPointsAndBoundingBox = getCornerPointsAndBoundingBox(result.cornerPoints, result.boundingBox, density)
+      putParcelableArrayList("cornerPoints", cornerPointsAndBoundingBox.first)
+      putBundle("bounds", cornerPointsAndBoundingBox.second)
+    }
+
+  private fun getCornerPointsAndBoundingBox(
+    cornerPoints: List<Int>,
+    boundingBox: BarCodeScannerResult.BoundingBox,
+    density: Float
+  ): Pair<ArrayList<Bundle>, Bundle> {
+    val convertedCornerPoints = ArrayList<Bundle>()
+    for (i in cornerPoints.indices step 2) {
+      val x = cornerPoints[i].toFloat() / density
+      val y = cornerPoints[i + 1].toFloat() / density
+
+      convertedCornerPoints.add(getPoint(x, y))
+    }
+    val boundingBoxBundle = Bundle().apply {
+      putParcelable("origin", getPoint(boundingBox.x.toFloat() / density, boundingBox.y.toFloat() / density))
+      putParcelable("size", getSize(boundingBox.width.toFloat() / density, boundingBox.height.toFloat() / density))
+    }
+    return Pair(convertedCornerPoints, boundingBoxBundle)
+  }
+
+  private fun getSize(width: Float, height: Float) =
+    Bundle().apply {
+      putFloat("width", width)
+      putFloat("height", height)
+    }
+
+  private fun getPoint(x: Float, y: Float) =
+    Bundle().apply {
+      putFloat("x", x)
+      putFloat("y", y)
+    }
+}

package/android/src/main/java/expo/modules/camera/analyzers/MLKitBarcodeAnalyzer.kt

@@ -0,0 +1,102 @@
+package expo.modules.camera.analyzers
+
+import android.graphics.Bitmap
+import android.util.Log
+import com.google.android.gms.tasks.Task
+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 expo.modules.interfaces.barcodescanner.BarCodeScannerResult
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlinx.coroutines.withContext
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
+
+class MLKitBarCodeScanner {
+  private var barCodeTypes: List<Int>? = null
+  private var barcodeScannerOptions =
+    BarcodeScannerOptions.Builder()
+      .setBarcodeFormats(Barcode.FORMAT_ALL_FORMATS)
+      .build()
+  private var barcodeScanner = BarcodeScanning.getClient(barcodeScannerOptions)
+
+  suspend fun scan(bitmap: Bitmap): List<BarCodeScannerResult> = withContext(Dispatchers.IO) {
+    val inputImage = InputImage.fromBitmap(bitmap, 0)
+    try {
+      val result: List<Barcode> = barcodeScanner.process(inputImage).await()
+      val results = mutableListOf<BarCodeScannerResult>()
+      if (result.isEmpty()) {
+        return@withContext results
+      }
+      for (barcode in result) {
+        val raw = barcode.rawValue ?: barcode.rawBytes?.let { String(it) }
+        val value = if (barcode.valueType == Barcode.TYPE_CONTACT_INFO) {
+          raw
+        } else {
+          barcode.displayValue
+        }
+        val cornerPoints = mutableListOf<Int>()
+        barcode.cornerPoints?.let { points ->
+          for (point in points) {
+            cornerPoints.addAll(listOf(point.x, point.y))
+          }
+        }
+
+        results.add(BarCodeScannerResult(barcode.format, value, raw, cornerPoints, inputImage.height, inputImage.width))
+      }
+      return@withContext results
+    } catch (e: Exception) {
+      Log.e(TAG, "Failed to detect barcode: " + e.message)
+      return@withContext emptyList()
+    }
+  }
+
+  fun setSettings(formats: List<Int>) {
+    if (areNewAndOldBarCodeTypesEqual(formats)) {
+      return
+    }
+    val barcodeFormats = formats.reduce { acc, it ->
+      acc or it
+    }
+
+    barCodeTypes = formats
+    barcodeScannerOptions = BarcodeScannerOptions.Builder()
+      .setBarcodeFormats(barcodeFormats)
+      .build()
+    barcodeScanner = BarcodeScanning.getClient(barcodeScannerOptions)
+  }
+
+  private fun areNewAndOldBarCodeTypesEqual(newBarCodeTypes: List<Int>): Boolean {
+    barCodeTypes?.run {
+      // create distinct-values sets
+      val prevTypesSet = toHashSet()
+      val nextTypesSet = newBarCodeTypes.toHashSet()
+
+      // sets sizes are equal -> possible content equality
+      if (prevTypesSet.size == nextTypesSet.size) {
+        prevTypesSet.removeAll(nextTypesSet)
+        // every element from new set was in previous one -> sets are equal
+        return prevTypesSet.isEmpty()
+      }
+    }
+    return false
+  }
+
+  companion object {
+    private val TAG = MLKitBarCodeScanner::class.java.simpleName
+  }
+}
+
+suspend fun <T> Task<T>.await(): T = suspendCancellableCoroutine { continuation ->
+  addOnSuccessListener { result ->
+    continuation.resume(result)
+  }
+  addOnFailureListener { exception ->
+    continuation.resumeWithException(exception)
+  }
+  addOnCanceledListener {
+    continuation.cancel()
+  }
+}

package/build/index.d.ts

@@ -1,3 +1,4 @@
+import { BarcodeScanningResult, BarcodeType } from './Camera.types';
 import { PermissionResponse } from './legacy/Camera.types';
 export { default as CameraView } from './CameraView';
 /**
@@ -42,6 +43,17 @@ declare function requestMicrophonePermissionsAsync(): Promise<PermissionResponse
  * ```
  */
 export declare const useMicrophonePermissions: (options?: import("expo-modules-core").PermissionHookOptions<object> | undefined) => [PermissionResponse | null, () => Promise<PermissionResponse>, () => Promise<PermissionResponse>];
+/**
+ * Scan bar codes from the image at the given URL.
+ * @param url URL to get the image from.
+ * @param barcodeTypes An array of bar code types. Defaults to all supported bar code types on
+ * the platform.
+ * > __Note:__ Only QR codes are supported on iOS.
+ * On android, the barcode should take up the majority of the image for best results.
+ * @return A possibly empty array of objects of the `BarcodeScanningResult` shape, where the type
+ * refers to the barcode type that was scanned and the data is the information encoded in the barcode.
+ */
+export declare function scanFromURLAsync(url: string, barcodeTypes?: BarcodeType[]): Promise<BarcodeScanningResult>;
 export * from './Camera.types';
 /**
  * @hidden
@@ -51,5 +63,6 @@ export declare const Camera: {
     requestCameraPermissionsAsync: typeof requestCameraPermissionsAsync;
     getMicrophonePermissionsAsync: typeof getMicrophonePermissionsAsync;
     requestMicrophonePermissionsAsync: typeof requestMicrophonePermissionsAsync;
+    scanFromURLAsync: typeof scanFromURLAsync;
 };
 //# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAE3D,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,cAAc,CAAC;AAGrD;;;GAGG;AACH,iBAAe,yBAAyB,IAAI,OAAO,CAAC,kBAAkB,CAAC,CAEtE;AAGD;;;;GAIG;AACH,iBAAe,6BAA6B,IAAI,OAAO,CAAC,kBAAkB,CAAC,CAE1E;AAGD;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,wLAG/B,CAAC;AAGH;;;GAGG;AACH,iBAAe,6BAA6B,IAAI,OAAO,CAAC,kBAAkB,CAAC,CAE1E;AAGD;;;;GAIG;AACH,iBAAe,iCAAiC,IAAI,OAAO,CAAC,kBAAkB,CAAC,CAE9E;AAGD;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB,wLAGnC,CAAC;AAEH,cAAc,gBAAgB,CAAC;AAE/B;;GAEG;AACH,eAAO,MAAM,MAAM;;;;;CAKlB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,qBAAqB,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAEpE,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAE3D,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,cAAc,CAAC;AAGrD;;;GAGG;AACH,iBAAe,yBAAyB,IAAI,OAAO,CAAC,kBAAkB,CAAC,CAEtE;AAGD;;;;GAIG;AACH,iBAAe,6BAA6B,IAAI,OAAO,CAAC,kBAAkB,CAAC,CAE1E;AAGD;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,wLAG/B,CAAC;AAGH;;;GAGG;AACH,iBAAe,6BAA6B,IAAI,OAAO,CAAC,kBAAkB,CAAC,CAE1E;AAGD;;;;GAIG;AACH,iBAAe,iCAAiC,IAAI,OAAO,CAAC,kBAAkB,CAAC,CAE9E;AAGD;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB,wLAGnC,CAAC;AAEH;;;;;;;;;GASG;AACH,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,MAAM,EACX,YAAY,GAAE,WAAW,EAAW,GACnC,OAAO,CAAC,qBAAqB,CAAC,CAEhC;AAED,cAAc,gBAAgB,CAAC;AAE/B;;GAEG;AACH,eAAO,MAAM,MAAM;;;;;;CAMlB,CAAC"}

package/build/index.js

@@ -63,6 +63,19 @@ export const useMicrophonePermissions = createPermissionHook({
     getMethod: getMicrophonePermissionsAsync,
     requestMethod: requestMicrophonePermissionsAsync,
 });
+/**
+ * Scan bar codes from the image at the given URL.
+ * @param url URL to get the image from.
+ * @param barcodeTypes An array of bar code types. Defaults to all supported bar code types on
+ * the platform.
+ * > __Note:__ Only QR codes are supported on iOS.
+ * On android, the barcode should take up the majority of the image for best results.
+ * @return A possibly empty array of objects of the `BarcodeScanningResult` shape, where the type
+ * refers to the barcode type that was scanned and the data is the information encoded in the barcode.
+ */
+export async function scanFromURLAsync(url, barcodeTypes = ['qr']) {
+    return CameraManager.scanFromURLAsync(url, barcodeTypes);
+}
 export * from './Camera.types';
 /**
  * @hidden
@@ -72,5 +85,6 @@ export const Camera = {
     requestCameraPermissionsAsync,
     getMicrophonePermissionsAsync,
     requestMicrophonePermissionsAsync,
+    scanFromURLAsync,
 };
 //# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAEzD,OAAO,aAAa,MAAM,qBAAqB,CAAC;AAGhD,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,cAAc,CAAC;AAErD,cAAc;AACd;;;GAGG;AACH,KAAK,UAAU,yBAAyB;IACtC,OAAO,aAAa,CAAC,yBAAyB,EAAE,CAAC;AACnD,CAAC;AAED,cAAc;AACd;;;;GAIG;AACH,KAAK,UAAU,6BAA6B;IAC1C,OAAO,aAAa,CAAC,6BAA6B,EAAE,CAAC;AACvD,CAAC;AAED,cAAc;AACd;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,oBAAoB,CAAC;IACvD,SAAS,EAAE,yBAAyB;IACpC,aAAa,EAAE,6BAA6B;CAC7C,CAAC,CAAC;AAEH,cAAc;AACd;;;GAGG;AACH,KAAK,UAAU,6BAA6B;IAC1C,OAAO,aAAa,CAAC,6BAA6B,EAAE,CAAC;AACvD,CAAC;AAED,cAAc;AACd;;;;GAIG;AACH,KAAK,UAAU,iCAAiC;IAC9C,OAAO,aAAa,CAAC,iCAAiC,EAAE,CAAC;AAC3D,CAAC;AAED,cAAc;AACd;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,oBAAoB,CAAC;IAC3D,SAAS,EAAE,6BAA6B;IACxC,aAAa,EAAE,iCAAiC;CACjD,CAAC,CAAC;AAEH,cAAc,gBAAgB,CAAC;AAE/B;;GAEG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG;IACpB,yBAAyB;IACzB,6BAA6B;IAC7B,6BAA6B;IAC7B,iCAAiC;CAClC,CAAC","sourcesContent":["import { createPermissionHook } from 'expo-modules-core';\n\nimport CameraManager from './ExpoCameraManager';\nimport { PermissionResponse } from './legacy/Camera.types';\n\nexport { default as CameraView } from './CameraView';\n\n// @needsAudit\n/**\n * Checks user's permissions for accessing camera.\n * @return A promise that resolves to an object of type [PermissionResponse](#permissionresponse).\n */\nasync function getCameraPermissionsAsync(): Promise<PermissionResponse> {\n  return CameraManager.getCameraPermissionsAsync();\n}\n\n// @needsAudit\n/**\n * Asks the user to grant permissions for accessing camera.\n * On iOS this will require apps to specify an `NSCameraUsageDescription` entry in the **Info.plist**.\n * @return A promise that resolves to an object of type [PermissionResponse](#permissionresponse).\n */\nasync function requestCameraPermissionsAsync(): Promise<PermissionResponse> {\n  return CameraManager.requestCameraPermissionsAsync();\n}\n\n// @needsAudit\n/**\n * Check or request permissions to access the camera.\n * This uses both `requestCameraPermissionsAsync` and `getCameraPermissionsAsync` to interact with the permissions.\n *\n * @example\n * ```ts\n * const [status, requestPermission] = useCameraPermissions();\n * ```\n */\nexport const useCameraPermissions = createPermissionHook({\n  getMethod: getCameraPermissionsAsync,\n  requestMethod: requestCameraPermissionsAsync,\n});\n\n// @needsAudit\n/**\n * Checks user's permissions for accessing microphone.\n * @return A promise that resolves to an object of type [PermissionResponse](#permissionresponse).\n */\nasync function getMicrophonePermissionsAsync(): Promise<PermissionResponse> {\n  return CameraManager.getMicrophonePermissionsAsync();\n}\n\n// @needsAudit\n/**\n * Asks the user to grant permissions for accessing the microphone.\n * On iOS this will require apps to specify an `NSMicrophoneUsageDescription` entry in the **Info.plist**.\n * @return A promise that resolves to an object of type [PermissionResponse](#permissionresponse).\n */\nasync function requestMicrophonePermissionsAsync(): Promise<PermissionResponse> {\n  return CameraManager.requestMicrophonePermissionsAsync();\n}\n\n// @needsAudit\n/**\n * Check or request permissions to access the microphone.\n * This uses both `requestMicrophonePermissionsAsync` and `getMicrophonePermissionsAsync` to interact with the permissions.\n *\n * @example\n * ```ts\n * const [status, requestPermission] = Camera.useMicrophonePermissions();\n * ```\n */\nexport const useMicrophonePermissions = createPermissionHook({\n  getMethod: getMicrophonePermissionsAsync,\n  requestMethod: requestMicrophonePermissionsAsync,\n});\n\nexport * from './Camera.types';\n\n/**\n * @hidden\n */\nexport const Camera = {\n  getCameraPermissionsAsync,\n  requestCameraPermissionsAsync,\n  getMicrophonePermissionsAsync,\n  requestMicrophonePermissionsAsync,\n};\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAGzD,OAAO,aAAa,MAAM,qBAAqB,CAAC;AAGhD,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,cAAc,CAAC;AAErD,cAAc;AACd;;;GAGG;AACH,KAAK,UAAU,yBAAyB;IACtC,OAAO,aAAa,CAAC,yBAAyB,EAAE,CAAC;AACnD,CAAC;AAED,cAAc;AACd;;;;GAIG;AACH,KAAK,UAAU,6BAA6B;IAC1C,OAAO,aAAa,CAAC,6BAA6B,EAAE,CAAC;AACvD,CAAC;AAED,cAAc;AACd;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,oBAAoB,CAAC;IACvD,SAAS,EAAE,yBAAyB;IACpC,aAAa,EAAE,6BAA6B;CAC7C,CAAC,CAAC;AAEH,cAAc;AACd;;;GAGG;AACH,KAAK,UAAU,6BAA6B;IAC1C,OAAO,aAAa,CAAC,6BAA6B,EAAE,CAAC;AACvD,CAAC;AAED,cAAc;AACd;;;;GAIG;AACH,KAAK,UAAU,iCAAiC;IAC9C,OAAO,aAAa,CAAC,iCAAiC,EAAE,CAAC;AAC3D,CAAC;AAED,cAAc;AACd;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,oBAAoB,CAAC;IAC3D,SAAS,EAAE,6BAA6B;IACxC,aAAa,EAAE,iCAAiC;CACjD,CAAC,CAAC;AAEH;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CACpC,GAAW,EACX,eAA8B,CAAC,IAAI,CAAC;IAEpC,OAAO,aAAa,CAAC,gBAAgB,CAAC,GAAG,EAAE,YAAY,CAAC,CAAC;AAC3D,CAAC;AAED,cAAc,gBAAgB,CAAC;AAE/B;;GAEG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG;IACpB,yBAAyB;IACzB,6BAA6B;IAC7B,6BAA6B;IAC7B,iCAAiC;IACjC,gBAAgB;CACjB,CAAC","sourcesContent":["import { createPermissionHook } from 'expo-modules-core';\n\nimport { BarcodeScanningResult, BarcodeType } from './Camera.types';\nimport CameraManager from './ExpoCameraManager';\nimport { PermissionResponse } from './legacy/Camera.types';\n\nexport { default as CameraView } from './CameraView';\n\n// @needsAudit\n/**\n * Checks user's permissions for accessing camera.\n * @return A promise that resolves to an object of type [PermissionResponse](#permissionresponse).\n */\nasync function getCameraPermissionsAsync(): Promise<PermissionResponse> {\n  return CameraManager.getCameraPermissionsAsync();\n}\n\n// @needsAudit\n/**\n * Asks the user to grant permissions for accessing camera.\n * On iOS this will require apps to specify an `NSCameraUsageDescription` entry in the **Info.plist**.\n * @return A promise that resolves to an object of type [PermissionResponse](#permissionresponse).\n */\nasync function requestCameraPermissionsAsync(): Promise<PermissionResponse> {\n  return CameraManager.requestCameraPermissionsAsync();\n}\n\n// @needsAudit\n/**\n * Check or request permissions to access the camera.\n * This uses both `requestCameraPermissionsAsync` and `getCameraPermissionsAsync` to interact with the permissions.\n *\n * @example\n * ```ts\n * const [status, requestPermission] = useCameraPermissions();\n * ```\n */\nexport const useCameraPermissions = createPermissionHook({\n  getMethod: getCameraPermissionsAsync,\n  requestMethod: requestCameraPermissionsAsync,\n});\n\n// @needsAudit\n/**\n * Checks user's permissions for accessing microphone.\n * @return A promise that resolves to an object of type [PermissionResponse](#permissionresponse).\n */\nasync function getMicrophonePermissionsAsync(): Promise<PermissionResponse> {\n  return CameraManager.getMicrophonePermissionsAsync();\n}\n\n// @needsAudit\n/**\n * Asks the user to grant permissions for accessing the microphone.\n * On iOS this will require apps to specify an `NSMicrophoneUsageDescription` entry in the **Info.plist**.\n * @return A promise that resolves to an object of type [PermissionResponse](#permissionresponse).\n */\nasync function requestMicrophonePermissionsAsync(): Promise<PermissionResponse> {\n  return CameraManager.requestMicrophonePermissionsAsync();\n}\n\n// @needsAudit\n/**\n * Check or request permissions to access the microphone.\n * This uses both `requestMicrophonePermissionsAsync` and `getMicrophonePermissionsAsync` to interact with the permissions.\n *\n * @example\n * ```ts\n * const [status, requestPermission] = Camera.useMicrophonePermissions();\n * ```\n */\nexport const useMicrophonePermissions = createPermissionHook({\n  getMethod: getMicrophonePermissionsAsync,\n  requestMethod: requestMicrophonePermissionsAsync,\n});\n\n/**\n * Scan bar codes from the image at the given URL.\n * @param url URL to get the image from.\n * @param barcodeTypes An array of bar code types. Defaults to all supported bar code types on\n * the platform.\n * > __Note:__ Only QR codes are supported on iOS.\n * On android, the barcode should take up the majority of the image for best results.\n * @return A possibly empty array of objects of the `BarcodeScanningResult` shape, where the type\n * refers to the barcode type that was scanned and the data is the information encoded in the barcode.\n */\nexport async function scanFromURLAsync(\n  url: string,\n  barcodeTypes: BarcodeType[] = ['qr']\n): Promise<BarcodeScanningResult> {\n  return CameraManager.scanFromURLAsync(url, barcodeTypes);\n}\n\nexport * from './Camera.types';\n\n/**\n * @hidden\n */\nexport const Camera = {\n  getCameraPermissionsAsync,\n  requestCameraPermissionsAsync,\n  getMicrophonePermissionsAsync,\n  requestMicrophonePermissionsAsync,\n  scanFromURLAsync,\n};\n"]}

package/ios/CameraViewModule.swift

@@ -37,6 +37,37 @@ public final class CameraViewModule: Module, ScannerResultHandler {
       return false
     }
 
+    AsyncFunction("scanFromURLAsync") { (url: URL, _: [BarcodeType], promise: Promise) in
+      guard let imageLoader = appContext?.imageLoader else {
+        throw ImageLoaderNotFound()
+      }
+
+      imageLoader.loadImage(for: url) { error, image in
+        if error != nil {
+          promise.reject(FailedToLoadImage())
+          return
+        }
+
+        guard let cgImage = image?.cgImage else {
+          promise.reject(FailedToLoadImage())
+          return
+        }
+
+        guard let detector = CIDetector(
+          ofType: CIDetectorTypeQRCode,
+          context: nil,
+          options: [CIDetectorAccuracy: CIDetectorAccuracyHigh]
+        ) else {
+          promise.reject(InitScannerFailed())
+          return
+        }
+
+        let ciImage = CIImage(cgImage: cgImage)
+        let features = detector.features(in: ciImage)
+        promise.resolve(BarcodeUtils.getResultFrom(features))
+      }
+    }
+
     // swiftlint:disable:next closure_body_length
     View(CameraView.self) {
       Events(cameraNextEvents)

package/ios/Common/BarcodeExceptions.swift

@@ -0,0 +1,19 @@
+import ExpoModulesCore
+
+internal class ImageLoaderNotFound: Exception {
+  override var reason: String {
+    "Image Loader module not found"
+  }
+}
+
+internal class FailedToLoadImage: Exception {
+  override var reason: String {
+    "Could not get the image"
+  }
+}
+
+internal class InitScannerFailed: Exception {
+  override var reason: String {
+    "Could not initialize the barcode scanner"
+  }
+}

package/ios/Common/BarcodeUtils.swift

@@ -0,0 +1,70 @@
+import AVFoundation
+
+struct BarcodeUtils {
+  static func getResultFrom(_ features: [CIFeature]) -> [[AnyHashable: Any]?] {
+    var result = [[AnyHashable: Any]?]()
+
+    for feature in features {
+      if let qrCodeFeature = feature as? CIQRCodeFeature {
+        let item = ciQRCodeFeature(
+          codeFeature: qrCodeFeature
+        )
+        result.append(item)
+      }
+    }
+
+    return result
+  }
+
+  static func ciQRCodeFeature(codeFeature: CIQRCodeFeature) -> [String: Any] {
+    var result: [String: Any] = [:]
+    result["type"] = "qr"
+    result["data"] = codeFeature.messageString
+
+    if !codeFeature.bounds.isEmpty {
+      result["cornerPoints"] = [
+        codeFeature.topLeft,
+        codeFeature.topRight,
+        codeFeature.bottomRight,
+        codeFeature.bottomLeft
+      ].map { point in
+        [
+          "x": point.x,
+          "y": point.y
+        ]
+      }
+
+      let origin = codeFeature.bounds.origin
+      let size = codeFeature.bounds.size
+
+      result["bounds"] = [
+        "origin": [
+          "x": origin.x,
+          "y": origin.y
+        ],
+        "size": [
+          "width": size.width,
+          "height": size.height
+        ]
+      ]
+    } else {
+      addEmptyCornerPoints(to: &result)
+    }
+
+    return result
+  }
+
+  static func addEmptyCornerPoints(to result: inout [String: Any]) {
+    result["cornerPoints"] = []
+    result["bounds"] = [
+      "origin": [
+        "x": 0,
+        "y": 0
+      ],
+      "size": [
+        "width": 0,
+        "height": 0
+      ]
+    ]
+  }
+}

package/ios/Common/ExpoCameraUtils.swift

@@ -24,7 +24,7 @@ struct ExpoCameraUtils {
     }
 
     return orientation
-}
+  }
 
   static func videoOrientation(for interfaceOrientation: UIInterfaceOrientation) -> AVCaptureVideoOrientation {
     switch interfaceOrientation {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-camera",
-  "version": "15.0.2",
+  "version": "15.0.3",
   "description": "A React component that renders a preview for the device's either front or back camera. Camera's parameters like zoom, auto focus, white balance and flash mode are adjustable. With expo-camera, one can also take photos and record videos that are saved to the app's cache. Morever, the component is also capable of detecting faces and bar codes appearing on the preview.",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -42,5 +42,5 @@
   "peerDependencies": {
     "expo": "*"
   },
-  "gitHead": "8b4cb45563b85c2ec91b1b249d136661bf6e8981"
+  "gitHead": "4a7cf0d0baf6dfc595d93f604945d2142e705a36"
 }

package/src/index.ts

@@ -1,5 +1,6 @@
 import { createPermissionHook } from 'expo-modules-core';
 
+import { BarcodeScanningResult, BarcodeType } from './Camera.types';
 import CameraManager from './ExpoCameraManager';
 import { PermissionResponse } from './legacy/Camera.types';
 
@@ -73,6 +74,23 @@ export const useMicrophonePermissions = createPermissionHook({
   requestMethod: requestMicrophonePermissionsAsync,
 });
 
+/**
+ * Scan bar codes from the image at the given URL.
+ * @param url URL to get the image from.
+ * @param barcodeTypes An array of bar code types. Defaults to all supported bar code types on
+ * the platform.
+ * > __Note:__ Only QR codes are supported on iOS.
+ * On android, the barcode should take up the majority of the image for best results.
+ * @return A possibly empty array of objects of the `BarcodeScanningResult` shape, where the type
+ * refers to the barcode type that was scanned and the data is the information encoded in the barcode.
+ */
+export async function scanFromURLAsync(
+  url: string,
+  barcodeTypes: BarcodeType[] = ['qr']
+): Promise<BarcodeScanningResult> {
+  return CameraManager.scanFromURLAsync(url, barcodeTypes);
+}
+
 export * from './Camera.types';
 
 /**
@@ -83,4 +101,5 @@ export const Camera = {
   requestCameraPermissionsAsync,
   getMicrophonePermissionsAsync,
   requestMicrophonePermissionsAsync,
+  scanFromURLAsync,
 };