@trustchex/react-native-sdk 1.464.0 → 1.475.0

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.475.0';