@hexar/biometric-identity-sdk-react-native 1.0.0

package/src/hooks/useBiometricSDK.ts

@@ -0,0 +1,230 @@
+import { useState, useEffect, useCallback, useRef } from 'react';
+import {
+  BiometricIdentitySDK,
+  SDKState,
+  VideoResult,
+} from '@hexar/biometric-identity-sdk-core';
+
+export interface ChallengeAction {
+  action: string;
+  instruction: string;
+  duration_ms: number;
+  order: number;
+}
+
+export interface UseBiometricSDKResult {
+  sdk: BiometricIdentitySDK;
+  state: SDKState;
+  isInitialized: boolean;
+  isUsingBackend: boolean;
+  sessionId: string | null;
+  challenges: ChallengeAction[];
+  uploadFrontID: (imageData: string | File | Blob) => Promise<void>;
+  uploadBackID: (imageData: string | File | Blob) => Promise<void>;
+  storeVideoRecording: (videoData: VideoResult) => Promise<void>;
+  fetchChallenges: (type?: 'active' | 'passive') => Promise<ChallengeAction[]>;
+  validateIdentity: () => Promise<any>;
+  reset: () => void;
+  recordVideo: (videoData?: VideoResult) => Promise<void>;
+}
+
+export const useBiometricSDK = (): UseBiometricSDKResult => {
+  const [sdk] = useState(() => BiometricIdentitySDK.createSession());
+  const [state, setState] = useState<SDKState>(sdk.getState());
+  const [isInitialized, setIsInitialized] = useState(false);
+  const [challenges, setChallenges] = useState<ChallengeAction[]>([]);
+  const isMounted = useRef(true);
+
+  useEffect(() => {
+    isMounted.current = true;
+    
+    const init = async () => {
+      try {
+        await sdk.initialize();
+        if (isMounted.current) {
+          setIsInitialized(true);
+          setState(sdk.getState());
+        }
+      } catch (error) {
+        console.error('SDK initialization failed:', error);
+      }
+    };
+
+    init();
+
+    return () => {
+      isMounted.current = false;
+      sdk.dispose();
+    };
+  }, [sdk]);
+
+  // Poll state updates while loading
+  useEffect(() => {
+    if (!state.isLoading) return;
+
+    const interval = setInterval(() => {
+      if (isMounted.current) {
+        setState(sdk.getState());
+      }
+    }, 100);
+
+    return () => clearInterval(interval);
+  }, [sdk, state.isLoading]);
+
+  /**
+   * Fetch liveness challenges from backend
+   */
+  const fetchChallenges = useCallback(
+    async (type: 'active' | 'passive' = 'active'): Promise<ChallengeAction[]> => {
+      try {
+        const response = await sdk.generateLivenessChallenge(type);
+        
+        if (response && response.challenges) {
+          const challengeActions: ChallengeAction[] = response.challenges.map(c => ({
+            action: c.action,
+            instruction: c.instruction,
+            duration_ms: c.duration_ms,
+            order: c.order,
+          }));
+          
+          setChallenges(challengeActions);
+          return challengeActions;
+        }
+        
+        // Return default challenges if backend not available
+        const defaultChallenges: ChallengeAction[] = sdk.getDefaultChallenges().map(c => ({
+          action: c.action,
+          instruction: c.instruction,
+          duration_ms: c.duration_ms,
+          order: c.order,
+        }));
+        setChallenges(defaultChallenges);
+        return defaultChallenges;
+      } catch (error) {
+        console.error('Failed to fetch challenges:', error);
+        const defaultChallenges: ChallengeAction[] = sdk.getDefaultChallenges().map(c => ({
+          action: c.action,
+          instruction: c.instruction,
+          duration_ms: c.duration_ms,
+          order: c.order,
+        }));
+        setChallenges(defaultChallenges);
+        return defaultChallenges;
+      }
+    },
+    [sdk]
+  );
+
+  /**
+   * Upload front ID image
+   */
+  const uploadFrontID = useCallback(
+    async (imageData: string | File | Blob) => {
+      await sdk.uploadFrontID(imageData);
+      if (isMounted.current) {
+        setState(sdk.getState());
+      }
+    },
+    [sdk]
+  );
+
+  /**
+   * Upload back ID image
+   */
+  const uploadBackID = useCallback(
+    async (imageData: string | File | Blob) => {
+      await sdk.uploadBackID(imageData);
+      if (isMounted.current) {
+        setState(sdk.getState());
+      }
+    },
+    [sdk]
+  );
+
+  /**
+   * Store video recording result
+   */
+  const storeVideoRecording = useCallback(
+    async (videoData: VideoResult) => {
+      // Add session ID if using backend
+      const sessionId = sdk.getSessionId();
+      if (sessionId) {
+        videoData.sessionId = sessionId;
+      }
+      
+      await sdk.storeVideoRecording(videoData);
+      if (isMounted.current) {
+        setState(sdk.getState());
+      }
+    },
+    [sdk]
+  );
+
+  /**
+   * Legacy: Record video (for backwards compatibility)
+   */
+  const recordVideo = useCallback(
+    async (videoData?: VideoResult) => {
+      if (videoData) {
+        await storeVideoRecording(videoData);
+      } else {
+        // Mock video result for backwards compatibility
+        const mockVideoResult: VideoResult = {
+          frames: Array.from({ length: 80 }, (_, i) => `frame_${i}_base64`),
+          duration: 8000,
+          instructionsFollowed: true,
+          qualityScore: 85,
+          challengesCompleted: challenges.map(c => c.action),
+          sessionId: sdk.getSessionId() || undefined,
+        };
+        
+        await sdk.storeVideoRecording(mockVideoResult);
+      }
+      
+      if (isMounted.current) {
+        setState(sdk.getState());
+      }
+    },
+    [sdk, storeVideoRecording, challenges]
+  );
+
+  /**
+   * Validate identity with all collected data
+   */
+  const validateIdentity = useCallback(async () => {
+    const result = await sdk.validateIdentity();
+    if (isMounted.current) {
+      setState(sdk.getState());
+    }
+    return result;
+  }, [sdk]);
+
+  /**
+   * Reset SDK state
+   */
+  const reset = useCallback(() => {
+    sdk.reset();
+    setChallenges([]);
+    if (isMounted.current) {
+      setState(sdk.getState());
+    }
+  }, [sdk]);
+
+  return {
+    sdk,
+    state,
+    isInitialized,
+    isUsingBackend: sdk.isUsingBackend(),
+    sessionId: sdk.getSessionId(),
+    challenges,
+    uploadFrontID,
+    uploadBackID,
+    storeVideoRecording,
+    fetchChallenges,
+    validateIdentity,
+    reset,
+    recordVideo,
+  };
+};
+
+export default useBiometricSDK;

package/src/index.ts

@@ -0,0 +1,24 @@
+/**
+ * React Native Biometric Identity SDK
+ * Main entry point
+ */
+
+// Main component
+export { BiometricIdentityFlow } from './components/BiometricIdentityFlow';
+export { default } from './components/BiometricIdentityFlow';
+
+// Individual components (for custom implementations)
+export { CameraCapture } from './components/CameraCapture';
+export { VideoRecorder } from './components/VideoRecorder';
+export { ValidationProgress } from './components/ValidationProgress';
+export { ResultScreen } from './components/ResultScreen';
+export { ErrorScreen } from './components/ErrorScreen';
+export { InstructionsScreen } from './components/InstructionsScreen';
+
+// Hooks
+export { useBiometricSDK } from './hooks/useBiometricSDK';
+
+// Re-export core types
+export * from '@hexar/biometric-identity-sdk-core';
+
+

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "jsx": "react",
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "moduleResolution": "node"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}