mediversal-rn-image-intelligence 1.0.6 → 1.0.8

package/README.md

@@ -3,68 +3,130 @@
 [![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)
 
-🎯 **Production-ready React Native library for intelligent image analysis using Google ML Kit (on-device)**
+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.
 
-Analyze images to detect faces, extract printed text, and recognize handwritten content—all processed locally on the device for maximum privacy and performance.
+## Overview
 
-## 🌟 Features
+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.
 
-- **Face Detection**: Detect human faces with detailed metadata (smiling probability, eye open probability, head rotation, etc.)
-- **Text Recognition (OCR)**: Extract printed text from images with high accuracy
-- **Handwriting Recognition**: Recognize handwritten text (requires stroke data)
-- **🚀 On-Device Processing**: All analysis happens locally using Google ML Kit
-- **🔒 Privacy-First**: No data sent to external servers
-- **⚡ Fast & Efficient**: Optimized for mobile performance
-- **📱 Cross-Platform**: Works seamlessly on iOS and Android
-- **🎨 TurboModule Architecture**: Built with React Native New Architecture support
-- **💪 TypeScript**: Fully typed API for excellent developer experience
+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.
 
-## 📦 Installation
+## Key Features
+
+**Face Detection**
+Detect human faces in images with comprehensive metadata including smiling probability, eye open probability, and head rotation angles. Perfect for selfie validation, group photo analysis, and identity verification workflows.
+
+**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.
+
+**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.
+
+**Cross-Platform Support**
+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.
+
+**TypeScript Support**
+Fully typed API provides excellent autocomplete and type safety in your development environment.
+
+## Installation
+
+Install the package using npm:
 
 ```bash
 npm install mediversal-rn-image-intelligence
-# or
+```
+
+Or if you prefer yarn:
+
+```bash
 yarn add mediversal-rn-image-intelligence
 ```
 
-### iOS Setup
+## Platform-Specific Setup
+
+### iOS Configuration
+
+After installing the package, you'll need to install the CocoaPods dependencies. Navigate to your iOS directory:
 
 ```bash
-cd ios && pod install
+cd ios
+pod install
+cd ..
 ```
 
-**Required**: Add the following to your `Info.plist` if you need camera or photo library access:
+Add the required permissions to your `ios/YourApp/Info.plist` file:
 
 ```xml
 <key>NSCameraUsageDescription</key>
-<string>We need access to your camera to capture images for analysis</string>
+<string>We need camera access to capture and analyze images</string>
 <key>NSPhotoLibraryUsageDescription</key>
-<string>We need access to your photo library to analyze images</string>
+<string>We need photo library access to select and analyze images</string>
 ```
 
-### Android Setup
+Requirements for iOS:
+
+- iOS 12.0 or higher
+- Xcode 12.0 or higher
+- CocoaPods 1.10 or higher
 
-The library will automatically configure the required Google ML Kit dependencies. Ensure your `minSdkVersion` is at least 21:
+### Android Configuration
+
+First, make sure your minimum SDK version is set to 21 or higher in `android/build.gradle`:
 
 ```gradle
-// android/build.gradle
 buildscript {
     ext {
         minSdkVersion = 21
+        compileSdkVersion = 33
+        targetSdkVersion = 33
     }
 }
 ```
 
-**Required**: Add permissions to your `AndroidManifest.xml` if needed:
+Update your `android/app/build.gradle` to use Java 17:
+
+```gradle
+android {
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+
+    kotlinOptions {
+        jvmTarget = "17"
+    }
+}
+```
+
+Add the necessary permissions to `android/app/src/main/AndroidManifest.xml`:
 
 ```xml
-<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
 <uses-permission android:name="android.permission.CAMERA" />
+<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
+<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
 ```
 
-## 🚀 Usage
+Remember to request these permissions at runtime in your application code:
 
-### Basic Example
+```typescript
+import { PermissionsAndroid, Platform } from 'react-native';
+
+async function requestPermissions() {
+  if (Platform.OS === 'android') {
+    await PermissionsAndroid.requestMultiple([
+      PermissionsAndroid.PERMISSIONS.CAMERA,
+      PermissionsAndroid.PERMISSIONS.READ_EXTERNAL_STORAGE,
+    ]);
+  }
+}
+```
+
+## 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:
 
 ```typescript
 import { analyzeImage } from 'mediversal-rn-image-intelligence';
@@ -74,21 +136,12 @@ async function analyzeMyImage() {
     const result = await analyzeImage('file:///path/to/image.jpg');
 
     console.log('Contains face:', result.containsFace);
-    console.log('Contains printed text:', result.containsPrintedText);
-    console.log('Contains handwritten text:', result.containsHandwrittenText);
+    console.log('Contains text:', result.containsPrintedText);
 
-    // Access detected faces
     if (result.faces) {
-      result.faces.forEach((face, index) => {
-        console.log(`Face ${index + 1}:`);
-        console.log('  Bounding box:', face.boundingBox);
-        console.log('  Smiling:', face.smilingProbability);
-        console.log('  Left eye open:', face.leftEyeOpenProbability);
-        console.log('  Right eye open:', face.rightEyeOpenProbability);
-      });
+      console.log('Number of faces:', result.faces.length);
     }
 
-    // Access extracted text
     if (result.printedText) {
       console.log('Extracted text:', result.printedText);
     }
@@ -98,7 +151,9 @@ async function analyzeMyImage() {
 }
 ```
 
-### Advanced Example with Options
+## Advanced Configuration
+
+You can customize the analysis behavior by passing an options object:
 
 ```typescript
 import {
@@ -109,15 +164,32 @@ import {
 const options: AnalysisOptions = {
   detectFaces: true,
   detectPrintedText: true,
-  detectHandwrittenText: false, // Skip handwriting for performance
-  faceDetectionMode: 'accurate', // 'fast' or 'accurate'
-  minFaceSize: 0.15, // Minimum face size (0.0 to 1.0)
+  faceDetectionMode: 'accurate',
+  minFaceSize: 0.15,
 };
 
 const result = await analyzeImage('file:///path/to/image.jpg', options);
 ```
 
-### With Image Picker
+### Available Options
+
+**detectFaces** (boolean, default: true)
+Enable or disable face detection. Set to false if you only need text 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.
+
+**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.
+
+**minFaceSize** (number, default: 0.1)
+The minimum face size to detect, expressed as a proportion of the image's smaller dimension. Valid range is 0.0 to 1.0. Increase this value to filter out small or distant faces.
+
+## Integration with Image Picker
+
+This library works seamlessly with React Native image picker libraries. Here are examples using react-native-image-picker:
+
+### Selecting from Gallery
 
 ```typescript
 import { launchImageLibrary } from 'react-native-image-picker';
@@ -136,11 +208,41 @@ async function pickAndAnalyze() {
 }
 ```
 
-### React Component Example
+### Capturing with Camera
+
+```typescript
+import { launchCamera } from 'react-native-image-picker';
+import { analyzeImage } from 'mediversal-rn-image-intelligence';
+
+async function captureAndAnalyze() {
+  const response = await launchCamera({
+    mediaType: 'photo',
+    quality: 1,
+  });
+
+  if (response.assets && response.assets[0].uri) {
+    const result = await analyzeImage(response.assets[0].uri);
+    console.log(result);
+  }
+}
+```
+
+## Complete Example Component
+
+Here's a full working example of a React component that lets users select an image and displays the analysis results:
 
 ```typescript
 import React, { useState } from 'react';
-import { View, Button, Text, Image } from 'react-native';
+import {
+  View,
+  Button,
+  Text,
+  Image,
+  StyleSheet,
+  ScrollView,
+  ActivityIndicator,
+  Alert,
+} from 'react-native';
 import { launchImageLibrary } from 'react-native-image-picker';
 import {
   analyzeImage,
@@ -153,7 +255,10 @@ export default function ImageAnalyzer() {
   const [loading, setLoading] = useState(false);
 
   const selectAndAnalyze = async () => {
-    const response = await launchImageLibrary({ mediaType: 'photo' });
+    const response = await launchImageLibrary({
+      mediaType: 'photo',
+      quality: 1,
+    });
 
     if (response.assets && response.assets[0].uri) {
       const uri = response.assets[0].uri;
@@ -161,9 +266,14 @@ export default function ImageAnalyzer() {
       setLoading(true);
 
       try {
-        const analysis = await analyzeImage(uri);
+        const analysis = await analyzeImage(uri, {
+          detectFaces: true,
+          detectPrintedText: true,
+          faceDetectionMode: 'accurate',
+        });
         setResult(analysis);
       } catch (error) {
+        Alert.alert('Error', 'Failed to analyze image');
         console.error(error);
       } finally {
         setLoading(false);
@@ -172,86 +282,269 @@ export default function ImageAnalyzer() {
   };
 
   return (
-    <View style={{ padding: 20 }}>
+    <ScrollView contentContainerStyle={styles.container}>
+      <Text style={styles.title}>Image Intelligence Demo</Text>
+
       <Button title="Select Image" onPress={selectAndAnalyze} />
 
       {imageUri && (
-        <Image source={{ uri: imageUri }} style={{ width: 300, height: 300 }} />
+        <Image
+          source={{ uri: imageUri }}
+          style={styles.image}
+          resizeMode="contain"
+        />
       )}
 
-      {loading && <Text>Analyzing...</Text>}
+      {loading && (
+        <View style={styles.loadingContainer}>
+          <ActivityIndicator size="large" color="#007AFF" />
+          <Text style={styles.loadingText}>Analyzing...</Text>
+        </View>
+      )}
+
+      {result && !loading && (
+        <View style={styles.resultsContainer}>
+          <Text style={styles.resultTitle}>Results</Text>
+
+          <Text style={styles.resultItem}>
+            Face Detected: {result.containsFace ? 'Yes' : 'No'}
+          </Text>
 
-      {result && (
-        <View style={{ marginTop: 20 }}>
-          <Text>Faces detected: {result.containsFace ? 'Yes' : 'No'}</Text>
-          <Text>
-            Text detected: {result.containsPrintedText ? 'Yes' : 'No'}
+          <Text style={styles.resultItem}>
+            Text Detected: {result.containsPrintedText ? 'Yes' : 'No'}
           </Text>
-          {result.faces && <Text>Number of faces: {result.faces.length}</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>
+              ))}
+            </View>
+          )}
+
           {result.printedText && (
-            <Text>Extracted text: {result.printedText}</Text>
+            <View style={styles.section}>
+              <Text style={styles.sectionTitle}>Extracted Text:</Text>
+              <Text style={styles.extractedText}>{result.printedText}</Text>
+            </View>
+          )}
+
+          {result.errors && (
+            <View style={styles.errorSection}>
+              <Text style={styles.errorTitle}>Errors:</Text>
+              {result.errors.faceDetection && (
+                <Text style={styles.errorText}>
+                  Face Detection: {result.errors.faceDetection}
+                </Text>
+              )}
+              {result.errors.textRecognition && (
+                <Text style={styles.errorText}>
+                  Text Recognition: {result.errors.textRecognition}
+                </Text>
+              )}
+            </View>
           )}
         </View>
       )}
-    </View>
+    </ScrollView>
   );
 }
+
+const styles = StyleSheet.create({
+  container: {
+    padding: 20,
+    alignItems: 'center',
+  },
+  title: {
+    fontSize: 24,
+    fontWeight: 'bold',
+    marginBottom: 20,
+  },
+  image: {
+    width: 300,
+    height: 300,
+    marginVertical: 20,
+  },
+  loadingContainer: {
+    alignItems: 'center',
+    marginVertical: 20,
+  },
+  loadingText: {
+    marginTop: 10,
+    fontSize: 16,
+  },
+  resultsContainer: {
+    marginTop: 20,
+    padding: 15,
+    backgroundColor: '#f5f5f5',
+    borderRadius: 10,
+    width: '100%',
+  },
+  resultTitle: {
+    fontSize: 20,
+    fontWeight: 'bold',
+    marginBottom: 10,
+  },
+  resultItem: {
+    fontSize: 16,
+    marginVertical: 5,
+  },
+  section: {
+    marginTop: 15,
+  },
+  sectionTitle: {
+    fontSize: 16,
+    fontWeight: 'bold',
+    marginBottom: 8,
+  },
+  faceInfo: {
+    marginLeft: 10,
+    marginVertical: 5,
+  },
+  extractedText: {
+    fontSize: 14,
+    lineHeight: 20,
+  },
+  errorSection: {
+    marginTop: 15,
+    padding: 10,
+    backgroundColor: '#ffebee',
+    borderRadius: 5,
+  },
+  errorTitle: {
+    fontSize: 16,
+    fontWeight: 'bold',
+    color: '#c62828',
+    marginBottom: 5,
+  },
+  errorText: {
+    fontSize: 14,
+    color: '#d32f2f',
+  },
+});
 ```
 
-## 📚 API Reference
+## API Reference
+
+### analyzeImage()
 
-### `analyzeImage(imageUri: string, options?: AnalysisOptions): Promise<AnalysisResult>`
+```typescript
+analyzeImage(imageUri: string, options?: AnalysisOptions): Promise<AnalysisResult>
+```
 
-Main function to analyze an image.
+Analyzes an image and returns the detection results.
 
 **Parameters:**
 
-- `imageUri` (string): Local file URI. Supported formats:
-  - Android: `file:///path/to/image.jpg`, `content://...`, or absolute path
-  - iOS: `file:///path/to/image.jpg`, `ph://...`, `assets-library://...`, or absolute path
-- `options` (AnalysisOptions, optional): Configuration options
+**imageUri** (string, required)
+The local file URI pointing to the image you want to analyze. Supported URI formats vary by platform:
 
-**Returns:** Promise<AnalysisResult>
+- Android: file://, content://, or absolute filesystem paths
+- iOS: file://, ph://, assets-library://, or absolute filesystem paths
 
-### `isAvailable(): Promise<boolean>`
+**options** (AnalysisOptions, optional)
+Configuration object to customize the analysis behavior. See the Advanced Configuration section for available options.
 
-Check if the library is properly installed and native modules are available.
+**Returns:**
+A Promise that resolves to an AnalysisResult object containing the detection results.
 
-## 📋 Types
+**Throws:**
+An error if the image URI is invalid or if both face detection and text recognition fail.
 
-### `AnalysisResult`
+### isAvailable()
+
+```typescript
+isAvailable(): Promise<boolean>
+```
+
+Checks whether the native modules are properly linked and available for use.
+
+**Returns:**
+A Promise that resolves to true if the library is ready to use, false otherwise.
+
+This is useful for verifying that the installation was successful before attempting to analyze images.
+
+## TypeScript Type Definitions
+
+### AnalysisResult
 
 ```typescript
 interface AnalysisResult {
   containsFace: boolean;
   containsPrintedText: boolean;
-  containsHandwrittenText: boolean;
   faces?: FaceData[];
   printedText?: string;
-  handwrittenText?: string;
   errors?: {
     faceDetection?: string;
     textRecognition?: string;
-    handwritingRecognition?: string;
   };
 }
 ```
 
-### `FaceData`
+**containsFace**
+Boolean indicating whether at least one face was detected in the image.
+
+**containsPrintedText**
+Boolean indicating whether any text was 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.
+
+**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.
+
+### FaceData
 
 ```typescript
 interface FaceData {
   boundingBox: BoundingBox;
-  smilingProbability?: number; // 0.0 to 1.0
-  leftEyeOpenProbability?: number; // 0.0 to 1.0
-  rightEyeOpenProbability?: number; // 0.0 to 1.0
-  headEulerAngleY?: number; // Yaw in degrees
-  headEulerAngleZ?: number; // Roll in degrees
+  smilingProbability?: number;
+  leftEyeOpenProbability?: number;
+  rightEyeOpenProbability?: number;
+  headEulerAngleY?: number;
+  headEulerAngleZ?: number;
   trackingId?: number;
 }
 ```
 
-### `BoundingBox`
+**boundingBox**
+The location and size of the detected face within the image.
+
+**smilingProbability**
+A number between 0.0 and 1.0 indicating the likelihood that the person is smiling. 0.0 means definitely not smiling, 1.0 means definitely smiling, and 0.5 indicates uncertainty.
+
+**leftEyeOpenProbability** and **rightEyeOpenProbability**
+Numbers between 0.0 and 1.0 indicating the likelihood that each eye is open.
+
+**headEulerAngleY** (yaw)
+The rotation of the head from left to right in degrees. A value of 0 means the face is looking straight at the camera, positive values mean the head is turned to the right, and negative values mean turned to the left.
+
+**headEulerAngleZ** (roll)
+The tilt of the head in degrees. A value of 0 means the head is upright, positive values mean tilted clockwise, and negative values mean tilted counter-clockwise.
+
+**trackingId**
+A unique identifier for the face, useful for tracking the same face across multiple frames in video scenarios.
+
+### BoundingBox
 
 ```typescript
 interface BoundingBox {
@@ -262,100 +555,208 @@ interface BoundingBox {
 }
 ```
 
-### `AnalysisOptions`
+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.
+
+### AnalysisOptions
 
 ```typescript
 interface AnalysisOptions {
-  detectFaces?: boolean; // default: true
-  detectPrintedText?: boolean; // default: true
-  detectHandwrittenText?: boolean; // default: true
-  faceDetectionMode?: 'fast' | 'accurate'; // default: 'fast'
-  minFaceSize?: number; // 0.0 to 1.0, default: 0.1
+  detectFaces?: boolean;
+  detectPrintedText?: boolean;
+  faceDetectionMode?: 'fast' | 'accurate';
+  minFaceSize?: number;
+}
+```
+
+All fields are optional and have sensible defaults. See the Advanced Configuration section for detailed descriptions.
+
+## Common Use Cases
+
+### Counting People in Group Photos
+
+```typescript
+const result = await analyzeImage(photoUri, {
+  detectFaces: true,
+  detectPrintedText: false,
+});
+
+const faceCount = result.faces?.length || 0;
+console.log(`Found ${faceCount} people in the photo`);
+```
+
+### Document Scanning and Text Extraction
+
+```typescript
+const result = await analyzeImage(documentUri, {
+  detectFaces: false,
+  detectPrintedText: true,
+});
+
+if (result.printedText) {
+  await saveToDatabase(result.printedText);
 }
 ```
 
-## ⚡ Performance Tips
+### Selfie Validation
+
+```typescript
+const result = await analyzeImage(selfieUri, {
+  detectFaces: true,
+  minFaceSize: 0.3,
+  faceDetectionMode: 'accurate',
+});
+
+const isValidSelfie =
+  result.faces?.length === 1 && result.faces[0].smilingProbability! > 0.5;
+```
+
+### ID Card and Document Verification
 
-1. **Use 'fast' mode for real-time applications**: The `faceDetectionMode: 'fast'` option provides better performance for live camera feeds.
+```typescript
+const result = await analyzeImage(idCardUri, {
+  detectFaces: true,
+  detectPrintedText: true,
+  faceDetectionMode: 'accurate',
+});
 
-2. **Disable unused features**: If you only need face detection, disable text recognition:
+const hasRequiredElements = result.containsFace && result.containsPrintedText;
+```
 
-   ```typescript
-   analyzeImage(uri, {
-     detectPrintedText: false,
-     detectHandwrittenText: false,
-   });
-   ```
+## Performance Considerations
 
-3. **Optimize image size**: Resize large images before analysis to improve processing time.
+**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.
 
-4. **Parallel processing**: The library automatically runs all enabled analyses in parallel for maximum efficiency.
+**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.
 
-## 🔒 Privacy & Security
+**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:
 
-All image processing happens **locally on the device** using Google ML Kit's on-device APIs. No image data is ever sent to external servers, ensuring:
+```typescript
+import ImageResizer from 'react-native-image-resizer';
 
-- ✅ Complete user privacy
-- ✅ Offline functionality
-- ✅ Faster processing
-- ✅ No data usage costs
-- ✅ GDPR & CCPA compliance
+const resized = await ImageResizer.createResizedImage(
+  uri,
+  1024,
+  1024,
+  'JPEG',
+  80
+);
 
-## 🐛 Troubleshooting
+const result = await analyzeImage(resized.uri);
+```
 
-### iOS: "Module not found"
+**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.
 
-Make sure you've run `pod install`:
+**Cache Results When Appropriate**
+If you're analyzing the same image multiple times, consider caching the results instead of re-processing the image.
+
+## Troubleshooting
+
+### iOS Module Not Found
+
+If you see "Module not found" errors on iOS, make sure you've installed the CocoaPods dependencies:
 
 ```bash
-cd ios && pod install
+cd ios
+pod install
+cd ..
+npx react-native run-ios
 ```
 
-### Android: Gradle build errors
+### Android Gradle Build Errors
 
-Ensure your `minSdkVersion` is at least 21 and you're using Java 11:
+For generic Gradle build errors, try cleaning the build:
+
+```bash
+cd android
+./gradlew clean
+cd ..
+npx react-native run-android
+```
+
+### Java Version Compatibility Issues
+
+If you encounter compilation errors related to Java compatibility, ensure your `android/app/build.gradle` specifies Java 17:
 
 ```gradle
 android {
     compileOptions {
-        sourceCompatibility JavaVersion.VERSION_11
-        targetCompatibility JavaVersion.VERSION_11
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+    kotlinOptions {
+        jvmTarget = "17"
     }
 }
 ```
 
-### Image URI format errors
+### Permission Denied Errors
 
-- **Android**: Use `file://`, `content://`, or absolute paths
-- **iOS**: Use `file://`, `ph://`, `assets-library://`, or absolute paths
+Remember that on Android, you need to request permissions at runtime, not just declare them in the manifest:
 
-### Digital Ink Recognition limitation
+```typescript
+import { PermissionsAndroid, Platform } from 'react-native';
+
+if (Platform.OS === 'android') {
+  await PermissionsAndroid.request(
+    PermissionsAndroid.PERMISSIONS.READ_EXTERNAL_STORAGE
+  );
+}
+```
+
+### Image URI Format Issues
+
+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
+
+## Privacy and Security
 
-The Digital Ink Recognition API is designed for real-time stroke data (from drawing apps), not static images. For handwriting recognition in static images, consider:
+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.
 
-- Using Google Cloud Vision API (cloud-based)
-- Pre-processing images to extract stroke information
-- Using alternative OCR solutions specifically designed for handwriting
+This makes the library GDPR compliant by default, as user data stays under their control. The library doesn't collect any analytics or telemetry, and the source code is open for review to verify these privacy guarantees.
 
-## 🤝 Contributing
+## Technical Details
 
-Contributions are welcome! Please feel free to submit a Pull Request.
+The library includes the following Google ML Kit components:
 
-## 📄 License
+- 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)
 
-MIT © Mediversal
+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.
 
-## 🙏 Acknowledgments
+## Contributing
 
-Built with:
+Contributions are welcome. Please read the CONTRIBUTING.md file in the repository for guidelines on how to submit issues and pull requests.
 
-- [Google ML Kit](https://developers.google.com/ml-kit)
-- [React Native](https://reactnative.dev/)
+## License
 
-## 📞 Support
+This project is licensed under the MIT License. See the LICENSE file for complete terms.
 
-- 📧 Email: sushantbibhu@gmail.com
-- 🐛 Issues: [GitHub Issues](https://github.com/thisissushant/mediversal-rn-image-intelligence)
-- 📖 Documentation: [GitHub Wiki](https://github.com/thisissushant/mediversal-rn-image-intelligence)
+## Author
+
+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
+
+## Acknowledgments
+
+This library is built on top of Google ML Kit and React Native. Thanks to both teams for their excellent work that makes projects like this possible.
 
 ---
+
+If this library has been helpful for your project, consider giving it a star on GitHub to help others discover it.