@au10tixorg/secureme-sdk 4.7.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 SecureMe SDK Team
+
+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/README.md

@@ -0,0 +1,479 @@
+# SecureMe SDK
+
+React Native library for SecureMe integration (iOS & Android).
+
+## Development
+
+### Prerequisites
+
+- Node.js 14+ and npm
+- React Native development environment
+- For iOS: Xcode and CocoaPods
+- For Android: Android Studio and Java
+
+## 📖 Documentation
+
+For a comprehensive overview of features, configuration options, and integration steps, please see the **[Integration Guide (GUIDE.md)](GUIDE.md)**.
+
+---
+
+### Building the Library
+
+1. **Clone the repository**
+
+   ```sh
+   git clone <repository-url>
+   cd reactnative-secure.me-sdk
+   ```
+
+2. **Install dependencies**
+
+   ```sh
+   yarn install
+   ```
+
+3. **Build the library**
+   ```sh
+   npx react-native-builder-bob build
+   ```
+
+### Clean Rebuild
+
+To perform a complete clean rebuild:
+
+```sh
+# Clean all build artifacts and dependencies
+rm -rf lib node_modules package-lock.json yarn.lock .yarn/cache .yarn/install-state.gz example/node_modules example/package-lock.json example/ios/Pods example/ios/Podfile.lock
+
+# Reinstall and rebuild
+yarn install
+npx react-native-builder-bob build
+```
+
+### Available Scripts
+
+- `yarn run typescript` - Type check with TypeScript
+- `yarn run lint` - Lint code with ESLint
+- `npx react-native-builder-bob build` - Build the library (via react-native-builder-bob)
+- `yarn test` - Run tests
+- `yarn run example` - Run commands in the example app
+- `yarn run pods` - Install iOS pods for the example app
+
+## iOS Setup
+
+### 1. Install Pods
+
+Go to your project's iOS folder and install dependencies:
+
+```sh
+cd ios
+pod install
+```
+
+## Android Setup
+
+### 1. Minimum SDK Version
+
+Ensure your `android/build.gradle` has minimum SDK version 21 or higher:
+
+```gradle
+buildscript {
+    ext {
+        minSdkVersion = 21
+    }
+}
+```
+
+## Usage
+
+Here is a basic example of how to integrate the SDK into your application.
+
+> **Note:** Use Named Import with curly braces `{ SecuremeSdk }`.
+
+```tsx
+import React, { useEffect, useState } from 'react';
+import {
+  SafeAreaView,
+  View,
+  Text,
+  Button,
+  StyleSheet,
+  Alert,
+  ActivityIndicator,
+  Linking,
+  Platform,
+  PermissionsAndroid,
+} from 'react-native';
+
+import { SecuremeSdk, SMFlow, SMConfig } from 'secureme-sdk';
+
+// Define your flow configuration for both platforms
+const smFlow: SMFlow = {
+  android: {
+    sdcFront: { enabled: true, showIntro: true, enableFileUpload: true },
+    sdcBack: { enabled: true, enableFileUpload: true, sendFeatureResult: true },
+    pfl: { enabled: true, showIntro: true, sendFeatureResult: true },
+  },
+  ios: {
+    sdcFront: {
+      showIntro: true,
+      enableFileUpload: true,
+      sendFeatureResult: true,
+      localClassification: false,
+    },
+    sdcBack: {
+      showIntro: true,
+      enableFileUpload: true,
+      sendFeatureResult: true,
+    },
+    pfl: {
+      showIntro: true,
+      sendFeatureResult: true,
+    },
+  },
+};
+
+// Define your configuration for both platforms
+const smConfig: SMConfig = {
+  android: {
+    withPflDetectionDelay: false,
+    pflDelaySecs: 0,
+    sendResults: true,
+  },
+  ios: {
+    pflDetectionDelayEnabled: false,
+    pflDelay: 0.0,
+    sendResults: true,
+    voiceConsentSessionTime: 20,
+  },
+};
+
+// Your workflow data from the API
+const WORKFLOW_DATA = `{
+  "sessionId": "YOUR_SESSION_ID",
+  "response": {
+    "session": "...",
+    "accessToken": "...",
+    "assets": [...]
+  },
+  "statusCode": 200
+}`;
+
+const App = () => {
+  const [isLoading, setIsLoading] = useState(true);
+  const [cameraStatus, setCameraStatus] = useState<boolean>(false);
+
+  const requestCameraAccess = async (): Promise<boolean> => {
+    if (Platform.OS === 'android') {
+      try {
+        const granted = await PermissionsAndroid.request(
+          PermissionsAndroid.PERMISSIONS.CAMERA,
+          {
+            title: 'Camera Permission',
+            message: 'This app needs camera access for identity verification.',
+            buttonNeutral: 'Ask Me Later',
+            buttonNegative: 'Cancel',
+            buttonPositive: 'OK',
+          }
+        );
+        return granted === PermissionsAndroid.RESULTS.GRANTED;
+      } catch (err) {
+        console.warn(err);
+        return false;
+      }
+    } else {
+      // iOS - permission handled by SecuremeSdk
+      const hasPermission = await SecuremeSdk.requestCameraPermission();
+      return hasPermission;
+    }
+  };
+
+  useEffect(() => {
+    const setupSDK = async () => {
+      try {
+        console.log('🚀 Starting SDK Setup...');
+
+        const hasPermission = await requestCameraAccess();
+        console.log('📷 Camera Status:', hasPermission);
+        setCameraStatus(hasPermission);
+      } catch (error: any) {
+        console.error('❌ Setup Failed:', error);
+        Alert.alert('Setup Error', error.message || 'Unknown error');
+      } finally {
+        setIsLoading(false);
+      }
+    };
+
+    setupSDK();
+  }, []);
+
+  const handleStartKit = async () => {
+    if (!cameraStatus) {
+      Alert.alert(
+        'Camera Permission Required',
+        'We need camera access to verify your identity.',
+        [
+          { text: 'Cancel', style: 'cancel' },
+          { text: 'Open Settings', onPress: () => Linking.openSettings() },
+        ]
+      );
+      return;
+    }
+
+    try {
+      console.log('📱 Opening SecureMe Kit...');
+      const result = await SecuremeSdk.start(WORKFLOW_DATA, smFlow, smConfig);
+      Alert.alert('Success', 'Verification was successful!');
+      console.log('🏁 Flow finished with result:', result);
+    } catch (error: any) {
+      console.error('❌ Failed to open Kit:', error);
+      Alert.alert('Error', error.message);
+    }
+  };
+
+  return (
+    <SafeAreaView style={styles.container}>
+      <View style={styles.content}>
+        <Text style={styles.title}>SecureMe Integration</Text>
+
+        {isLoading ? (
+          <View>
+            <ActivityIndicator size="large" color="#0000ff" />
+            <Text style={styles.loadingText}>
+              Checking permissions & initializing...
+            </Text>
+          </View>
+        ) : (
+          <View style={styles.infoContainer}>
+            <Text style={styles.statusRow}>
+              Camera: {cameraStatus ? '✅ Allowed' : '❌ Denied'}
+            </Text>
+
+            <View style={styles.buttonContainer}>
+              <Button
+                title="Start SecureMe"
+                onPress={handleStartKit}
+                disabled={!cameraStatus}
+              />
+            </View>
+          </View>
+        )}
+      </View>
+    </SafeAreaView>
+  );
+};
+
+const styles = StyleSheet.create({
+  container: { flex: 1, backgroundColor: '#F5F5F5' },
+  content: {
+    flex: 1,
+    justifyContent: 'center',
+    alignItems: 'center',
+    padding: 20,
+  },
+  title: { fontSize: 24, fontWeight: 'bold', marginBottom: 30, color: '#333' },
+  loadingText: { marginTop: 10, color: '#666' },
+  infoContainer: { width: '100%', alignItems: 'center' },
+  statusRow: { fontSize: 16, marginBottom: 10, color: '#444' },
+  buttonContainer: { marginTop: 20, width: '100%', marginBottom: 10 },
+});
+
+export default App;
+```
+
+## API Reference
+
+### Methods
+
+#### `requestCameraPermission(): Promise<boolean>`
+
+Requests camera permission (iOS only - Android handles via `PermissionsAndroid`).
+
+**Returns:** `Promise<boolean>` - `true` if permission granted, `false` otherwise.
+
+```tsx
+const hasPermission = await SecuremeSdk.requestCameraPermission();
+```
+
+#### `start(workFlowResponse: string, flow: SMFlow, config: SMConfig): Promise<any>`
+
+Starts the SecureMe verification flow.
+
+**Parameters:**
+
+- `workFlowResponse` (string): JSON string containing session data from your backend
+- `flow` (SMFlow): Flow configuration for Android and/or iOS
+- `config` (SMConfig): Additional configuration options for Android and/or iOS
+
+**Returns:** `Promise<any>` - Result of the verification flow
+
+```tsx
+const result = await SecuremeSdk.start(WORKFLOW_DATA, smFlow, smConfig);
+```
+
+### Types
+
+#### `SMFlow`
+
+```typescript
+interface SMFlow {
+  android?: AndroidSMFlow;
+  ios?: IOSSMFlow;
+}
+```
+
+#### `SMConfig`
+
+```typescript
+interface SMConfig {
+  android?: AndroidSMConfig;
+  ios?: IOSSMConfig;
+}
+```
+
+For detailed type definitions, see [types.ts](src/types.ts).
+
+## Flow Features
+
+### Android Features
+
+- `sdcFront` - Front Document Capture
+- `sdcBack` - Back Document Capture
+- `pfl` - Passive Face Liveness
+- `nfc` - NFC Passport Reading
+- `poa` - Proof of Address
+- `videoSession` - Video Session
+- `voiceConsent` - Voice Consent
+
+### iOS Features
+
+- `sdcFront` - Front Smart Document Capture
+- `sdcBack` - Back Smart Document Capture
+- `pfl` - Passive Face Liveness
+- `vc` - Voice Consent
+- `vs` - Video Session
+- `poa` - Proof of Address
+- `sdcOcr` - OCR Document Capture
+
+## Configuration Options
+
+### Android Config
+
+```typescript
+{
+  pflDelaySecs?: number;
+  sendResults?: boolean;
+  suspiciousConfig?: AndroidSuspiciousConfigType;
+  videoSessionAskUserConsent?: boolean;
+  videoSessionConsentTime?: number;
+  videoSessionIDTime?: number;
+  voiceConsentSessionTime?: number;
+  voiceConsentText?: string;
+  withPflDetectionDelay?: boolean;
+}
+```
+
+### iOS Config
+
+```typescript
+{
+  pflDetectionDelayEnabled?: boolean;
+  pflDelay?: number;
+  sendResults?: boolean;
+  voiceConsentText?: string;
+  voiceConsentSessionTime?: number;
+  videoSessionText?: string;
+  videoSessionIdSessionDuration?: number;
+  videoSessionVoiceSessionDuration?: number;
+}
+```
+
+## Troubleshooting
+
+### iOS
+
+**Issue:** Pod install fails  
+**Solution:** Try `cd ios && pod install --repo-update`
+
+**Issue:** Camera permission not working  
+**Solution:** Ensure `NSCameraUsageDescription` is added to `Info.plist`
+
+### Android
+
+**Issue:** Build fails with dependency conflicts  
+**Solution:** Ensure your `minSdkVersion` is at least 21
+
+**Issue:** Camera permission denied  
+**Solution:** Check that `CAMERA` permission is declared in `AndroidManifest.xml`
+
+## Error Handling
+
+The SDK can throw the following errors:
+
+### Native Module Errors
+
+- **LinkingError** — thrown when the native module is not properly linked (native binary missing or pods not installed).
+- **PermissionError** — thrown when camera permissions are denied or unavailable.
+- **ValidationError** — thrown when an invalid configuration or workflow payload is provided.
+
+### Session Errors
+
+- **SessionInitError** — failed to initialize session with provided workflow data.
+- **NetworkError** — failed to communicate with backend services or token validation failed.
+
+### Example Error Handling
+
+Use guarded calls and inspect error messages or types to handle specific cases:
+
+```tsx
+try {
+  const result = await SecuremeSdk.start(WORKFLOW_DATA, smFlow, smConfig);
+  // handle success result
+} catch (error: any) {
+  const msg = error && error.message ? error.message.toLowerCase() : '';
+
+  if (msg.includes('link') || msg.includes('linking')) {
+    // Native linking problems
+    Alert.alert(
+      'Linking Error',
+      'Native module not linked. Run pod install and rebuild.'
+    );
+  } else if (msg.includes('permission')) {
+    // Permission issues
+    Alert.alert(
+      'Permission Required',
+      'Please enable camera access in settings.'
+    );
+  } else if (msg.includes('session') || msg.includes('workflow')) {
+    // Session / workflow validation
+    Alert.alert(
+      'Session Error',
+      'Invalid workflow data or session init failed.'
+    );
+  } else if (msg.includes('network') || msg.includes('timeout')) {
+    // Network problems
+    Alert.alert(
+      'Network Error',
+      'Communication with the backend failed. Try again later.'
+    );
+  } else {
+    // Fallback
+    Alert.alert('Error', error?.message || 'Unknown error occurred');
+  }
+}
+```
+
+Notes:
+
+- Native linking errors typically indicate native code not built/installed. For iOS, run `cd example/ios && pod install` and rebuild.
+- PermissionError means the user denied camera access — prompt to open app settings.
+- ValidationError indicates the provided WORKFLOW data is invalid JSON or missing required fields; validate before calling SDK.
+- Log errors on the native side (Xcode / Logcat) for deeper diagnostics.
+
+## License
+
+MIT
+
+## Support
+
+For issues and questions, please visit [the repository issues page](https://example.com/repo/issues).

package/android/build.gradle

@@ -0,0 +1,156 @@
+buildscript {
+  // Buildscript is evaluated before everything else so we can't use getExtOrDefault
+  def kotlin_version = rootProject.ext.has('kotlinVersion') ? rootProject.ext.get('kotlinVersion') : project.properties['SecuremeSdk_kotlinVersion']
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath 'com.android.tools.build:gradle:8.2.2'
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+  }
+}
+
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['SecuremeSdk_' + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties['SecuremeSdk_' + name]).toInteger()
+}
+
+android {
+  compileSdkVersion getExtOrIntegerDefault('compileSdkVersion')
+  buildToolsVersion getExtOrDefault('buildToolsVersion')
+  defaultConfig {
+    minSdkVersion 26
+    targetSdkVersion getExtOrIntegerDefault('targetSdkVersion')
+    versionCode 1
+    versionName "1.0.0"
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+  lintOptions {
+    disable 'GradleCompatible'
+  }
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_11
+    targetCompatibility JavaVersion.VERSION_11
+  }
+}
+
+repositories {
+  mavenCentral()
+  mavenLocal()
+  google()
+
+  def found = false
+  def defaultDir = null
+  def androidSourcesName = 'React Native sources'
+
+  if (rootProject.ext.has('reactNativeAndroidRoot')) {
+    defaultDir = rootProject.ext.get('reactNativeAndroidRoot')
+  } else {
+    defaultDir = new File(
+      projectDir,
+      '/../../../node_modules/react-native/android'
+    )
+  }
+
+  if (defaultDir.exists()) {
+    maven {
+      url defaultDir.toString()
+      name androidSourcesName
+    }
+
+    logger.info(":${project.name}:reactNativeAndroidRoot ${defaultDir.canonicalPath}")
+    found = true
+  } else {
+    def parentDir = rootProject.projectDir
+
+    1.upto(5, {
+      if (found) return true
+      parentDir = parentDir.parentFile
+
+      def androidSourcesDir = new File(
+        parentDir,
+        'node_modules/react-native'
+      )
+
+      def androidPrebuiltBinaryDir = new File(
+        parentDir,
+        'node_modules/react-native/android'
+      )
+
+      if (androidPrebuiltBinaryDir.exists()) {
+        maven {
+          url androidPrebuiltBinaryDir.toString()
+          name androidSourcesName
+        }
+
+        logger.info(":${project.name}:reactNativeAndroidRoot ${androidPrebuiltBinaryDir.canonicalPath}")
+        found = true
+      } else if (androidSourcesDir.exists()) {
+        maven {
+          url androidSourcesDir.toString()
+          name androidSourcesName
+        }
+
+        logger.info(":${project.name}:reactNativeAndroidRoot ${androidSourcesDir.canonicalPath}")
+        found = true
+      }
+    })
+  }
+
+  if (!found) {
+    throw new GradleException(
+      "${project.name}: unable to locate React Native android sources. " +
+        "Ensure you have you installed React Native as a dependency in your project and try again."
+    )
+  }
+}
+
+def kotlin_version = getExtOrDefault('kotlinVersion')
+def camerax_version = "1.3.4"
+def au10Version = '4.7.0'
+
+dependencies {
+  // noinspection GradleDynamicVersion
+  api 'com.facebook.react:react-native:+'
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+
+  implementation 'androidx.constraintlayout:constraintlayout:2.1.4'
+  implementation "com.google.android.material:material:1.11.0"
+
+  //ML
+  implementation 'com.google.android.gms:play-services-mlkit-face-detection:17.1.0'
+  implementation 'com.google.android.gms:play-services-mlkit-text-recognition:19.0.1'
+
+  // Camera
+  implementation "androidx.camera:camera-core:${camerax_version}"
+  implementation "androidx.camera:camera-camera2:${camerax_version}"
+  implementation "androidx.camera:camera-lifecycle:${camerax_version}"
+  implementation "androidx.camera:camera-view:${camerax_version}"
+  implementation "androidx.camera:camera-extensions:${camerax_version}"
+
+  //Local SDC tflite dependencies
+  implementation 'com.google.android.gms:play-services-tflite-java:16.4.0'
+  implementation 'com.google.android.gms:play-services-tflite-support:16.4.0'
+
+  // Au10tix
+  implementation "com.au10tix.sdk:passive-face-liveness:$au10Version"
+  implementation "com.au10tix.sdk:smart-document:$au10Version"
+  implementation "com.au10tix.sdk:au10tix:$au10Version"
+  implementation "com.au10tix.sdk:local-infer:$au10Version"
+  implementation "com.au10tix.sdk:secure-me:$au10Version"
+}

package/android/gradle.properties

@@ -0,0 +1,4 @@
+SecuremeSdk_kotlinVersion=1.3.50
+SecuremeSdk_compileSdkVersion=29
+SecuremeSdk_buildToolsVersion=29.0.2
+SecuremeSdk_targetSdkVersion=29

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,6 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+  package="com.securemesdk">
+
+  <uses-permission android:name="android.permission.CAMERA" />
+
+</manifest>