// android/app/src/main/java/.../MainActivity.kt
import android.os.Bundle
import com.truora.validationssdk.TruoraValidationsSdkModule

class MainActivity : ReactActivity() {
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    TruoraValidationsSdkModule.init(this)
  }

  // ... rest of your activity
}

            

                
import EncryptedStorage from 'react-native-encrypted-storage';
import Config from 'react-native-config';

// Option 1: From encrypted storage
const getApiKeyFromSecureStorage = async (): Promise<string> => {
  const apiKey = await EncryptedStorage.getItem('truora_api_key');
  if (!apiKey) {
    throw new Error('API key not found in secure storage');
  }
  return apiKey;
};

// Option 2: From environment config (less secure, for development)
const getApiKeyFromSecureStorage = (): string => {
  return Config.TRUORA_API_KEY || '';
};

// Option 3: From backend service
const getApiKeyFromSecureStorage = async (): Promise<string> => {
  const response = await fetch('https://your-api.com/truora-key', {
    headers: { Authorization: `Bearer ${userToken}` },
  });
  const { apiKey } = await response.json();
  return apiKey;
};

            

                
await TruoraSDK.initialize({
  "getApiKeyFromSecureStorage": getApiKeyFromSecureStorage,
  "userId": userId, // <-- The unique identifier for the user
  "ui": { /* ... */ },
  "validation": { /* ... */ },
  "language": "es" // <-- Sets the UI language to Spanish
});

            

                
const faceConfig: FaceValidationConfig = {
  type: "face",

  // Capture settings
  useAutocapture: true,        // Auto-capture when face is detected
  similarityThreshold: 0.8,       // Matching strictness (0.0 - 1.0)
  timeout: 60,                  // Timeout in seconds

  // Result handling
  waitForResults: true,           // Wait for API response before closing

  // Optional: Reference face for comparison if not provided
  // one associated with the user id on Truora is used if any.
  referenceFace: 'https://example.com/reference.jpg',
};


            

                
const documentConfig: DocumentValidationConfig = {
  type: "document",

  // Document details (optional - if not set, a selection screen will be shown)
  country: Country.co,         // Country code (e.g., 'CO', 'MX', 'PE')
  documentType: DocumentType.nationalId,      // Type of document

  // Capture settings
  useAutocapture: true,    // Auto-capture when document is detected
  timeout: 90,         // Timeout in seconds

  // Result handling
  waitForResults: true,       // Wait for API response before closing
};

            

                
type ValidationStatus = 'success' | 'failure' | 'pending';
type ValidationType = 'face' | 'document';

interface ValidationResult {
  validationId: string; // Unique identifier for this validation
  status: ValidationStatus; // Status of the validation
  type: ValidationType; // Type of the validation
}

            

                
const handleResult = (result: TruoraValidationResult) => {
  switch (result.type) {
    case 'completed':
      // Validation process completed - check the validation status
      const validation = result.validation;
      console.log('Validation ID:', validation.validationId);
      console.log('Status:', validation.status);
      console.log('Type:', validation.type);

      if (validation.status === 'success') {
        // User passed the validation
        navigation.navigate('Success');
      } else if (validation.status === 'failure') {
        // User did not pass the validation criteria
        showRetryDialog();
      }
      break;

    case 'canceled':
      // User cancelled - just go back
      navigation.goBack();
    break;

    case 'error':
      // SDK error occurred - handle based on error type
      handleError(result.error);
      break;
  }
};

const handleError = (error: TruoraException) => {
  switch (error.type) {
    case 'sdk':
      // Handle SDK errors 
      if (error.code === 20011) {
        // Camera permission denied
        showPermissionDialog();
      } else {
        showErrorDialog(error.message);
      }
      break;

    case 'network':
      showErrorDialog(`Connection error: ${error.message}`);
      break;

    case 'validationApi':
      showErrorDialog(`API error: ${error.message}`);
      break;
  }
};

            

                
import React, { useEffect, useState } from 'react';
import {
  View,
  Text,
  TouchableOpacity,
  StyleSheet,
  Alert,
  ActivityIndicator,
} from 'react-native';
import TruoraSDK, {
  FaceValidationConfig,
  UIConfig,
  ValidationResult,
  ValidationError,
} from 'truora-validations-react-native';
import Config from 'react-native-config';

const ValidationScreen: React.FC = () => {
  const [isValidating, setIsValidating] = useState(false);
  const [validationStatus, setValidationStatus] = useState('Ready to start validation');

  // Initialize SDK on mount
  useEffect(() => {
    initializeSDK();
  }, []);

  const initializeSDK = async () => {
      const getApiKeyFromSecureStorage = () => Config.TRUORA_API_KEY; // Or fetch from secure storage
      const userId = "my-unique-user-identifier";
    try {
      await TruoraSDK.initialize({
  "getApiKeyFromSecureStorage": getApiKeyFromSecureStorage,
  "userId": userId,
  "ui": {
      primaryColor: '#435AE0',
      surfaceColor: '#FFFFFF',
      errorColor: '#FF5454',
      logoUrl: 'https://your-cdn.com/logo.png',
    },
  "validation": {
      type: "face",
      useAutocapture: true,
      similarityThreshold: 0.8,
      timeout: 60,
      waitForResults: true,
    },
  "language": "es"
});
    } catch (error) {
      setValidationStatus(`Initialization failed: ${error}`);
    }
  };

  const startFaceValidation = async () => {
    setIsValidating(true);
    setValidationStatus('Starting face validation...');

    // Start the validation
    const result = await TruoraSDK.start();
    setIsValidating(false);
    handleResult(result);
  };

  const handleResult = (result: TruoraValidationResult) => {
    switch (result.type) {
      case 'completed':
        const validation = result.validation;
        if (validation.status === 'success') {
          setValidationStatus(`Success! ID: ${validation.validationId}`);
        } else if (validation.status === 'failure') {
          setValidationStatus('Validation failed. Please try again.');
        } else {
          setValidationStatus('Processing...');
        }
        break;
      case 'canceled':
      	  // User cancelled - just go back 
        navigation.goBack();

	  break;
      case 'error':
        setValidationStatus(`Error: ${result.error.message}`);
        if (result.error.code === 20011) {
          Alert.alert(
            'Camera Permission Required',
            'Please grant camera permission to continue with identity verification.',
            [{ text: 'OK' }]
          );
        }
        break;
    }
  };

  return (
    <View style={styles.container}>
      <Text style={styles.statusText}>{validationStatus}</Text>

      <TouchableOpacity
        style={[styles.button, isValidating && styles.buttonDisabled]}
        onPress={startFaceValidation}
        disabled={isValidating}
      >
        {isValidating ? (
          <ActivityIndicator color="#FFFFFF" />
        ) : (
          <Text style={styles.buttonText}>Start Face Validation</Text>
        )}
      </TouchableOpacity>
    </View>
  );
};

const styles = StyleSheet.create({
  container: {
    flex: 1,
    justifyContent: 'center',
    alignItems: 'center',
    padding: 20,
  },
  statusText: {
    fontSize: 16,
    textAlign: 'center',
    marginBottom: 40,
  },
  button: {
    backgroundColor: '#435AE0',
    paddingHorizontal: 32,
    paddingVertical: 16,
    borderRadius: 8,
    minWidth: 200,
    alignItems: 'center',
  },
  buttonDisabled: {
    opacity: 0.6,
  },
  buttonText: {
    color: '#FFFFFF',
    fontSize: 16,
    fontWeight: '600',
  },
});

export default ValidationScreen;


            

                
import TruoraSDK, {
  DocumentValidationConfig,
  UIConfig,
} from 'truora-validations-react-native';

const startDocumentValidation = async () => {
  // Start the validation
  const result = await TruoraSDK.start();
  handleResult(result);
};