Troubleshooting

enum LivenessErrorType {
  INITIALIZATION_FAILED = 'INITIALIZATION_FAILED', // Falha na inicialização
  SESSION_FAILED = 'SESSION_FAILED', // Falha ao criar sessão
  CAPTURE_FAILED = 'CAPTURE_FAILED', // Falha na captura
  SUBMISSION_FAILED = 'SUBMISSION_FAILED', // Falha no envio
  CAMERA_PERMISSION_DENIED = 'CAMERA_PERMISSION_DENIED', // Permissão negada
  CAMERA_INJECTION_DETECTED = 'CAMERA_INJECTION_DETECTED', // Injeção detectada
  USER_CANCELLED = 'USER_CANCELLED', // Usuário cancelou
  NETWORK_ERROR = 'NETWORK_ERROR', // Erro de rede
  UNKNOWN_ERROR = 'UNKNOWN_ERROR', // Erro desconhecido
}

interface LivenessFailureError {
  type: LivenessErrorType; // Tipo do erro
  failureReason?: string; // Descrição detalhada (opcional)
}

const config = {
  // ... outras configurações

  onFailure: (error) => {
    switch (error.type) {
      case 'CAMERA_PERMISSION_DENIED':
        mostrarMensagem(
          'Por favor, permita o acesso à câmera nas configurações do navegador.'
        );
        break;

      case 'CAMERA_INJECTION_DETECTED':
        mostrarMensagem(
          'Detectamos um problema com a câmera. Por favor, desative softwares de câmera virtual.'
        );
        break;

      case 'NETWORK_ERROR':
        mostrarMensagem(
          'Erro de conexão. Verifique sua internet e tente novamente.'
        );
        break;

      case 'SESSION_FAILED':
        mostrarMensagem(
          'Não foi possível iniciar a sessão. Tente novamente em alguns instantes.'
        );
        break;

      case 'CAPTURE_FAILED':
        mostrarMensagem(
          'Falha na captura: ' + (error.failureReason || 'Tente novamente')
        );
        break;

      case 'USER_CANCELLED':
        mostrarMensagem('Verificação cancelada pelo usuário.');
        break;

      default:
        mostrarMensagem('Ocorreu um erro inesperado. Tente novamente.');
        console.error('Erro:', error);
    }
  },
};

try {
  const result = await hub.run(config);
  processarResultado(result);
} catch (error) {
  if (error.type) {
    // Erro tipado do SDK
    tratarErroLiveness(error);
  } else {
    // Erro genérico
    console.error('Erro inesperado:', error);
  }
}

function getMensagemAmigavel(error) {
  const mensagens = {
    CAMERA_PERMISSION_DENIED: {
      titulo: 'Acesso à Câmera Necessário',
      mensagem:
        'Para continuar, permita o acesso à câmera nas configurações do seu navegador.',
      acao: 'Verificar Permissões',
    },
    CAMERA_INJECTION_DETECTED: {
      titulo: 'Câmera Virtual Detectada',
      mensagem:
        'Detectamos um software de câmera virtual. Por favor, desative-o e use sua câmera real.',
      acao: 'Tentar Novamente',
    },
    NETWORK_ERROR: {
      titulo: 'Problema de Conexão',
      mensagem:
        'Não foi possível conectar ao servidor. Verifique sua internet.',
      acao: 'Tentar Novamente',
    },
    SESSION_EXPIRED: {
      titulo: 'Sessão Expirada',
      mensagem: 'Sua sessão expirou. Por favor, inicie novamente.',
      acao: 'Reiniciar',
    },
    CAPTURE_FAILED: {
      titulo: 'Falha na Captura',
      mensagem:
        'Não conseguimos capturar sua biometria. Tente novamente com boa iluminação.',
      acao: 'Tentar Novamente',
    },
  };

  return (
    mensagens[error.type] || {
      titulo: 'Erro Inesperado',
      mensagem: 'Ocorreu um problema. Por favor, tente novamente.',
      acao: 'Tentar Novamente',
    }
  );
}

// Exemplo de cleanup adequado
const hub = ValidHub.createHub();

try {
  const result = await hub.run(config);
  // processar resultado
} finally {
  // Garantir cleanup mesmo em caso de erro
  await hub.teardown();
}

// livenessService.js
class LivenessService {
  constructor(config) {
    this.config = config;
    this.hub = null;
  }

  async carregarCEK(cekUrl) {
    const response = await fetch(cekUrl);
    if (!response.ok) {
      throw new Error('Falha ao carregar CEK');
    }
    return await response.json();
  }

  async verificar(options = {}) {
    if (typeof ValidHub === 'undefined') {
      throw new Error('SDK não carregado');
    }

    const cekData = await this.carregarCEK(this.config.cekUrl);
    this.hub = ValidHub.createHub();

    const hubConfig = {
      apiKey: this.config.apiKey,
      cek: cekData,
      mount: options.container || this.config.defaultContainer,
      backendBaseUrl: this.config.backendUrl,
      appName: this.config.appName,
      risk: options.risk || 'LIVENESS_RISK_HIGH',
      hubOptions: options.hubOptions,
      onProgress: options.onProgress,
      onSuccess: options.onSuccess,
      onFailure: options.onFailure,
    };

    try {
      const result = await this.hub.run(hubConfig);
      return result;
    } finally {
      this.hub = null;
    }
  }

  async cancelar() {
    if (this.hub) {
      await this.hub.teardown();
      this.hub = null;
    }
  }
}

// Uso
const livenessService = new LivenessService({
  apiKey: 'sua-api-key',
  cekUrl: '/config/production.cek.json',
  backendUrl: 'https://api.valid.com/liveness',
  appName: 'minha-aplicacao',
  defaultContainer: '#camera-container',
});

async function handleVerificacao() {
  try {
    const result = await livenessService.verificar({
      risk: 'LIVENESS_RISK_HIGH',
      hubOptions: {
        locale: 'pt-BR',
        colorTheme: { primaryColor: '#0066cc' },
      },
      onProgress: (state) => atualizarUI(state),
    });

    await enviarResultadoParaBackend(result);
  } catch (error) {
    tratarErro(error);
  }
}