react-native-mdl-verification 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/PUBLISHING.md

@@ -0,0 +1,143 @@
+# Publishing to NPM
+
+Follow these steps to publish your `react-native-mdl-verification` package to npm:
+
+## Prerequisites
+
+1. **NPM Account**: Create an account at [npmjs.com](https://www.npmjs.com/) if you don't have one
+2. **Login to NPM**: Run `npm login` in your terminal and enter your credentials
+
+## Pre-Publishing Checklist
+
+1. **Update package.json**: Make sure all fields are correct
+   - `name`: Should be unique on npm (check availability at npmjs.com)
+   - `version`: Start with `1.0.0` for first release
+   - `description`: Clear description of what the package does
+   - `author`: Your name or organization
+   - `repository`: Your git repository URL
+   - `license`: Typically MIT
+
+2. **Verify AAR files are included**:
+   ```bash
+   ls android/libs/
+   ```
+   Should show:
+   - `checkmdl-mvalid-sdk-1.6.0-release.aar`
+   - `mvalid-sdk-1.6.0-SNAPSHOT.aar`
+
+3. **Test the package locally** (optional but recommended):
+   ```bash
+   npm pack
+   ```
+   This creates a `.tgz` file you can test in another project:
+   ```bash
+   npm install /path/to/react-native-mdl-verification-1.0.0.tgz
+   ```
+
+## Publishing Steps
+
+### 1. Navigate to package directory
+```bash
+cd C:\src_send\projects\react-native\react-native-mdl-verification
+```
+
+### 2. Review what will be published
+```bash
+npm pack --dry-run
+```
+This shows all files that will be included in the package.
+
+### 3. Publish to npm
+```bash
+npm publish
+```
+
+If your package name is scoped (e.g., `@yourorg/react-native-mdl-verification`), use:
+```bash
+npm publish --access public
+```
+
+## After Publishing
+
+### Update version for future releases
+Follow [Semantic Versioning](https://semver.org/):
+- **Patch** (1.0.1): Bug fixes - `npm version patch`
+- **Minor** (1.1.0): New features (backwards compatible) - `npm version minor`
+- **Major** (2.0.0): Breaking changes - `npm version major`
+
+Then publish again:
+```bash
+npm publish
+```
+
+## Using the Published Package
+
+In your React Native project:
+
+```bash
+npm install react-native-mdl-verification
+# or
+yarn add react-native-mdl-verification
+```
+
+For React Native 0.60+, the package will auto-link.
+
+## Alternative: Private NPM Registry
+
+If you want to keep the package private:
+
+### Option 1: NPM Private Packages (Paid)
+```bash
+npm publish --access restricted
+```
+
+### Option 2: GitHub Packages
+1. Update package.json:
+   ```json
+   {
+     "name": "@yourusername/react-native-mdl-verification",
+     "publishConfig": {
+       "registry": "https://npm.pkg.github.com"
+     }
+   }
+   ```
+
+2. Authenticate with GitHub:
+   ```bash
+   npm login --registry=https://npm.pkg.github.com
+   ```
+
+3. Publish:
+   ```bash
+   npm publish
+   ```
+
+### Option 3: Local/File-based Install
+Instead of publishing, use a local path or git URL:
+```bash
+npm install /path/to/react-native-mdl-verification
+# or
+npm install git+https://github.com/yourusername/react-native-mdl-verification.git
+```
+
+## Troubleshooting
+
+### Error: Package name already exists
+- Choose a different name in package.json
+- Or use a scoped package: `@yourorg/react-native-mdl-verification`
+
+### Error: Not logged in
+```bash
+npm login
+```
+
+### Error: Access denied
+Make sure you have permission to publish under that package name.
+
+## Documentation
+
+After publishing, your package will be available at:
+- https://www.npmjs.com/package/react-native-mdl-verification
+- Can be installed with: `npm install react-native-mdl-verification`
+
+The README.md will be displayed on the npm package page automatically.

package/README.md

@@ -0,0 +1,178 @@
+# react-native-mdl-verification
+
+React Native bridge for MDL (Mobile Driver's License) verification using CheckMDL SDK.
+
+## Installation
+
+```bash
+npm install react-native-mdl-verification
+# or
+yarn add react-native-mdl-verification
+```
+
+### Android Setup
+
+The package includes the required AAR files for the CheckMDL SDK. No additional manual linking is needed for React Native 0.60+.
+
+#### Required Permissions
+
+Add the following permissions to your `android/app/src/main/AndroidManifest.xml`:
+
+```xml
+<uses-permission android:name="android.permission.INTERNET" />
+<uses-permission android:name="android.permission.BLUETOOTH" />
+<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
+<uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
+<uses-permission android:name="android.permission.BLUETOOTH_SCAN" />
+<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
+<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
+<uses-feature android:name="android.hardware.bluetooth_le" android:required="true" />
+```
+
+## Usage
+
+### Initialize the SDK
+
+```javascript
+import MdlVerification from 'react-native-mdl-verification';
+
+// Initialize with your license key
+await MdlVerification.initialize('YOUR_LICENSE_KEY');
+```
+
+### Start Verification
+
+```javascript
+try {
+  const result = await MdlVerification.startVerification({
+    stan: '000001',
+    terminalId: 'TERMINAL_001',
+    merchantId: 'MERCHANT_001'
+  });
+
+  if (result.isSuccessful) {
+    console.log('Verification successful!');
+    console.log('MDL Token:', result.mdlToken);
+    console.log('Document Type:', result.docType);
+    console.log('Document Valid:', result.docValid);
+  } else {
+    console.log('Verification failed:', result.successMesg);
+  }
+} catch (error) {
+  console.error('Verification error:', error);
+}
+```
+
+### Get Detailed Verification Data
+
+```javascript
+try {
+  const detailedData = await MdlVerification.getDetailedVerificationData(mdlToken);
+  console.log('Detailed data:', detailedData);
+} catch (error) {
+  console.error('Error getting detailed data:', error);
+}
+```
+
+### Listen to Verification Events
+
+```javascript
+// Listen for progress updates
+const progressListener = MdlVerification.addListener(
+  MdlVerification.Events.VERIFICATION_PROGRESS,
+  (progress) => {
+    console.log('Progress:', progress.status);
+    console.log('Log:', progress.logData);
+  }
+);
+
+// Listen for completion
+const completeListener = MdlVerification.addListener(
+  MdlVerification.Events.VERIFICATION_COMPLETE,
+  (result) => {
+    console.log('Verification complete:', result);
+  }
+);
+
+// Clean up listeners when done
+progressListener.remove();
+completeListener.remove();
+
+// Or remove all listeners for an event
+MdlVerification.removeAllListeners(MdlVerification.Events.VERIFICATION_PROGRESS);
+```
+
+## API
+
+### Methods
+
+#### `initialize(licenseKey: string): Promise<void>`
+
+Initialize the MDL verification SDK with your license key.
+
+#### `startVerification(options: VerificationOptions): Promise<VerificationResponse>`
+
+Start the MDL verification process.
+
+**Options:**
+- `stan` (string): Station number
+- `terminalId` (string): Terminal ID
+- `merchantId` (string): Merchant ID
+
+**Returns:** `VerificationResponse` object
+
+#### `getDetailedVerificationData(mdlToken: string): Promise<DetailedVerificationData>`
+
+Get detailed verification data using the MDL token from the verification response.
+
+#### `addListener(eventName: string, listener: Function): Subscription`
+
+Add an event listener for verification events.
+
+**Events:**
+- `MdlVerification.Events.VERIFICATION_PROGRESS` - Progress updates during verification
+- `MdlVerification.Events.VERIFICATION_COMPLETE` - Verification completed
+
+### Types
+
+#### `VerificationResponse`
+
+```typescript
+interface VerificationResponse {
+  command?: string;
+  stan?: string;
+  terminalId?: string;
+  merchantId?: string;
+  success?: string;
+  successMesg?: string;
+  status?: number;
+  mdlToken?: string;
+  docType?: string;
+  docValid?: string;
+  authMethod?: string;
+  authSuccess?: string;
+  msoValid?: string;
+  cert?: string;
+  ica_cert?: string;
+  isSuccessful?: boolean;
+}
+```
+
+#### `ProgressResponse`
+
+```typescript
+interface ProgressResponse {
+  command?: string;
+  status?: string;
+  logData?: string;
+  logLevel?: string;
+}
+```
+
+## License
+
+MIT
+
+## Support
+
+For issues and questions, please visit the [GitHub repository](https://github.com/yourusername/react-native-mdl-verification).

package/android/build.gradle

@@ -0,0 +1,97 @@
+buildscript {
+    ext.kotlin_version = '1.9.22'
+    
+    repositories {
+        google()
+        mavenCentral()
+    }
+    
+    dependencies {
+        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version")
+    }
+}
+
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+
+def safeExtGet(prop, fallback) {
+    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+}
+
+android {
+    compileSdkVersion safeExtGet('compileSdkVersion', 34)
+    buildToolsVersion safeExtGet('buildToolsVersion', '34.0.0')
+    
+    namespace "com.mdlverification"
+    
+    defaultConfig {
+        minSdkVersion safeExtGet('minSdkVersion', 26)
+        targetSdkVersion safeExtGet('targetSdkVersion', 34)
+        versionCode 1
+        versionName "1.0.0"
+    }
+    
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+        }
+    }
+    
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+    
+    kotlinOptions {
+        jvmTarget = '17'
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+    flatDir {
+        dirs 'libs'
+    }
+}
+
+dependencies {
+    // React Native
+    implementation 'com.facebook.react:react-native:+'
+    
+    // Material Components required by checkmdl-verifier
+    implementation "com.google.android.material:material:1.11.0"
+    
+    // AndroidX ViewModel dependencies required by checkmdl SDK
+    implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:2.6.2"
+    implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.6.2"
+    implementation "androidx.activity:activity-ktx:1.8.2"
+    implementation "androidx.core:core-ktx:1.12.0"
+    implementation "androidx.appcompat:appcompat:1.6.1"
+    
+    // Compose dependencies required by checkmdl SDK
+    implementation platform("androidx.compose:compose-bom:2024.02.00")
+    implementation "androidx.activity:activity-compose:1.8.2"
+    implementation "androidx.compose.ui:ui"
+    implementation "androidx.compose.material:material"
+    
+    // Additional dependencies required by mvalid SDK
+    implementation "com.google.code.gson:gson:2.10.1"
+    implementation "com.upokecenter:cbor:4.5.2"
+    implementation "commons-codec:commons-codec:1.15"
+    implementation "org.bouncycastle:bcprov-jdk15on:1.70"
+    implementation "org.bouncycastle:bcpkix-jdk15on:1.70"
+    implementation "com.nimbusds:nimbus-jose-jwt:9.31"
+    implementation "org.apache.commons:commons-lang3:3.12.0"
+    
+    // Ktor dependencies
+    implementation "io.ktor:ktor-client-core:2.3.8"
+    implementation "io.ktor:ktor-client-android:2.3.8"
+    implementation "io.ktor:ktor-client-content-negotiation:2.3.8"
+    implementation "io.ktor:ktor-serialization-gson:2.3.8"
+    
+    // CheckMDL SDK (AAR files)
+    implementation(name: 'checkmdl-mvalid-sdk-1.6.0-release', ext: 'aar')
+    implementation(name: 'mvalid-sdk-1.6.0-SNAPSHOT', ext: 'aar')
+}

package/android/proguard-rules.pro

@@ -0,0 +1,16 @@
+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# Keep CheckMDL SDK classes
+-keep class com.checkmdl.mdlvalid.sdk.** { *; }
+-keep class com.scytales.mvalid.sdk.** { *; }
+
+# Keep React Native classes
+-keep class com.facebook.react.** { *; }
+
+# Keep module classes
+-keep class com.mdlverification.** { *; }

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,13 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.BLUETOOTH" />
+    <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
+    <uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
+    <uses-permission android:name="android.permission.BLUETOOTH_SCAN" />
+    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
+    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
+    
+    <uses-feature android:name="android.hardware.bluetooth_le" android:required="true" />
+    
+</manifest>

package/android/src/main/java/com/mdlverification/MdlVerificationBridge.kt

@@ -0,0 +1,214 @@
+package com.mdlverification
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import android.util.Log
+import com.checkmdl.mdlvalid.sdk.*
+import com.scytales.mvalid.sdk.*
+import androidx.activity.ComponentActivity
+
+class MdlVerificationBridge(reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+    private lateinit var coordinator: MdlVerificationCoordinator
+
+    companion object {
+        private const val TAG = "MdlVerificationBridge"
+    }
+
+    override fun getName(): String {
+        return "MdlVerification"
+    }
+
+    private fun sendEvent(eventName: String, params: WritableMap?) {
+        reactApplicationContext
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(eventName, params)
+    }
+
+    private fun convertVerificationResponseToWritableMap(response: VerificationResponse): WritableMap {
+        val map = Arguments.createMap()
+        
+        try {
+            map.putString("command", response.command ?: "")
+            map.putString("stan", response.stan ?: "")
+            map.putString("terminalId", response.terminalId ?: "")
+            map.putString("merchantId", response.merchantId ?: "")
+            map.putString("success", response.success ?: "")
+            map.putString("successMesg", response.successMesg ?: "")
+            map.putInt("status", response.status ?: 0)
+            map.putString("mdlToken", response.mdlToken ?: "")
+            map.putString("docType", response.docType ?: "")
+            map.putString("docValid", response.docValid ?: "")
+            map.putString("authMethod", response.authMethod ?: "")
+            map.putString("authSuccess", response.authSuccess ?: "")
+            map.putString("msoValid", response.msoValid ?: "")
+            map.putString("cert", response.cert ?: "")
+            map.putString("ica_cert", response.ica_cert ?: "")
+            
+            // Add convenience boolean for easy checking
+            map.putBoolean("isSuccessful", response.success == "Y")
+            
+        } catch (e: Exception) {
+            Log.e(TAG, "Error converting VerificationResponse to WritableMap: ${e.message}", e)
+            map.putString("error", "Error processing verification response")
+        }
+        
+        return map
+    }
+
+    private fun convertProgressResponseToWritableMap(progress: ProgressResponse): WritableMap {
+        val map = Arguments.createMap()
+        
+        try {
+            map.putString("command", progress.command ?: "")
+            map.putString("status", progress.status ?: "")
+            map.putString("logData", progress.logData ?: "")
+            map.putString("logLevel", progress.logLevel ?: "")
+            
+        } catch (e: Exception) {
+            Log.e(TAG, "Error converting ProgressResponse to WritableMap: ${e.message}", e)
+            map.putString("error", "Error processing progress response")
+        }
+        
+        return map
+    }
+
+    @ReactMethod
+    fun initialize(licenseKey: String, promise: Promise) {
+        try {
+            Log.d(TAG, "Initializing SDK with license key: $licenseKey")
+            
+            // Get the current activity from React context
+            val currentActivity = reactApplicationContext.currentActivity
+            if (currentActivity == null) {
+                promise.reject("INIT_ERROR", "Activity not available")
+                return
+            }
+            
+            if (currentActivity !is ComponentActivity) {
+                promise.reject("INIT_ERROR", "Activity is not a ComponentActivity")
+                return
+            }
+
+            coordinator = MdlVerificationCoordinator(currentActivity)
+            coordinator.initSDK(licenseKey)
+
+            promise.resolve("SDK initialized successfully")
+            Log.d(TAG, "SDK initialized successfully")
+        } catch (e: Exception) {
+            Log.e(TAG, "Error initializing SDK: ${e.message}", e)
+            promise.reject("INIT_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun startVerification(config: ReadableMap, promise: Promise) {
+        try {
+            Log.d(TAG, "Starting verification")
+
+            if (!::coordinator.isInitialized) {
+                promise.reject("NOT_INITIALIZED", "SDK not initialized. Call initialize() first.")
+                return
+            }
+
+            var minAge: String = config.getString("minAge") ?: "18"
+            var command: String? = config.getString("command")
+            var stan: String? = config.getString("stan")
+            var terminalId: String? = config.getString("terminalId")
+            var merchantId: String? = config.getString("merchantId")
+            var testHostResponse: String? = config.getString("testHostResponse")
+            var mdlToken: String? = config.getString("mdlToken")
+            var timeout: String? = config.getString("timeout")
+            var demoMode: Boolean? = if (config.hasKey("demoMode")) config.getBoolean("demoMode") else null
+            var onlyVerified: Boolean? = if (config.hasKey("onlyVerified")) config.getBoolean("onlyVerified") else null
+            
+            val request = VerificationRequest(
+                command = command,
+                stan = stan,
+                terminalId = terminalId,
+                merchantId = merchantId,
+                testHostResponse = testHostResponse,
+                minAge = minAge,
+                mdlToken = mdlToken,
+                timeout = timeout,
+                demoMode = demoMode,
+                onlyVerified = onlyVerified
+            )
+            
+            coordinator.startVerification(
+                request = request,
+                onVerificationComplete = { response: VerificationResponse ->
+                    Log.d(TAG, "Verification complete: $response")
+                    
+                    // Create separate WritableMap instances for event and promise
+                    val eventResponseMap = convertVerificationResponseToWritableMap(response)
+                    val promiseResponseMap = convertVerificationResponseToWritableMap(response)
+                    
+                    sendEvent("onVerificationComplete", eventResponseMap)
+                    promise.resolve(promiseResponseMap)
+                },
+                onProgressUpdate = { progress: ProgressResponse ->
+                    Log.d(TAG, "Progress: $progress")
+                    
+                    // Convert the progress object to a proper WritableMap
+                    val progressMap = convertProgressResponseToWritableMap(progress)
+                    sendEvent("onVerificationProgress", progressMap)
+                }
+            )
+            
+            Log.d(TAG, "Verification started")
+        } catch (e: Exception) {
+            Log.e(TAG, "Error starting verification: ${e.message}", e)
+            promise.reject("START_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun getDetailedVerificationData(mdlToken: String, promise: Promise) {
+        try {
+            Log.d(TAG, "Getting detailed verification data for token: $mdlToken")
+            
+            if (!::coordinator.isInitialized) {
+                promise.reject("NOT_INITIALIZED", "SDK not initialized. Call initialize() first.")
+                return
+            }
+
+            coordinator.getDetailedVerificationData(
+                mdlToken = mdlToken,
+                onDataReceived = { data ->
+                    Log.d(TAG, "Detailed data received: $data")
+                    
+                    // Convert the data map to WritableMap
+                    val resultMap = Arguments.createMap()
+                    data.forEach { (key, value) ->
+                        when (value) {
+                            is String -> resultMap.putString(key, value)
+                            is Int -> resultMap.putInt(key, value)
+                            is Double -> resultMap.putDouble(key, value)
+                            is Boolean -> resultMap.putBoolean(key, value)
+                            else -> resultMap.putString(key, value.toString())
+                        }
+                    }
+                    
+                    promise.resolve(resultMap)
+                },
+                onError = { error ->
+                    Log.e(TAG, "Error getting detailed data: $error")
+                    promise.reject("DATA_ERROR", error.message ?: "Unknown error", error)
+                }
+            )
+            
+            Log.d(TAG, "Requested detailed verification data")
+        } catch (e: Exception) {
+            Log.e(TAG, "Error requesting detailed data: ${e.message}", e)
+            promise.reject("DATA_ERROR", e.message, e)
+        }
+    }
+}

package/android/src/main/java/com/mdlverification/MdlVerificationPackage.kt

@@ -0,0 +1,16 @@
+package com.mdlverification
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class MdlVerificationPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(MdlVerificationBridge(reactContext))
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}

package/example.js

@@ -0,0 +1,194 @@
+import React, { useEffect, useState } from 'react';
+import { View, Text, Button, Alert, StyleSheet, ScrollView } from 'react-native';
+import MdlVerification from 'react-native-mdl-verification';
+
+const App = () => {
+  const [isInitialized, setIsInitialized] = useState(false);
+  const [verificationResult, setVerificationResult] = useState(null);
+  const [progress, setProgress] = useState('');
+
+  useEffect(() => {
+    // Add event listeners
+    const progressListener = MdlVerification.addListener(
+      MdlVerification.Events.VERIFICATION_PROGRESS,
+      (progressData) => {
+        console.log('Progress:', progressData);
+        setProgress(progressData.status || progressData.logData || '');
+      }
+    );
+
+    const completeListener = MdlVerification.addListener(
+      MdlVerification.Events.VERIFICATION_COMPLETE,
+      (result) => {
+        console.log('Verification complete:', result);
+        setVerificationResult(result);
+      }
+    );
+
+    // Cleanup listeners on unmount
+    return () => {
+      progressListener.remove();
+      completeListener.remove();
+    };
+  }, []);
+
+  const initializeSDK = async () => {
+    try {
+      await MdlVerification.initialize('YOUR_LICENSE_KEY_HERE');
+      setIsInitialized(true);
+      Alert.alert('Success', 'SDK initialized successfully');
+    } catch (error) {
+      console.error('Initialization error:', error);
+      Alert.alert('Error', `Failed to initialize SDK: ${error.message}`);
+    }
+  };
+
+  const startVerification = async () => {
+    if (!isInitialized) {
+      Alert.alert('Error', 'Please initialize SDK first');
+      return;
+    }
+
+    try {
+      setProgress('Starting verification...');
+      setVerificationResult(null);
+
+      const result = await MdlVerification.startVerification({
+        stan: '000001',
+        terminalId: 'TERMINAL_001',
+        merchantId: 'MERCHANT_001',
+        minAge: '18',
+        demoMode: false,
+        onlyVerified: true,
+      });
+
+      if (result.isSuccessful) {
+        Alert.alert('Success', 'Verification completed successfully!');
+        
+        // Get detailed data if mdlToken is available
+        if (result.mdlToken) {
+          const detailedData = await MdlVerification.getDetailedVerificationData(result.mdlToken);
+          console.log('Detailed data:', detailedData);
+        }
+      } else {
+        Alert.alert('Verification Failed', result.successMesg || 'Unknown error');
+      }
+    } catch (error) {
+      console.error('Verification error:', error);
+      Alert.alert('Error', `Verification failed: ${error.message}`);
+    }
+  };
+
+  return (
+    <ScrollView style={styles.container}>
+      <View style={styles.content}>
+        <Text style={styles.title}>MDL Verification Example</Text>
+        
+        <View style={styles.buttonContainer}>
+          <Button
+            title={isInitialized ? 'SDK Initialized ✓' : 'Initialize SDK'}
+            onPress={initializeSDK}
+            disabled={isInitialized}
+          />
+        </View>
+
+        <View style={styles.buttonContainer}>
+          <Button
+            title="Start Verification"
+            onPress={startVerification}
+            disabled={!isInitialized}
+          />
+        </View>
+
+        {progress ? (
+          <View style={styles.progressContainer}>
+            <Text style={styles.progressTitle}>Progress:</Text>
+            <Text style={styles.progressText}>{progress}</Text>
+          </View>
+        ) : null}
+
+        {verificationResult ? (
+          <View style={styles.resultContainer}>
+            <Text style={styles.resultTitle}>Verification Result:</Text>
+            <Text style={styles.resultText}>
+              Success: {verificationResult.success}
+            </Text>
+            <Text style={styles.resultText}>
+              Message: {verificationResult.successMesg}
+            </Text>
+            <Text style={styles.resultText}>
+              Doc Type: {verificationResult.docType}
+            </Text>
+            <Text style={styles.resultText}>
+              Doc Valid: {verificationResult.docValid}
+            </Text>
+            <Text style={styles.resultText}>
+              Auth Method: {verificationResult.authMethod}
+            </Text>
+            <Text style={styles.resultText}>
+              Auth Success: {verificationResult.authSuccess}
+            </Text>
+            {verificationResult.mdlToken ? (
+              <Text style={styles.resultText}>
+                MDL Token: {verificationResult.mdlToken.substring(0, 20)}...
+              </Text>
+            ) : null}
+          </View>
+        ) : null}
+      </View>
+    </ScrollView>
+  );
+};
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+    backgroundColor: '#f5f5f5',
+  },
+  content: {
+    padding: 20,
+  },
+  title: {
+    fontSize: 24,
+    fontWeight: 'bold',
+    marginBottom: 20,
+    textAlign: 'center',
+  },
+  buttonContainer: {
+    marginVertical: 10,
+  },
+  progressContainer: {
+    marginTop: 20,
+    padding: 15,
+    backgroundColor: '#e3f2fd',
+    borderRadius: 8,
+  },
+  progressTitle: {
+    fontSize: 16,
+    fontWeight: 'bold',
+    marginBottom: 5,
+  },
+  progressText: {
+    fontSize: 14,
+    color: '#1976d2',
+  },
+  resultContainer: {
+    marginTop: 20,
+    padding: 15,
+    backgroundColor: '#fff',
+    borderRadius: 8,
+    borderWidth: 1,
+    borderColor: '#ddd',
+  },
+  resultTitle: {
+    fontSize: 18,
+    fontWeight: 'bold',
+    marginBottom: 10,
+  },
+  resultText: {
+    fontSize: 14,
+    marginVertical: 3,
+  },
+});
+
+export default App;

package/index.d.ts

@@ -0,0 +1,52 @@
+declare module 'react-native-mdl-verification' {
+  export interface VerificationOptions {
+    stan: string;
+    terminalId: string;
+    merchantId: string;
+  }
+
+  export interface VerificationResponse {
+    command?: string;
+    stan?: string;
+    terminalId?: string;
+    merchantId?: string;
+    success?: string;
+    successMesg?: string;
+    status?: number;
+    mdlToken?: string;
+    docType?: string;
+    docValid?: string;
+    authMethod?: string;
+    authSuccess?: string;
+    msoValid?: string;
+    cert?: string;
+    ica_cert?: string;
+    isSuccessful?: boolean;
+  }
+
+  export interface ProgressResponse {
+    command?: string;
+    status?: string;
+    logData?: string;
+    logLevel?: string;
+  }
+
+  export interface DetailedVerificationData {
+    [key: string]: any;
+  }
+
+  export interface MdlVerificationModule {
+    initialize(licenseKey: string): Promise<void>;
+    startVerification(options: VerificationOptions): Promise<VerificationResponse>;
+    getDetailedVerificationData(mdlToken: string): Promise<DetailedVerificationData>;
+    addListener(eventName: string, listener: (event: any) => void): { remove: () => void };
+    removeAllListeners(eventName: string): void;
+    Events: {
+      VERIFICATION_PROGRESS: 'onVerificationProgress';
+      VERIFICATION_COMPLETE: 'onVerificationComplete';
+    };
+  }
+
+  const MdlVerification: MdlVerificationModule;
+  export default MdlVerification;
+}

package/index.js

@@ -0,0 +1,71 @@
+import { NativeModules, NativeEventEmitter } from 'react-native';
+
+const { MdlVerification } = NativeModules;
+
+if (!MdlVerification) {
+  throw new Error(
+    'MdlVerification native module is not available. Make sure the native module is properly linked.'
+  );
+}
+
+const mdlEventEmitter = new NativeEventEmitter(MdlVerification);
+
+/**
+ * MDL Verification Module
+ * Provides methods for verifying Mobile Driver's Licenses
+ */
+export default {
+  /**
+   * Initialize the MDL verification SDK
+   * @param {string} licenseKey - The license key for the SDK
+   * @returns {Promise<void>}
+   */
+  initialize(licenseKey) {
+    return MdlVerification.initialize(licenseKey);
+  },
+
+  /**
+   * Start MDL verification
+   * @param {Object} options - Verification options
+   * @param {string} options.stan - Station number
+   * @param {string} options.terminalId - Terminal ID
+   * @param {string} options.merchantId - Merchant ID
+   * @returns {Promise<Object>} Verification response
+   */
+  startVerification(options) {
+    return MdlVerification.startVerification(options);
+  },
+
+  /**
+   * Get detailed verification data
+   * @param {string} mdlToken - The MDL token from verification response
+   * @returns {Promise<Object>} Detailed verification data
+   */
+  getDetailedVerificationData(mdlToken) {
+    return MdlVerification.getDetailedVerificationData(mdlToken);
+  },
+
+  /**
+   * Add event listener for verification events
+   * @param {string} eventName - Event name ('onVerificationProgress' or 'onVerificationComplete')
+   * @param {function} listener - Event listener function
+   * @returns {Object} Subscription object with remove() method
+   */
+  addListener(eventName, listener) {
+    return mdlEventEmitter.addListener(eventName, listener);
+  },
+
+  /**
+   * Remove all listeners for a specific event
+   * @param {string} eventName - Event name to remove listeners from
+   */
+  removeAllListeners(eventName) {
+    mdlEventEmitter.removeAllListeners(eventName);
+  },
+
+  // Event names constants
+  Events: {
+    VERIFICATION_PROGRESS: 'onVerificationProgress',
+    VERIFICATION_COMPLETE: 'onVerificationComplete',
+  },
+};

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "react-native-mdl-verification",
+  "version": "1.0.0",
+  "description": "React Native bridge for MDL (Mobile Driver's License) verification using CheckMDL SDK",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "react-native",
+    "mdl",
+    "mobile-drivers-license",
+    "verification",
+    "checkmdl",
+    "android"
+  ],
+  "author": "Naresh Bangia",
+  "license": "MIT",
+  "peerDependencies": {
+    "react": "*",
+    "react-native": "*"
+  },
+  "devDependencies": {
+    "react": "*",
+    "react-native": "*"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yourusername/react-native-mdl-verification.git"
+  },
+  "bugs": {
+    "url": "https://github.com/yourusername/react-native-mdl-verification/issues"
+  },
+  "homepage": "https://github.com/yourusername/react-native-mdl-verification#readme"
+}