Guia de Tratamento de Retornos - Flutter Liveness 3D

public enum Liveness3DErrorCode: Int, Error {
    case invalidAppKey = 0          // "App Key inválido."
    case noCameraPermission = 1     // "Não foi concedida permissão de acesso à câmera do aparelho."
    case noInternetConnection = 2   // "Sem conexão à Internet."
    case livenessNotCompleted = 3   // "Prova de vida não foi completada."
    case livenessNotInitialized = 4 // "Liveness não foi inicializado corretamente."
}

func finishChannel(error code: Liveness3DErrorCode, result: FlutterResult?) {
    let flutterError = FlutterError(
        code: String(code.code),    // "0", "1", "2", "3" ou "4"
        message: code.message,       // Mensagem descritiva
        details: nil
    )
    result?(flutterError)
}

// Erro de AppKey inválido
class InvalidAppKey(
    code: String = "INVALID_APP_KEY",
    message: String = "INVALID_APP_KEY"
) : AltLiveness3dException(code, message)

// Erro quando o liveness é cancelado
fun onLiveness3DResultCancelled(data: Intent?) {
    val errorMessage = data?.getStringExtra(HybridLiveness3DActivity.PARAM_RESULT_ERROR) ?: ""
    result?.error(errorMessage, errorMessage, null)
}

try {
    // ... inicialização do liveness
} catch (e: AltLiveness3dException) {
    result.error(e.code, e.message, null)
} catch (e: Exception) {
    result.error("UNKNOWN_ERROR", e.message, e.stackTrace)
}

final methodChannel = const MethodChannel('oiti_liveness3d');

Future startLiveness(...) async {
    return await methodChannel.invokeMapMethod(
        'OITI.startLiveness3d',
        { ... },
    );
    // Erros são lançados como PlatformException
}

import 'package:flutter/material.dart';
import 'package:oiti_liveness3d/oiti_liveness3d.dart';
import 'package:oiti_liveness3d/common/enumerations.dart';

void main() => runApp(const MaterialApp(home: ExampleWidget()));

class ExampleWidget extends StatelessWidget {
  const ExampleWidget({super.key});

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('Liveness 3D'),
      ),
      body: Center(
        child: ElevatedButton(
          child: const Text('Open liveness'),
          onPressed: () => Navigator.push(
            context,
            MaterialPageRoute(
              builder: (context) => OitiLiveness3d.createLiveness3DWidget(
                appKey: 'SUA-APP-KEY',
                environment: Environment.hml, // Use Environment.prd para produção
                onSuccess: (result) {
                  // Tratamento de sucesso
                  print('Valid: ${result.valid}');
                  print('CodId: ${result.codId}');
                  print('Protocol: ${result.protocol}');
                  print('Cause: ${result.cause}');
                  
                  // Verificar resultado da prova de vida
                  if (result.valid) {
                    // Prova de vida aprovada
                    Navigator.pop(context);
                    // Prosseguir com o fluxo do app
                  } else {
                    // Verificar motivo da reprovação
                    switch (result.codId) {
                      case '300.1':
                        // Face não identificada - permitir retentativa
                        break;
                      case '300.2':
                        // Usuário bloqueado - não permitir retentativa
                        break;
                    }
                  }
                },
                onError: (error) {
                  // Tratamento de erro
                  print('Erro: $error');
                  Navigator.pop(context);
                  
                  // Exibir mensagem de erro apropriada ao usuário
                },
              ),
            ),
          ),
        ),
      ),
    );
  }
}

import 'package:oiti_liveness3d/oiti_liveness3d.dart';
import 'package:oiti_liveness3d/common/enumerations.dart';

class LivenessService {
  final _liveness = OitiLiveness3d();

  Future<void> executeLiveness() async {
    try {
      final result = await _liveness.openLiveness3D(
        appKey: 'SUA-APP-KEY',
        environment: Environment.hml,
      );

      if (result.valid) {
        // Prova de vida aprovada
        print('Sucesso! Protocolo: ${result.protocol}');
      } else {
        // Prova de vida reprovada
        print('Reprovado. Motivo: ${result.cause}');
      }
    } catch (error) {
      // Tratamento de erro
      print('Erro durante liveness: $error');
    }
  }
}

final liveness = OitiLiveness3d();

// Verificar se a permissão foi concedida
final hasPermission = await liveness.checkPermission();

// Solicitar permissão ao usuário
await liveness.askPermission();

// Abrir configurações do app (para quando a permissão foi negada)
await liveness.openSettings();

import 'package:flutter/services.dart';

onError: (error) {
  String mensagem;
  String? code;
  
  // O erro vem como PlatformException do MethodChannel
  if (error is PlatformException) {
    code = error.code;
    
    switch (code) {
      case '0':
      case 'INVALID_APP_KEY':
        mensagem = 'Configuração inválida. Entre em contato com o suporte.';
        break;
      case '1':
        mensagem = 'É necessário permitir o acesso à câmera para continuar.';
        break;
      case '2':
        mensagem = 'Verifique sua conexão com a internet e tente novamente.';
        break;
      case '3':
        mensagem = 'O processo foi interrompido. Tente novamente.';
        break;
      case '4':
        mensagem = 'Erro ao iniciar. Reinicie o aplicativo e tente novamente.';
        break;
      default:
        // Para erros não mapeados, usar a mensagem do SDK
        mensagem = error.message ?? 'Ocorreu um erro inesperado. Tente novamente.';
    }
  } else {
    mensagem = 'Ocorreu um erro inesperado. Tente novamente.';
  }
  
  // Log para debug
  debugPrint('Liveness3D Error - Code: $code, Message: $mensagem');
  
  // Exibir mensagem ao usuário
  showDialog(
    context: context,
    builder: (context) => AlertDialog(
      title: const Text('Erro'),
      content: Text(mensagem),
      actions: [
        TextButton(
          onPressed: () => Navigator.pop(context),
          child: const Text('OK'),
        ),
      ],
    ),
  );
}