@trustchex/react-native-sdk 1.464.0 → 1.472.0

package/src/Shared/Components/IdentityDocumentCamera.tsx

@@ -21,6 +21,7 @@ import {
   type Frame,
 } from './TrustchexCamera';
 import { NativeModules } from 'react-native';
+import PermissionManager from '../Libs/permissions.utils';
 import mrzUtils from '../Libs/mrz.utils';
 import { useKeepAwake } from '../Libs/native-keep-awake.utils';
 import { useIsFocused } from '@react-navigation/native';
@@ -246,13 +247,12 @@ const IdentityDocumentCamera = ({
 
   useEffect(() => {
     const requestPermissions = async () => {
-      if (Platform.OS === 'android') {
-        const granted = await PermissionsAndroid.request(
-          PermissionsAndroid.PERMISSIONS.CAMERA
-        );
-        setHasPermission(granted === PermissionsAndroid.RESULTS.GRANTED);
-      } else {
-        setHasPermission(true);
+      try {
+        const hasCameraPermission =
+          await PermissionManager.requestPermission('camera');
+        setHasPermission(hasCameraPermission);
+      } catch (error) {
+        setHasPermission(false);
       }
       setPermissionsRequested(true);
     };

package/src/Shared/Libs/PERMISSIONS_MANAGER.md

@@ -0,0 +1,268 @@
+# PermissionManager Documentation
+
+## Overview
+
+`PermissionManager` is a centralized utility for handling all platform-specific permission requests (camera, microphone, NFC, etc.) in the React Native SDK. It abstracts away platform differences (iOS vs Android) and provides a clean, consistent API.
+
+## Location
+
+- **File**: `src/Shared/Libs/permissions.utils.ts`
+- **Export**: Can be imported from `src/Shared/Libs/index.ts`
+
+## Supported Permissions
+
+```typescript
+type PermissionType = 'camera' | 'microphone' | 'nfc';
+```
+
+| Permission   | iOS | Android | Notes                                    |
+| ------------ | --- | ------- | ---------------------------------------- |
+| `camera`     | ✅  | ✅      | Camera access for video recording        |
+| `microphone` | ✅  | ✅      | Microphone access for audio recording    |
+| `nfc`        | ✅  | ✅      | NFC chip reading (document verification) |
+
+## API Reference
+
+### Request Methods
+
+#### `requestPermission(permission: PermissionType): Promise<boolean>`
+
+Request a single permission. Returns `true` if granted, `false` if denied.
+
+```typescript
+import PermissionManager from '../../Shared/Libs/permissions.utils';
+
+const hasCamera = await PermissionManager.requestPermission('camera');
+if (!hasCamera) {
+  console.log('Camera permission denied');
+}
+```
+
+#### `requestPermissions(permissions: PermissionType[]): Promise<Map<PermissionType, boolean>>`
+
+Request multiple permissions at once. Returns a Map with permission status for each.
+
+```typescript
+const results = await PermissionManager.requestPermissions([
+  'camera',
+  'microphone',
+]);
+const hasCamera = results.get('camera') ?? false;
+const hasMicrophone = results.get('microphone') ?? false;
+```
+
+#### `requestCameraAndMicrophone(): Promise<boolean>`
+
+**⭐ Convenience method** — Request camera and microphone together (common for video recording). Returns `true` only if BOTH are granted.
+
+```typescript
+const hasBothPermissions = await PermissionManager.requestCameraAndMicrophone();
+if (!hasBothPermissions) {
+  showError('Camera and microphone access required for video call');
+}
+```
+
+#### `requestCamera(): Promise<boolean>`
+
+Request camera permission only.
+
+```typescript
+const hasCamera = await PermissionManager.requestCamera();
+```
+
+#### `requestMicrophone(): Promise<boolean>`
+
+Request microphone permission only.
+
+```typescript
+const hasMicrophone = await PermissionManager.requestMicrophone();
+```
+
+#### `requestNFC(): Promise<boolean>`
+
+Request NFC permission for document verification.
+
+```typescript
+const hasNFC = await PermissionManager.requestNFC();
+```
+
+#### `requestWithFallback(permission: PermissionType, onDenied?: () => void): Promise<boolean>`
+
+Request permission with custom callback when denied.
+
+```typescript
+const granted = await PermissionManager.requestWithFallback('camera', () => {
+  showAlert('Camera access is required for verification');
+});
+```
+
+### Check Methods (Non-requesting)
+
+Check if a permission is already granted without requesting.
+
+#### `checkPermission(permission: PermissionType): Promise<boolean>`
+
+Check a single permission status.
+
+```typescript
+const hasCamera = await PermissionManager.checkPermission('camera');
+```
+
+#### `hasCameraAndMicrophone(): Promise<boolean>`
+
+Check if both camera and microphone are granted.
+
+```typescript
+const ready = await PermissionManager.hasCameraAndMicrophone();
+```
+
+#### `hasCamera(): Promise<boolean>`
+
+Check if camera is granted.
+
+```typescript
+const hasCamera = await PermissionManager.hasCamera();
+```
+
+#### `hasMicrophone(): Promise<boolean>`
+
+Check if microphone is granted.
+
+```typescript
+const hasMicrophone = await PermissionManager.hasMicrophone();
+```
+
+#### `hasNFC(): Promise<boolean>`
+
+Check if NFC is granted.
+
+```typescript
+const hasNFC = await PermissionManager.hasNFC();
+```
+
+## Common Patterns
+
+### Pattern 1: Video Call Setup (Camera + Microphone)
+
+```typescript
+import PermissionManager from '../../Shared/Libs/permissions.utils';
+
+async function initializeVideoCall() {
+  const hasBothPermissions =
+    await PermissionManager.requestCameraAndMicrophone();
+
+  if (!hasBothPermissions) {
+    setConnectionState('permissions_denied');
+    return;
+  }
+
+  // Proceed with video call initialization
+  const stream = await service.initialize();
+  setLocalStream(stream);
+}
+```
+
+### Pattern 2: Document Verification (NFC)
+
+```typescript
+const hasNFC = await PermissionManager.requestNFC();
+
+if (!hasNFC) {
+  showError('NFC access required to read document');
+  return;
+}
+
+const result = await readNFCChip();
+```
+
+### Pattern 3: Check Before Requesting
+
+```typescript
+// First check if permission is already granted
+const alreadyHasCamera = await PermissionManager.checkPermission('camera');
+
+if (alreadyHasCamera) {
+  // Skip request dialog
+  startCamera();
+} else {
+  // Request permission (shows OS dialog)
+  const granted = await PermissionManager.requestCamera();
+  if (granted) {
+    startCamera();
+  } else {
+    showErrorMessage('Camera access required');
+  }
+}
+```
+
+## Platform Implementation Details
+
+### iOS
+
+Uses the `react-native-permissions` library with `RNPermissions` module.
+
+**Permissions layout location**: `ios/App.xcodeproj/Info.plist`
+
+Required Info.plist keys:
+
+- `NSCameraUsageDescription` — Camera access explanation
+- `NSMicrophoneUsageDescription` — Microphone access explanation
+- `NFCReaderUsageDescription` — NFC access explanation
+
+### Android
+
+Uses built-in `PermissionsAndroid` from React Native core.
+
+**Permissions manifest location**: `android/app/src/main/AndroidManifest.xml`
+
+Required manifest permissions:
+
+- `android.permission.CAMERA` — Camera access
+- `android.permission.RECORD_AUDIO` — Microphone access
+- `android.permission.NFC` — NFC chip reading
+
+## Error Handling
+
+The PermissionManager handles errors internally and logs them using the debug utility. All methods return clear boolean or Map results so you can check status directly:
+
+```typescript
+const granted = await PermissionManager.requestCamera();
+
+// Simple check
+if (!granted) {
+  // Handle permission denied
+}
+```
+
+## Best Practices
+
+1. ✅ **Use convenience methods** — `requestCameraAndMicrophone()` instead of manually requesting both
+2. ✅ **Request at the right time** — Request permissions when the feature is about to be used
+3. ✅ **Check before requesting** — Use `checkPermission()` if you want to skip the OS dialog
+4. ✅ **Handle denial gracefully** — Always provide clear error messages when permissions are denied
+5. ✅ **Use the centralized manager** — Never import React Native permissions directly; always use PermissionManager
+
+## Troubleshooting
+
+### Permission request dialog not appearing
+
+- Check that you're using `request*` methods, not `check*` methods
+- Verify the permission is in the app's manifest (Android) or Info.plist (iOS)
+- Test on a device where the permission hasn't been granted yet
+
+### Camera/Microphone not working after permission granted
+
+- Check that you're handling successful permission grant and initializing the feature
+- Verify other features aren't holding exclusive access to the device
+
+### NFC not working on iOS
+
+- Ensure `NFCReaderUsageDescription` is set in Info.plist
+- The app must be signed with proper entitlements for NFC
+- NFC requires iPhone XS or later
+
+## Related Files
+
+- `src/Screens/Dynamic/VideoCallScreen.tsx` — Example usage with video calls
+- `src/Shared/Libs/index.ts` — Exported for easy importing
+- `src/Shared/Libs/debug.utils.ts` — Used internally for debug logging

package/src/Shared/Libs/index.ts

@@ -0,0 +1,63 @@
+// Export utility modules with validated symbols only.
+export { default as PermissionManager } from './permissions.utils';
+export type { PermissionType } from './permissions.utils';
+export { SignalingClient } from './SignalingClient';
+
+export {
+  setDebugMode,
+  setLogLevel,
+  isDebugEnabled,
+  getLogLevel,
+  traceLog,
+  debugLog,
+  infoLog,
+  debugWarn,
+  debugError,
+  logError,
+  logWarn,
+} from './debug.utils';
+
+export {
+  default as HTTPClient,
+  HttpClientError,
+  UnauthorizedError,
+  ForbiddenError,
+  NotFoundError,
+  BadRequestError,
+  TooManyRequestsError,
+  InternalServerError,
+} from './http-client';
+
+export * from './analytics.utils';
+export type { Rect } from './contains';
+export { getLocalizedCountryName } from './country-display.utils';
+export { getSessionKey, encryptWithAes, decryptWithAes } from './crypto.utils';
+export { default as debounce } from './debounce.utils';
+export { handleDeepLink } from './deeplink.utils';
+export { getSimulatedDemoData, isDemoSession } from './demo.utils';
+export { default as MRZUtils } from './mrz.utils';
+export { NativeDeviceInfo } from './native-device-info.utils';
+export { default as getDeviceInfo } from './native-device-info.utils';
+
+export {
+  useKeepAwake,
+  enableKeepAwake,
+  disableKeepAwake,
+  isKeepAwakeCurrentlyActive,
+  getKeepAwakeStats,
+} from './native-keep-awake.utils';
+
+export { runWithRetry } from './promise.utils';
+
+export {
+  configureStatusBarForWhiteBackground,
+  useStatusBarWhiteBackground,
+} from './status-bar.utils';
+
+export {
+  speak,
+  speakWithDebounce,
+  stopSpeaking,
+  resetLastMessage,
+  initializeTTS,
+} from './tts.utils';

package/src/Shared/Libs/permissions.utils.ts

@@ -0,0 +1,251 @@
+import {
+  Platform,
+  NativeModules,
+  PermissionsAndroid,
+  type Permission,
+} from 'react-native';
+import { debugLog, debugError, debugWarn } from './debug.utils';
+
+const { PermissionModule } = NativeModules;
+
+export type PermissionType = 'camera' | 'microphone' | 'nfc';
+
+class PermissionManager {
+  private static permissionCache: Map<PermissionType, boolean> = new Map();
+
+  /**
+   * Request a single permission
+   */
+  static async requestPermission(permission: PermissionType): Promise<boolean> {
+    try {
+      if (Platform.OS === 'android') {
+        return await this.requestAndroidPermission(permission);
+      } else {
+        return await this.requestIOSPermission(permission);
+      }
+    } catch (error) {
+      debugError(
+        'PermissionManager',
+        `Failed to request ${permission}:`,
+        error
+      );
+      return false;
+    }
+  }
+
+  /**
+   * Request multiple permissions at once
+   */
+  static async requestPermissions(
+    permissions: PermissionType[]
+  ): Promise<Map<PermissionType, boolean>> {
+    const results = new Map<PermissionType, boolean>();
+
+    if (Platform.OS === 'android') {
+      const androidPermissions = permissions.map((p) =>
+        this.permissionTypeToAndroid(p)
+      );
+      const granted =
+        await PermissionsAndroid.requestMultiple(androidPermissions);
+
+      permissions.forEach((p, i) => {
+        const isGranted =
+          granted[androidPermissions[i]] === PermissionsAndroid.RESULTS.GRANTED;
+        results.set(p, isGranted);
+      });
+    } else {
+      for (const permission of permissions) {
+        const isGranted = await this.requestIOSPermission(permission);
+        results.set(permission, isGranted);
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Check if a permission is granted (without requesting)
+   */
+  static async checkPermission(permission: PermissionType): Promise<boolean> {
+    try {
+      if (Platform.OS === 'android') {
+        const androidPerm = this.permissionTypeToAndroid(permission);
+        const result = await PermissionsAndroid.check(androidPerm);
+        return result;
+      } else {
+        return await this.checkIOSPermission(permission);
+      }
+    } catch (error) {
+      debugError(
+        'PermissionManager',
+        `Failed to check ${permission} permission:`,
+        error
+      );
+      return false;
+    }
+  }
+
+  /**
+   * Request permission with user-friendly error handling
+   */
+  static async requestWithFallback(
+    permission: PermissionType,
+    onDenied?: () => void
+  ): Promise<boolean> {
+    const isGranted = await this.requestPermission(permission);
+
+    if (!isGranted) {
+      debugLog('PermissionManager', `${permission} permission denied`);
+      onDenied?.();
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Convenience method: Request camera and microphone together (for video recording)
+   */
+  static async requestCameraAndMicrophone(): Promise<boolean> {
+    const permissions = await this.requestPermissions(['camera', 'microphone']);
+
+    const hasCamera = permissions.get('camera') ?? false;
+    const hasMicrophone = permissions.get('microphone') ?? false;
+
+    return hasCamera && hasMicrophone;
+  }
+
+  /**
+   * Convenience method: Request camera only
+   */
+  static async requestCamera(): Promise<boolean> {
+    return this.requestPermission('camera');
+  }
+
+  /**
+   * Convenience method: Request microphone only
+   */
+  static async requestMicrophone(): Promise<boolean> {
+    return this.requestPermission('microphone');
+  }
+
+  /**
+   * Convenience method: Request NFC only
+   */
+  static async requestNFC(): Promise<boolean> {
+    return this.requestPermission('nfc');
+  }
+
+  /**
+   * Check if camera and microphone are both accessible
+   */
+  static async hasCameraAndMicrophone(): Promise<boolean> {
+    const camera = await this.checkPermission('camera');
+    const microphone = await this.checkPermission('microphone');
+    return camera && microphone;
+  }
+
+  /**
+   * Check if camera is accessible
+   */
+  static async hasCamera(): Promise<boolean> {
+    return this.checkPermission('camera');
+  }
+
+  /**
+   * Check if microphone is accessible
+   */
+  static async hasMicrophone(): Promise<boolean> {
+    return this.checkPermission('microphone');
+  }
+
+  /**
+   * Check if NFC is accessible
+   */
+  static async hasNFC(): Promise<boolean> {
+    return this.checkPermission('nfc');
+  }
+
+  // Private helper methods
+
+  private static permissionTypeToAndroid(permission: PermissionType): Permission {
+    const map: Record<PermissionType, Permission> = {
+      camera: PermissionsAndroid.PERMISSIONS.CAMERA,
+      microphone: PermissionsAndroid.PERMISSIONS.RECORD_AUDIO,
+      nfc: 'android.permission.NFC' as Permission,
+    };
+    return map[permission];
+  }
+
+  private static async requestAndroidPermission(
+    permission: PermissionType
+  ): Promise<boolean> {
+    const androidPerm = this.permissionTypeToAndroid(permission);
+    const result = await PermissionsAndroid.request(androidPerm);
+    return result === PermissionsAndroid.RESULTS.GRANTED;
+  }
+
+  private static async requestIOSPermission(
+    permission: PermissionType
+  ): Promise<boolean> {
+    if (!PermissionModule) {
+      debugLog(
+        'PermissionManager',
+        'PermissionModule not available, assuming permission granted'
+      );
+      return true;
+    }
+
+    try {
+      switch (permission) {
+        case 'camera':
+          return await PermissionModule.requestCameraPermission();
+        case 'microphone':
+          return await PermissionModule.requestMicrophonePermission();
+        case 'nfc':
+          // NFC permission on iOS is automatically handled when NFCManager is initialized
+          // No explicit permission request needed
+          return true;
+        default:
+          return false;
+      }
+    } catch (error) {
+      debugError(
+        'PermissionManager',
+        `iOS permission request failed for ${permission}:`,
+        error
+      );
+      return false;
+    }
+  }
+
+  private static async checkIOSPermission(
+    permission: PermissionType
+  ): Promise<boolean> {
+    if (!PermissionModule) {
+      return true;
+    }
+
+    try {
+      switch (permission) {
+        case 'camera':
+          return await PermissionModule.checkCameraPermission?.();
+        case 'microphone':
+          return await PermissionModule.checkMicrophonePermission?.();
+        case 'nfc':
+          return true;
+        default:
+          return false;
+      }
+    } catch (error) {
+      debugWarn(
+        'PermissionManager',
+        `iOS permission check failed for ${permission}`,
+        error
+      );
+      return false;
+    }
+  }
+}
+
+export default PermissionManager;

package/src/Translation/Resources/en.ts

@@ -103,6 +103,7 @@ export default {
   'eidScannerScreen.docTypeResidence': 'Residence Permit',
   'eidScannerScreen.docTypeVisa': 'Visa',
   'eidScannerScreen.expirationDate': 'Expiration Date',
+  'eidScannerScreen.issuingState': 'Issuing State',
   'eidScannerScreen.mrzText': 'MRZ Text',
   'eidScannerScreen.nfcNotSupported':
     'This device does not support NFC functionality.',

package/src/Translation/Resources/tr.ts

@@ -103,6 +103,7 @@ export default {
   'eidScannerScreen.docTypeResidence': 'Oturma İzni',
   'eidScannerScreen.docTypeVisa': 'Vize',
   'eidScannerScreen.expirationDate': 'Geçerlilik Tarihi',
+  'eidScannerScreen.issuingState': 'Veren Ülke',
   'eidScannerScreen.mrzText': 'MRZ Metni',
   'eidScannerScreen.nfcNotSupported':
     'Bu cihaz NFC işlevini desteklememektedir.',

package/src/version.ts

@@ -1,3 +1,3 @@
 // This file is auto-generated. Do not edit manually.
 // Version is synced from package.json during build.
-export const SDK_VERSION = '1.464.0';
+export const SDK_VERSION = '1.472.0';