mediversal-rn-image-intelligence 1.0.9 → 1.0.10

package/README.md

@@ -3,11 +3,11 @@
 [![npm version](https://badge.fury.io/js/mediversal-rn-image-intelligence.svg)](https://badge.fury.io/js/mediversal-rn-image-intelligence)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-A production-ready React Native library for intelligent image analysis using Google ML Kit's on-device APIs. Analyze images to detect faces and extract text, with all processing happening locally on the device for maximum privacy and performance.
+A production-ready React Native library for intelligent image analysis using Google ML Kit's on-device APIs. Detect faces, extract text, and identify objects in images—all processed locally on the device for maximum privacy and performance.
 
 ## Overview
 
-This library provides a simple interface to Google ML Kit's powerful machine learning capabilities for mobile applications. You can detect human faces with detailed metadata including smile probability, eye state, and head rotation, as well as extract printed text from images with high accuracy using optical character recognition.
+This library provides a simple interface to Google ML Kit's powerful machine learning capabilities for mobile applications. You can detect human faces with detailed metadata, extract printed text using optical character recognition, and identify objects with confidence scores—all without sending any data to external servers.
 
 Since all processing happens entirely on-device, your users' data never leaves their device. There's no need for an internet connection, no data is uploaded to external servers, and you get fast, reliable results even in offline scenarios.
 
@@ -19,6 +19,9 @@ Detect human faces in images with comprehensive metadata including smiling proba
 **Text Recognition (OCR)**
 Extract printed text from images with high accuracy. Ideal for document scanning, business card reading, receipt processing, and any scenario where you need to digitize text from photos.
 
+**Object Detection**
+Identify and classify objects in images with confidence scores. Recognize common objects like animals, vehicles, furniture, food items, and more. Each detected object includes a bounding box, tracking ID, and multiple classification labels.
+
 **Privacy-First Architecture**
 All image processing happens on-device using Google ML Kit. No images or extracted data are ever transmitted to external servers, ensuring complete privacy and GDPR compliance.
 
@@ -26,7 +29,7 @@ All image processing happens on-device using Google ML Kit. No images or extract
 Works seamlessly on both iOS and Android with a unified API. Built with TurboModule specifications for the new React Native architecture.
 
 **Performance Optimized**
-Designed for mobile performance with efficient processing and the option to run face detection and text recognition in parallel.
+Designed for mobile performance with efficient processing and the option to run face detection, text recognition, and object detection in parallel.
 
 **TypeScript Support**
 Fully typed API provides excellent autocomplete and type safety in your development environment.
@@ -124,6 +127,14 @@ async function requestPermissions() {
 }
 ```
 
+### Fix 16KB Alignment Warning (Android)
+
+If you see a "16KB-compatible" warning during build, add this to `android/gradle.properties`:
+
+```properties
+android.bundle.enableUncompressedNativeLibs=false
+```
+
 ## Basic Usage
 
 The simplest way to use the library is with the `analyzeImage` function. Pass it an image URI and it will return the analysis results:
@@ -137,6 +148,7 @@ async function analyzeMyImage() {
 
     console.log('Contains face:', result.containsFace);
     console.log('Contains text:', result.containsPrintedText);
+    console.log('Contains objects:', result.containsObjects);
 
     if (result.faces) {
       console.log('Number of faces:', result.faces.length);
@@ -145,6 +157,17 @@ async function analyzeMyImage() {
     if (result.printedText) {
       console.log('Extracted text:', result.printedText);
     }
+
+    if (result.objects) {
+      result.objects.forEach((obj, index) => {
+        console.log(`Object ${index + 1}:`);
+        obj.labels.forEach((label) => {
+          console.log(
+            `  ${label.text}: ${(label.confidence * 100).toFixed(1)}%`
+          );
+        });
+      });
+    }
   } catch (error) {
     console.error('Analysis failed:', error);
   }
@@ -164,6 +187,7 @@ import {
 const options: AnalysisOptions = {
   detectFaces: true,
   detectPrintedText: true,
+  detectObjects: true,
   faceDetectionMode: 'accurate',
   minFaceSize: 0.15,
 };
@@ -174,10 +198,13 @@ const result = await analyzeImage('file:///path/to/image.jpg', options);
 ### Available Options
 
 **detectFaces** (boolean, default: true)
-Enable or disable face detection. Set to false if you only need text recognition to improve performance.
+Enable or disable face detection. Set to false if you only need text or object recognition to improve performance.
 
 **detectPrintedText** (boolean, default: true)
-Enable or disable text recognition. Set to false if you only need face detection to improve performance.
+Enable or disable text recognition. Set to false if you only need face or object detection to improve performance.
+
+**detectObjects** (boolean, default: true)
+Enable or disable object detection. Set to false if you only need face or text detection to improve performance.
 
 **faceDetectionMode** ('fast' | 'accurate', default: 'fast')
 Choose between fast processing for real-time scenarios or accurate mode for higher quality detection. Use 'fast' for camera previews and 'accurate' for analyzing stored images.
@@ -229,7 +256,7 @@ async function captureAndAnalyze() {
 
 ## Complete Example Component
 
-Here's a full working example of a React component that lets users select an image and displays the analysis results:
+Here's a full working example of a React component that lets users select an image and displays comprehensive analysis results:
 
 ```typescript
 import React, { useState } from 'react';
@@ -269,6 +296,7 @@ export default function ImageAnalyzer() {
         const analysis = await analyzeImage(uri, {
           detectFaces: true,
           detectPrintedText: true,
+          detectObjects: true,
           faceDetectionMode: 'accurate',
         });
         setResult(analysis);
@@ -304,7 +332,7 @@ export default function ImageAnalyzer() {
 
       {result && !loading && (
         <View style={styles.resultsContainer}>
-          <Text style={styles.resultTitle}>Results</Text>
+          <Text style={styles.resultTitle}>Analysis Results</Text>
 
           <Text style={styles.resultItem}>
             Face Detected: {result.containsFace ? 'Yes' : 'No'}
@@ -314,25 +342,53 @@ export default function ImageAnalyzer() {
             Text Detected: {result.containsPrintedText ? 'Yes' : 'No'}
           </Text>
 
+          <Text style={styles.resultItem}>
+            Objects Detected: {result.containsObjects ? 'Yes' : 'No'}
+          </Text>
+
           {result.faces && result.faces.length > 0 && (
             <View style={styles.section}>
               <Text style={styles.sectionTitle}>
                 Faces Found: {result.faces.length}
               </Text>
               {result.faces.map((face, index) => (
-                <View key={index} style={styles.faceInfo}>
-                  <Text>Face {index + 1}:</Text>
-                  <Text>
-                    Smiling: {(face.smilingProbability! * 100).toFixed(0)}%
-                  </Text>
-                  <Text>
-                    Left Eye Open:{' '}
-                    {(face.leftEyeOpenProbability! * 100).toFixed(0)}%
-                  </Text>
-                  <Text>
-                    Right Eye Open:{' '}
-                    {(face.rightEyeOpenProbability! * 100).toFixed(0)}%
-                  </Text>
+                <View key={index} style={styles.detailBox}>
+                  <Text style={styles.itemTitle}>Face {index + 1}:</Text>
+                  {face.smilingProbability !== undefined && (
+                    <Text style={styles.detailText}>
+                      Smiling: {(face.smilingProbability * 100).toFixed(0)}%
+                    </Text>
+                  )}
+                  {face.leftEyeOpenProbability !== undefined && (
+                    <Text style={styles.detailText}>
+                      Left Eye Open:{' '}
+                      {(face.leftEyeOpenProbability * 100).toFixed(0)}%
+                    </Text>
+                  )}
+                  {face.rightEyeOpenProbability !== undefined && (
+                    <Text style={styles.detailText}>
+                      Right Eye Open:{' '}
+                      {(face.rightEyeOpenProbability * 100).toFixed(0)}%
+                    </Text>
+                  )}
+                </View>
+              ))}
+            </View>
+          )}
+
+          {result.objects && result.objects.length > 0 && (
+            <View style={styles.section}>
+              <Text style={styles.sectionTitle}>
+                Objects Detected: {result.objects.length}
+              </Text>
+              {result.objects.map((obj, index) => (
+                <View key={index} style={styles.detailBox}>
+                  <Text style={styles.itemTitle}>Object {index + 1}:</Text>
+                  {obj.labels.map((label, labelIndex) => (
+                    <Text key={labelIndex} style={styles.detailText}>
+                      {label.text}: {(label.confidence * 100).toFixed(1)}%
+                    </Text>
+                  ))}
                 </View>
               ))}
             </View>
@@ -358,6 +414,11 @@ export default function ImageAnalyzer() {
                   Text Recognition: {result.errors.textRecognition}
                 </Text>
               )}
+              {result.errors.objectDetection && (
+                <Text style={styles.errorText}>
+                  Object Detection: {result.errors.objectDetection}
+                </Text>
+              )}
             </View>
           )}
         </View>
@@ -375,11 +436,13 @@ const styles = StyleSheet.create({
     fontSize: 24,
     fontWeight: 'bold',
     marginBottom: 20,
+    color: '#333',
   },
   image: {
     width: 300,
     height: 300,
     marginVertical: 20,
+    borderRadius: 10,
   },
   loadingContainer: {
     alignItems: 'center',
@@ -388,6 +451,7 @@ const styles = StyleSheet.create({
   loadingText: {
     marginTop: 10,
     fontSize: 16,
+    color: '#666',
   },
   resultsContainer: {
     marginTop: 20,
@@ -399,27 +463,52 @@ const styles = StyleSheet.create({
   resultTitle: {
     fontSize: 20,
     fontWeight: 'bold',
-    marginBottom: 10,
+    marginBottom: 15,
+    color: '#333',
   },
   resultItem: {
     fontSize: 16,
     marginVertical: 5,
+    color: '#555',
   },
   section: {
-    marginTop: 15,
+    marginTop: 20,
+    paddingTop: 15,
+    borderTopWidth: 1,
+    borderTopColor: '#ddd',
   },
   sectionTitle: {
-    fontSize: 16,
+    fontSize: 18,
     fontWeight: 'bold',
-    marginBottom: 8,
+    marginBottom: 10,
+    color: '#007AFF',
   },
-  faceInfo: {
+  detailBox: {
     marginLeft: 10,
-    marginVertical: 5,
+    marginVertical: 8,
+    padding: 10,
+    backgroundColor: '#fff',
+    borderRadius: 8,
+  },
+  itemTitle: {
+    fontSize: 15,
+    fontWeight: '600',
+    marginBottom: 5,
+    color: '#333',
+  },
+  detailText: {
+    fontSize: 14,
+    marginLeft: 5,
+    marginVertical: 2,
+    color: '#666',
   },
   extractedText: {
     fontSize: 14,
     lineHeight: 20,
+    padding: 10,
+    backgroundColor: '#fff',
+    borderRadius: 8,
+    color: '#333',
   },
   errorSection: {
     marginTop: 15,
@@ -436,6 +525,7 @@ const styles = StyleSheet.create({
   errorText: {
     fontSize: 14,
     color: '#d32f2f',
+    marginVertical: 2,
   },
 });
 ```
@@ -465,7 +555,7 @@ Configuration object to customize the analysis behavior. See the Advanced Config
 A Promise that resolves to an AnalysisResult object containing the detection results.
 
 **Throws:**
-An error if the image URI is invalid or if both face detection and text recognition fail.
+An error if the image URI is invalid or if all enabled analyses fail.
 
 ### isAvailable()
 
@@ -488,11 +578,14 @@ This is useful for verifying that the installation was successful before attempt
 interface AnalysisResult {
   containsFace: boolean;
   containsPrintedText: boolean;
+  containsObjects: boolean;
   faces?: FaceData[];
   printedText?: string;
+  objects?: ObjectData[];
   errors?: {
     faceDetection?: string;
     textRecognition?: string;
+    objectDetection?: string;
   };
 }
 ```
@@ -503,14 +596,20 @@ Boolean indicating whether at least one face was detected in the image.
 **containsPrintedText**
 Boolean indicating whether any text was detected in the image.
 
+**containsObjects**
+Boolean indicating whether any objects were detected in the image.
+
 **faces**
 Optional array of FaceData objects, one for each detected face. Only present if faces were detected.
 
 **printedText**
 Optional string containing all the text extracted from the image. Only present if text was detected.
 
+**objects**
+Optional array of ObjectData objects, one for each detected object. Only present if objects were detected.
+
 **errors**
-Optional object containing error messages if either detection method encountered issues. This allows partial results - for example, face detection might succeed while text recognition fails.
+Optional object containing error messages if any detection method encountered issues. This allows partial results - for example, face detection might succeed while text recognition fails.
 
 ### FaceData
 
@@ -544,6 +643,44 @@ The tilt of the head in degrees. A value of 0 means the head is upright, positiv
 **trackingId**
 A unique identifier for the face, useful for tracking the same face across multiple frames in video scenarios.
 
+### ObjectData
+
+```typescript
+interface ObjectData {
+  boundingBox: BoundingBox;
+  trackingId?: number;
+  labels: ObjectLabel[];
+}
+```
+
+**boundingBox**
+The location and size of the detected object within the image.
+
+**trackingId**
+A unique identifier for the object, useful for tracking the same object across multiple frames in video scenarios.
+
+**labels**
+Array of classification labels for the detected object, ordered by confidence score (highest first).
+
+### ObjectLabel
+
+```typescript
+interface ObjectLabel {
+  text: string;
+  confidence: number;
+  index: number;
+}
+```
+
+**text**
+The classification label (e.g., "Dog", "Car", "Person", "Food").
+
+**confidence**
+A number between 0.0 and 1.0 indicating the confidence of the classification. Higher values mean more confident predictions.
+
+**index**
+The internal index of the label in Google ML Kit's classification model.
+
 ### BoundingBox
 
 ```typescript
@@ -555,7 +692,7 @@ interface BoundingBox {
 }
 ```
 
-Represents the rectangular region containing a detected face. The coordinate system has its origin (0, 0) at the top-left corner of the image, with x increasing to the right and y increasing downward. All values are in pixels.
+Represents the rectangular region containing a detected face or object. The coordinate system has its origin (0, 0) at the top-left corner of the image, with x increasing to the right and y increasing downward. All values are in pixels.
 
 ### AnalysisOptions
 
@@ -563,6 +700,7 @@ Represents the rectangular region containing a detected face. The coordinate sys
 interface AnalysisOptions {
   detectFaces?: boolean;
   detectPrintedText?: boolean;
+  detectObjects?: boolean;
   faceDetectionMode?: 'fast' | 'accurate';
   minFaceSize?: number;
 }
@@ -578,6 +716,7 @@ All fields are optional and have sensible defaults. See the Advanced Configurati
 const result = await analyzeImage(photoUri, {
   detectFaces: true,
   detectPrintedText: false,
+  detectObjects: false,
 });
 
 const faceCount = result.faces?.length || 0;
@@ -590,6 +729,7 @@ console.log(`Found ${faceCount} people in the photo`);
 const result = await analyzeImage(documentUri, {
   detectFaces: false,
   detectPrintedText: true,
+  detectObjects: false,
 });
 
 if (result.printedText) {
@@ -602,6 +742,8 @@ if (result.printedText) {
 ```typescript
 const result = await analyzeImage(selfieUri, {
   detectFaces: true,
+  detectPrintedText: false,
+  detectObjects: false,
   minFaceSize: 0.3,
   faceDetectionMode: 'accurate',
 });
@@ -616,19 +758,110 @@ const isValidSelfie =
 const result = await analyzeImage(idCardUri, {
   detectFaces: true,
   detectPrintedText: true,
+  detectObjects: false,
   faceDetectionMode: 'accurate',
 });
 
 const hasRequiredElements = result.containsFace && result.containsPrintedText;
 ```
 
+### Object Recognition and Classification
+
+```typescript
+const result = await analyzeImage(imageUri, {
+  detectFaces: false,
+  detectPrintedText: false,
+  detectObjects: true,
+});
+
+if (result.objects && result.objects.length > 0) {
+  result.objects.forEach((obj) => {
+    const primaryLabel = obj.labels[0];
+    console.log(
+      `Detected: ${primaryLabel.text} (${(
+        primaryLabel.confidence * 100
+      ).toFixed(1)}% confident)`
+    );
+  });
+}
+```
+
+### Smart Photo Organization
+
+```typescript
+const result = await analyzeImage(photoUri, {
+  detectFaces: true,
+  detectPrintedText: false,
+  detectObjects: true,
+});
+
+const tags = [];
+
+if (result.faces && result.faces.length > 0) {
+  tags.push(
+    `${result.faces.length} person${result.faces.length > 1 ? 's' : ''}`
+  );
+}
+
+if (result.objects) {
+  result.objects.forEach((obj) => {
+    if (obj.labels[0].confidence > 0.7) {
+      tags.push(obj.labels[0].text.toLowerCase());
+    }
+  });
+}
+
+console.log('Photo tags:', tags.join(', '));
+```
+
+### Food Recognition
+
+```typescript
+const result = await analyzeImage(foodPhotoUri, {
+  detectFaces: false,
+  detectPrintedText: false,
+  detectObjects: true,
+});
+
+const foodItems = result.objects
+  ?.filter((obj) =>
+    obj.labels.some(
+      (label) =>
+        label.text.toLowerCase().includes('food') && label.confidence > 0.6
+    )
+  )
+  .map((obj) => obj.labels[0].text);
+
+console.log('Food items detected:', foodItems);
+```
+
+### Pet Detection
+
+```typescript
+const result = await analyzeImage(petPhotoUri, {
+  detectFaces: false,
+  detectPrintedText: false,
+  detectObjects: true,
+});
+
+const pets = result.objects?.filter((obj) =>
+  obj.labels.some((label) =>
+    ['dog', 'cat', 'bird', 'fish'].includes(label.text.toLowerCase())
+  )
+);
+
+if (pets && pets.length > 0) {
+  console.log(`Found ${pets.length} pet(s) in the image`);
+}
+```
+
 ## Performance Considerations
 
 **Choose the Right Detection Mode**
 Use 'fast' mode for real-time scenarios like camera previews where speed is more important than perfect accuracy. Use 'accurate' mode when analyzing stored images where quality matters more than speed.
 
 **Disable Unused Features**
-If you only need face detection, set `detectPrintedText: false` to improve performance. Similarly, if you only need text recognition, disable face detection.
+If you only need face detection, set `detectPrintedText: false` and `detectObjects: false` to improve performance. Similarly, if you only need object detection, disable the other features.
 
 **Optimize Image Size**
 Large images take longer to process. Consider resizing images before analysis if you're working with high-resolution photos. Libraries like react-native-image-resizer can help:
@@ -648,11 +881,20 @@ const result = await analyzeImage(resized.uri);
 ```
 
 **First Run Download**
-The first time you use the library, Google ML Kit needs to download its models (approximately 10-15 MB). This only happens once per device, but the first analysis may take longer than subsequent ones.
+The first time you use the library, Google ML Kit needs to download its models:
+
+- Face Detection: approximately 1-2 MB
+- Text Recognition: approximately 10-15 MB
+- Object Detection: approximately 20-30 MB
+
+These models are downloaded automatically and cached on the device. This only happens once per device, but the first analysis may take longer than subsequent ones.
 
 **Cache Results When Appropriate**
 If you're analyzing the same image multiple times, consider caching the results instead of re-processing the image.
 
+**Parallel vs Sequential Processing**
+By default, all enabled detection methods run in parallel for maximum speed. However, this uses more device resources. If battery life is a concern, you can run analyses sequentially by calling `analyzeImage` multiple times with different options.
+
 ## Troubleshooting
 
 ### iOS Module Not Found
@@ -693,6 +935,14 @@ android {
 }
 ```
 
+### Android 16KB Alignment Warning
+
+If you see a warning about "16KB-compatible", add this to `android/gradle.properties`:
+
+```properties
+android.bundle.enableUncompressedNativeLibs=false
+```
+
 ### Permission Denied Errors
 
 Remember that on Android, you need to request permissions at runtime, not just declare them in the manifest:
@@ -714,6 +964,16 @@ Make sure you're using the correct URI format for your platform:
 - Android accepts: file://, content://, or absolute paths
 - iOS accepts: file://, ph://, assets-library://, or absolute paths
 
+### Object Detection Returns No Results
+
+Object detection works best with clear, well-lit images containing common objects. If you're getting no results:
+
+1. Ensure the image quality is good with adequate lighting
+2. Try images with more prominent, well-framed objects
+3. Verify that objects are not too small in the frame
+4. Check that the image isn't too dark, blurry, or low resolution
+5. Remember that ML Kit recognizes common objects best - very specific or unusual items may not be detected
+
 ## Privacy and Security
 
 This library is designed with privacy as a core principle. All image processing happens entirely on-device using Google ML Kit. Your users' images and the data extracted from them never leave their device. No internet connection is required for the library to function, and no data is transmitted to external servers.
@@ -726,9 +986,40 @@ The library includes the following Google ML Kit components:
 
 - Face Detection (Android: version 16.1.5, iOS: version 4.0.0)
 - Text Recognition v2 (Android: version 19.0.0, iOS: version 4.0.0)
+- Object Detection (Android: version 17.0.2, iOS: version 4.0.0)
 
 It's built with TurboModule specifications to be compatible with React Native's new architecture. The package includes full TypeScript type definitions and integrates with iOS via CocoaPods and Android via Gradle.
 
+## Object Detection Capabilities
+
+The object detection feature can recognize a wide variety of common objects across multiple categories:
+
+**Animals**
+Dog, Cat, Bird, Fish, Horse, Rabbit, and various other domestic and wild animals
+
+**Vehicles**
+Car, Truck, Bicycle, Motorcycle, Bus, Train, Airplane, Boat
+
+**Household Items**
+Chair, Table, Bed, Sofa, Lamp, Television, Refrigerator, Microwave
+
+**Food and Beverages**
+Fruits, Vegetables, Beverages, Prepared dishes, Snacks, Desserts
+
+**Electronics**
+Phone, Laptop, Computer, TV, Camera, Keyboard, Mouse
+
+**Clothing and Accessories**
+Shirt, Pants, Shoes, Hat, Bag, Glasses
+
+**Outdoor Objects**
+Trees, Flowers, Buildings, Roads, Signs
+
+**Sports Equipment**
+Ball, Racket, Bicycle, Skateboard
+
+And many more categories. Each detection includes multiple classification labels with confidence scores, allowing you to choose the most appropriate label for your use case or combine multiple labels for more accurate classification.
+
 ## Contributing
 
 Contributions are welcome. Please read the CONTRIBUTING.md file in the repository for guidelines on how to submit issues and pull requests.
@@ -742,16 +1033,15 @@ This project is licensed under the MIT License. See the LICENSE file for complet
 Sushant Singh
 
 Email: sushantbibhu@gmail.com
-
 GitHub: @thisissushant
 
 ## Support and Community
 
 If you need help or want to discuss the library:
 
-- Report bugs or request features via GitHub Issues
-- Join discussions on GitHub Discussions
-- Contact the author directly at sushantbibhu@gmail.com
+Email: sushantbibhu@gmail.com
+Issues: GitHub Issues (https://github.com/thisissushant/mediversal-rn-image-intelligence/issues)
+Discussions: GitHub Discussions (https://github.com/thisissushant/mediversal-rn-image-intelligence/discussions)
 
 ## Acknowledgments
 
@@ -759,4 +1049,6 @@ This library is built on top of Google ML Kit and React Native. Thanks to both t
 
 ---
 
-If this library has been helpful for your project, consider giving it a star on GitHub to help others discover it.
+If this library has been helpful for your project, consider giving it a star on GitHub (https://github.com/thisissushant/mediversal-rn-image-intelligence) to help others discover it.
+
+Made with care for the React Native community.

package/android/build.gradle

@@ -62,6 +62,9 @@ dependencies {
   
   // Google ML Kit - Text Recognition v2 (newer API)
   implementation 'com.google.android.gms:play-services-mlkit-text-recognition:19.0.0'
+
+  // Google ML Kit - Object Detection
+  implementation 'com.google.mlkit:object-detection:17.0.2'
   
   // Coroutines for async operations
   implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.4'

package/android/src/main/java/com/mediversalrnimagintelligence/ImageIntelligencePackage.kt

@@ -1,15 +1,16 @@
 package com.mediversalrnimagintelligence
-
 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.mediversalrnimagintelligence.ObjectDetectionModule
 
 class ImageIntelligencePackage : ReactPackage {
     override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
         return listOf(
             FaceDetectionModule(reactContext),
             TextRecognitionModule(reactContext)
+            ObjectDetectionModule(reactContext)
         )
     }