From 0a8c904e1c2a22ca941b5512a47c157e8386bd8b Mon Sep 17 00:00:00 2001
From: Alan Hughes <30924086+alanjhughes@users.noreply.github.com>
Date: Sat, 27 Apr 2024 10:28:58 +0100
Subject: [PATCH] [camera] Support scanning barcode from URL (#28445)

---
 .../ExpoComponentsStackNavigator.tsx          |   6 ++
 .../Camera/CameraScreenBarcodeFromURL.tsx     |  64 +++++++++++
 .../src/screens/ExpoComponentsScreen.tsx      |   1 +
 packages/expo-camera/CHANGELOG.md             |   2 +
 .../expo/modules/camera/CameraExceptions.kt   |   3 +
 .../expo/modules/camera/CameraViewModule.kt   |  30 ++++++
 .../BarcodeScannerResultSerializer.kt         |  48 +++++++++
 .../camera/analyzers/MLKitBarcodeAnalyzer.kt  | 102 ++++++++++++++++++
 packages/expo-camera/build/index.d.ts         |  14 +++
 packages/expo-camera/build/index.d.ts.map     |   2 +-
 packages/expo-camera/build/index.js           |  15 +++
 packages/expo-camera/build/index.js.map       |   2 +-
 .../expo-camera/ios/CameraViewModule.swift    |  31 ++++++
 .../ios/Common/BarcodeExceptions.swift        |  19 ++++
 .../expo-camera/ios/Common/BarcodeUtils.swift |  70 ++++++++++++
 .../ios/Common/ExpoCameraUtils.swift          |   2 +-
 packages/expo-camera/src/index.ts             |  19 ++++
 17 files changed, 427 insertions(+), 3 deletions(-)
 create mode 100644 apps/native-component-list/src/screens/Camera/CameraScreenBarcodeFromURL.tsx
 create mode 100644 packages/expo-camera/android/src/main/java/expo/modules/camera/analyzers/BarcodeScannerResultSerializer.kt
 create mode 100644 packages/expo-camera/android/src/main/java/expo/modules/camera/analyzers/MLKitBarcodeAnalyzer.kt
 create mode 100644 packages/expo-camera/ios/Common/BarcodeExceptions.swift
 create mode 100644 packages/expo-camera/ios/Common/BarcodeUtils.swift

diff --git a/apps/native-component-list/src/navigation/ExpoComponentsStackNavigator.tsx b/apps/native-component-list/src/navigation/ExpoComponentsStackNavigator.tsx
index ca85a970777c0..1099a903d24af 100644
--- a/apps/native-component-list/src/navigation/ExpoComponentsStackNavigator.tsx
+++ b/apps/native-component-list/src/navigation/ExpoComponentsStackNavigator.tsx
@@ -67,6 +67,12 @@ export const Screens = [
     },
     name: 'Camera (barcode)',
   },
+  {
+    getComponent() {
+      return optionalRequire(() => require('../screens/Camera/CameraScreenBarcodeFromURL'));
+    },
+    name: 'Camera (barcode from URL)',
+  },
   {
     getComponent() {
       return optionalRequire(() => require('../screens/TextScreen'));
diff --git a/apps/native-component-list/src/screens/Camera/CameraScreenBarcodeFromURL.tsx b/apps/native-component-list/src/screens/Camera/CameraScreenBarcodeFromURL.tsx
new file mode 100644
index 0000000000000..d293a5b5f8e8b
--- /dev/null
+++ b/apps/native-component-list/src/screens/Camera/CameraScreenBarcodeFromURL.tsx
@@ -0,0 +1,64 @@
+import { BarcodeScanningResult, Camera } from 'expo-camera';
+import { Image } from 'expo-image';
+import * as ImagePicker from 'expo-image-picker';
+import { useState } from 'react';
+import { View, Text, Button, ScrollView, StyleSheet } from 'react-native';
+
+export default function CameraScreenFromURL() {
+  const [image, setImage] = useState<string | null>(null);
+  const [results, setResults] = useState<BarcodeScanningResult | null>(null);
+
+  const pickImage = async () => {
+    const result = await ImagePicker.launchImageLibraryAsync({
+      mediaTypes: ImagePicker.MediaTypeOptions.Images,
+      allowsEditing: false,
+      quality: 1,
+    });
+
+    if (!result.canceled) {
+      setImage(result.assets[0].uri);
+    }
+  };
+
+  const scanImage = async () => {
+    if (!image) {
+      return;
+    }
+    const results = await Camera.scanFromURLAsync(image);
+    setResults(results);
+  };
+
+  return (
+    <View style={styles.container}>
+      {!image && <Text>Select an image from the photo library</Text>}
+      <Button title="Select image" onPress={pickImage} />
+      {image && <Image source={{ uri: image }} style={styles.image} />}
+      {image && <Button title="Scan Image" onPress={scanImage} />}
+      <ScrollView style={styles.scrollView} contentContainerStyle={styles.scollViewContent}>
+        {results && <Text>{JSON.stringify(results, null, 2)}</Text>}
+      </ScrollView>
+    </View>
+  );
+}
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+    alignItems: 'center',
+    justifyContent: 'center',
+    gap: 20,
+    paddingTop: 20,
+  },
+  image: {
+    width: 200,
+    height: 200,
+  },
+  scrollView: {
+    flex: 1,
+    width: '100%',
+  },
+  scollViewContent: {
+    padding: 20,
+    alignItems: 'center',
+  },
+});
diff --git a/apps/native-component-list/src/screens/ExpoComponentsScreen.tsx b/apps/native-component-list/src/screens/ExpoComponentsScreen.tsx
index 90a6694ca6b45..dd4c964dd3d07 100644
--- a/apps/native-component-list/src/screens/ExpoComponentsScreen.tsx
+++ b/apps/native-component-list/src/screens/ExpoComponentsScreen.tsx
@@ -9,6 +9,7 @@ const screens = [
   'Camera',
   'Camera (legacy)',
   'Camera (barcode)',
+  'Camera (barcode from URL)',
   'Checkbox',
   'ClipboardPasteButton',
   'DateTimePicker',
diff --git a/packages/expo-camera/CHANGELOG.md b/packages/expo-camera/CHANGELOG.md
index 7e0c926d0e1ef..126a18dc3340f 100644
--- a/packages/expo-camera/CHANGELOG.md
+++ b/packages/expo-camera/CHANGELOG.md
@@ -6,6 +6,8 @@
 
 ### 🎉 New features
 
+- Support scanning barcodes from a provided image URL. ([#28445](https://github.com/expo/expo/pull/28445) by [@alanjhughes](https://github.com/alanjhughes))
+
 ### 🐛 Bug fixes
 
 ### 💡 Others
diff --git a/packages/expo-camera/android/src/main/java/expo/modules/camera/CameraExceptions.kt b/packages/expo-camera/android/src/main/java/expo/modules/camera/CameraExceptions.kt
index f8eac100464d2..fece17b08ac13 100644
--- a/packages/expo-camera/android/src/main/java/expo/modules/camera/CameraExceptions.kt
+++ b/packages/expo-camera/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'")
 }
diff --git a/packages/expo-camera/android/src/main/java/expo/modules/camera/CameraViewModule.kt b/packages/expo-camera/android/src/main/java/expo/modules/camera/CameraViewModule.kt
index 40cb390743d2f..5f84d28355d45 100644
--- a/packages/expo-camera/android/src/main/java/expo/modules/camera/CameraViewModule.kt
+++ b/packages/expo-camera/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())
diff --git a/packages/expo-camera/android/src/main/java/expo/modules/camera/analyzers/BarcodeScannerResultSerializer.kt b/packages/expo-camera/android/src/main/java/expo/modules/camera/analyzers/BarcodeScannerResultSerializer.kt
new file mode 100644
index 0000000000000..3cfff6f36d3ab
--- /dev/null
+++ b/packages/expo-camera/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)
+    }
+}
diff --git a/packages/expo-camera/android/src/main/java/expo/modules/camera/analyzers/MLKitBarcodeAnalyzer.kt b/packages/expo-camera/android/src/main/java/expo/modules/camera/analyzers/MLKitBarcodeAnalyzer.kt
new file mode 100644
index 0000000000000..4099073f4f2e5
--- /dev/null
+++ b/packages/expo-camera/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()
+  }
+}
diff --git a/packages/expo-camera/build/index.d.ts b/packages/expo-camera/build/index.d.ts
index a9b2fcbf9506a..c1135b45ad027 100644
--- a/packages/expo-camera/build/index.d.ts
+++ b/packages/expo-camera/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,18 @@ 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 bar code type that was scanned and the data is the information encoded in the bar
+ * code.
+ */
+export declare function scanFromURLAsync(url: string, barcodeTypes?: BarcodeType[]): Promise<BarcodeScanningResult>;
 export * from './Camera.types';
 /**
  * @hidden
@@ -51,5 +64,6 @@ export declare const Camera: {
     requestCameraPermissionsAsync: typeof requestCameraPermissionsAsync;
     getMicrophonePermissionsAsync: typeof getMicrophonePermissionsAsync;
     requestMicrophonePermissionsAsync: typeof requestMicrophonePermissionsAsync;
+    scanFromURLAsync: typeof scanFromURLAsync;
 };
 //# sourceMappingURL=index.d.ts.map
\ No newline at end of file
diff --git a/packages/expo-camera/build/index.d.ts.map b/packages/expo-camera/build/index.d.ts.map
index c02dd04384922..1d843b2e68e79 100644
--- a/packages/expo-camera/build/index.d.ts.map
+++ b/packages/expo-camera/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"}
\ No newline at end of file
+{"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;;;;;;;;;;GAUG;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"}
\ No newline at end of file
diff --git a/packages/expo-camera/build/index.js b/packages/expo-camera/build/index.js
index 321594dd41fb8..af04b0f6e748c 100644
--- a/packages/expo-camera/build/index.js
+++ b/packages/expo-camera/build/index.js
@@ -63,6 +63,20 @@ 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 bar code type that was scanned and the data is the information encoded in the bar
+ * code.
+ */
+export async function scanFromURLAsync(url, barcodeTypes = ['qr']) {
+    return CameraManager.scanFromURLAsync(url, barcodeTypes);
+}
 export * from './Camera.types';
 /**
  * @hidden
@@ -72,5 +86,6 @@ export const Camera = {
     requestCameraPermissionsAsync,
     getMicrophonePermissionsAsync,
     requestMicrophonePermissionsAsync,
+    scanFromURLAsync,
 };
 //# sourceMappingURL=index.js.map
\ No newline at end of file
diff --git a/packages/expo-camera/build/index.js.map b/packages/expo-camera/build/index.js.map
index ecb47de33bf05..3f7bb0d9c7f25 100644
--- a/packages/expo-camera/build/index.js.map
+++ b/packages/expo-camera/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"]}
\ No newline at end of file
+{"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;;;;;;;;;;GAUG;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 bar code type that was scanned and the data is the information encoded in the bar\n * code.\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"]}
\ No newline at end of file
diff --git a/packages/expo-camera/ios/CameraViewModule.swift b/packages/expo-camera/ios/CameraViewModule.swift
index 5321413738446..50a3b852690f3 100644
--- a/packages/expo-camera/ios/CameraViewModule.swift
+++ b/packages/expo-camera/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)
diff --git a/packages/expo-camera/ios/Common/BarcodeExceptions.swift b/packages/expo-camera/ios/Common/BarcodeExceptions.swift
new file mode 100644
index 0000000000000..9be8a8d6465f2
--- /dev/null
+++ b/packages/expo-camera/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"
+  }
+}
diff --git a/packages/expo-camera/ios/Common/BarcodeUtils.swift b/packages/expo-camera/ios/Common/BarcodeUtils.swift
new file mode 100644
index 0000000000000..0483da9c39134
--- /dev/null
+++ b/packages/expo-camera/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
+      ]
+    ]
+  }
+}
diff --git a/packages/expo-camera/ios/Common/ExpoCameraUtils.swift b/packages/expo-camera/ios/Common/ExpoCameraUtils.swift
index bd73a18c6d811..486a4b93bc862 100644
--- a/packages/expo-camera/ios/Common/ExpoCameraUtils.swift
+++ b/packages/expo-camera/ios/Common/ExpoCameraUtils.swift
@@ -24,7 +24,7 @@ struct ExpoCameraUtils {
     }
 
     return orientation
-}
+  }
 
   static func videoOrientation(for interfaceOrientation: UIInterfaceOrientation) -> AVCaptureVideoOrientation {
     switch interfaceOrientation {
diff --git a/packages/expo-camera/src/index.ts b/packages/expo-camera/src/index.ts
index 32caa7f7fb364..44ffd378e6f8c 100644
--- a/packages/expo-camera/src/index.ts
+++ b/packages/expo-camera/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,
 };