@ha_tecno/live-id-sdk 1.0.0

package/src/screens/ValidadeFinger/index.tsx

@@ -0,0 +1,263 @@
+import React, { useCallback, useEffect, useRef, useState } from 'react';
+import { Button, Text, View, Alert, TouchableOpacity } from 'react-native';
+import {
+  Camera,
+  useCameraFormat,
+  type Point,
+  useCameraDevice,
+} from 'react-native-vision-camera';
+import Modal, { type ModalProps } from 'react-native-modal';
+import Orientation from 'react-native-orientation-locker';
+import {
+  Gesture,
+  GestureDetector,
+  GestureHandlerRootView,
+} from 'react-native-gesture-handler';
+import { runOnJS } from 'react-native-reanimated';
+
+import { verifyDigital } from '../../services';
+import { encodeImageToBase64 } from '../../utils/file';
+import type { ScreenProps } from '../../types/screen';
+import { DeviceNullDisplay } from '../../components/DeviceNullDisplay';
+import { ErrorDisplay } from '../../components/ErrorDisplay';
+import { Gabarito } from '../../components/Gabarito';
+import { WaitingForResult } from '../../components/WaitingForResult';
+import { styles } from './styles';
+import { CameraConfigInfos } from '../../components/CameraConfigInfos';
+import { getConfigCamera } from '../../utils';
+
+interface ValidaFingerProps {
+  isVisible: boolean;
+  ModalParams?: ModalProps;
+  screenProps?: ScreenProps;
+  onCloseModal?: () => void;
+  onError?: (response?: any) => void;
+  onSuccess?: (response?: any) => void;
+}
+
+type GetConfigApi = {
+  id: number;
+  deviceModels: string[];
+  deviceType: string;
+  fps: number;
+  exposure: number;
+  zoom: number;
+  serviceType: string;
+  showButtonInfo: boolean;
+};
+
+export const ValidaFinger: React.FC<ValidaFingerProps> = ({
+  isVisible = false,
+  onCloseModal,
+  onError,
+  onSuccess,
+  ModalParams,
+  screenProps,
+}) => {
+  const id = screenProps?.id;
+
+  const camera = useRef<Camera>(null);
+  const [showOverlay, setShowOverlay] = useState(false);
+  const [load, setLoad] = useState(false);
+  const [cameraConfigs, setCameraConfigs] = useState<GetConfigApi>();
+
+  // mantem a tela em modo portrait
+  useEffect(() => {
+    Orientation.lockToPortrait();
+    return () => {
+      Orientation.unlockAllOrientations();
+    };
+  }, []);
+
+  // Pega a permissão da camera do dispositivo
+  const requestCameraPermission = useCallback(async () => {
+    try {
+      await Camera.requestCameraPermission();
+    } catch (error) {}
+  }, []);
+
+  // pra garantir que a permissão da camera seja solicitada
+  useEffect(() => {
+    requestCameraPermission();
+  }, [requestCameraPermission]);
+
+  useEffect(() => {
+    getConfigCamera('finger')
+      .then((config) => {
+        setCameraConfigs(config);
+      })
+      .catch((error) => {
+        console.error(error);
+      });
+  }, []);
+
+  const device = useCameraDevice('back', {
+    physicalDevices: ['wide-angle-camera'],
+  });
+
+  const cameraFormat = useCameraFormat(device, [
+    {
+      photoResolution: {
+        height: 1280,
+        width: 720,
+      },
+    },
+  ]);
+
+  const capturedPhoto = async () => {
+    const snapshot = await camera.current?.takePhoto({
+      qualityPrioritization: 'speed',
+      flash: 'on',
+    });
+    if (snapshot == null) {
+      Alert.alert('Erro ao capturar imagem');
+      return false;
+    }
+    let base64 = await encodeImageToBase64(snapshot.path);
+
+    setLoad(true);
+    setShowOverlay(true);
+    sendFile(base64);
+    return true;
+  };
+
+  // Fecha o modal
+  const onCloseModalHandler = useCallback(() => {
+    onCloseModal && onCloseModal();
+  }, [onCloseModal]);
+
+  // Envia a imagem para a validação da digital
+  const sendFile = useCallback(
+    async (image) => {
+      try {
+        let UID = id;
+        let finger = 'DI';
+        let req = await verifyDigital(UID, finger, image);
+        if (req.code === 0) {
+          Alert.alert('Sucesso identificado !');
+          onSuccess && onSuccess(req);
+        } else if (req.code === 1) {
+          Alert.alert('Não Identificado !');
+          onError && onError(req);
+          setLoad(false);
+        } else {
+          Alert.alert('Erro ao tentar validar');
+          onError && onError(req);
+          setLoad(false);
+        }
+        setLoad(false);
+        onCloseModalHandler();
+        setShowOverlay(false);
+      } catch (error) {
+        onError && onError(error);
+        setShowOverlay(false);
+      }
+    },
+    [id, onError, onSuccess, onCloseModalHandler]
+  );
+
+  // Foca a camera na posição do toque
+  const focus = useCallback((point: Point) => {
+    const c = camera.current;
+    if (c == null) return;
+    c.focus(point);
+  }, []);
+
+  // Gestos para focar a camera
+  const gesture = Gesture.Tap().onBegin(({ x, y }) => {
+    runOnJS(focus)({ x, y });
+  });
+
+  if (!screenProps && isVisible) {
+    return (
+      <ErrorDisplay
+        isVisible={isVisible}
+        modalParams={ModalParams}
+        onCloseModalHandler={onCloseModalHandler}
+        requestCameraPermission={requestCameraPermission}
+      />
+    );
+  }
+
+  if (device == null) {
+    return (
+      <DeviceNullDisplay
+        isVisible={isVisible}
+        modalParams={ModalParams}
+        onCloseModalHandler={onCloseModalHandler}
+        requestCameraPermission={requestCameraPermission}
+      />
+    );
+  }
+
+  if (screenProps) {
+    return (
+      <Modal
+        style={styles.modal}
+        isVisible={isVisible}
+        swipeDirection="down"
+        propagateSwipe={true}
+        onSwipeComplete={onCloseModalHandler}
+        {...ModalParams}
+      >
+        <GestureHandlerRootView style={styles.root}>
+          <View style={styles.container}>
+            {showOverlay && (
+              <WaitingForResult
+                onPress={() => {
+                  setShowOverlay(false);
+                }}
+              />
+            )}
+            <GestureDetector gesture={gesture}>
+              <View style={styles.cameraContainer}>
+                <Camera
+                  ref={camera}
+                  format={cameraFormat}
+                  isActive={true}
+                  device={device}
+                  torch={'on'}
+                  exposure={cameraConfigs?.exposure}
+                  zoom={cameraConfigs?.zoom}
+                  photo={true}
+                  enableHighQualityPhotos={true}
+                  style={styles.camera}
+                />
+                {!showOverlay && <Gabarito />}
+              </View>
+            </GestureDetector>
+            <View style={styles.containerCapture}>
+              <TouchableOpacity disabled={load} onPress={() => capturedPhoto()}>
+                <View style={styles.containerButton}>
+                  {load ? (
+                    <Text style={styles.textButton}>
+                      Verificando Digital...
+                    </Text>
+                  ) : (
+                    <Text style={styles.textButton}>Tirar Foto</Text>
+                  )}
+                </View>
+              </TouchableOpacity>
+            </View>
+            <View style={styles.containerButtonClose}>
+              <Button
+                disabled={load}
+                title="Fechar Camera"
+                onPress={onCloseModalHandler}
+              />
+              <View style={styles.cameraConfigs}>
+                <CameraConfigInfos
+                  exposure={cameraConfigs?.exposure}
+                  zoom={cameraConfigs?.zoom}
+                  showButtonInfo={cameraConfigs?.showButtonInfo}
+                />
+              </View>
+            </View>
+          </View>
+        </GestureHandlerRootView>
+      </Modal>
+    );
+  }
+
+  return null;
+};

package/src/screens/ValidadeFinger/styles.ts

@@ -0,0 +1,47 @@
+import { StyleSheet, Dimensions, Platform } from 'react-native';
+
+const { height } = Dimensions.get('window');
+
+export const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+  },
+  root: {
+    flex: 1,
+  },
+  cameraContainer: {
+    flex: 1,
+  },
+  camera: {
+    flex: 1,
+    justifyContent: 'flex-end',
+    paddingBottom: height * 0.2,
+  },
+  containerCapture: {
+    height: height * 0.2,
+    alignItems: 'center',
+    justifyContent: 'center',
+  },
+  containerButton: {
+    width: 350,
+    height: 100,
+    borderRadius: 80,
+    backgroundColor: 'blue',
+    alignItems: 'center',
+    justifyContent: 'center',
+  },
+  textButton: {
+    fontSize: 18,
+    fontWeight: '500',
+    color: '#fff',
+  },
+  modal: {
+    margin: 0,
+  },
+  containerButtonClose: {
+    marginBottom: Platform.OS === 'ios' ? 48 : 0,
+  },
+  cameraConfigs: {
+    alignItems: 'center',
+  },
+});

package/src/services/index.ts

@@ -0,0 +1,143 @@
+import { Platform } from 'react-native';
+import axios from 'axios';
+
+const BASE_URL = 'https://api.liveid.app.br';
+const TOKEN =
+  'eyJhbGciOiJIUzI1NiJ9.NmU5ZmQ0MzEtOTE0Yy00Njc1LWFkYjAtZjVjNjRlZDUxNDg0.9J8eydQk5fbkH5GKdXkmXpt6wdQWyw8bsbaP5POU6YA';
+
+const BASE_HEADER = {
+  'Content-Type': 'application/json',
+  'Authorization': `Bearer ${TOKEN}`,
+};
+
+const axiosInstance = axios.create({
+  baseURL: BASE_URL,
+});
+
+export const login = async (cpf: any, senha: any) => {
+  const response = await fetch(`${BASE_URL}/login`, {
+    method: 'POST',
+    headers: BASE_HEADER,
+    body: JSON.stringify({ cpf, senha }),
+  });
+  const data = await response.json();
+  return data;
+};
+
+export const cadastro = async (cpf: string, name: string, senha: string) => {
+  const response = await fetch(`${BASE_URL}/signup`, {
+    method: 'POST',
+    headers: BASE_HEADER,
+    body: JSON.stringify({ cpf, name, senha }),
+  });
+  const data = await response.json();
+  return data;
+};
+
+export const sendImages = async (UID: any, finger: any, images: any) => {
+  const response = await fetch(`${BASE_URL}/enroll-images`, {
+    method: 'POST',
+    headers: BASE_HEADER,
+    body: JSON.stringify({ UID, finger, images }),
+  });
+  const data = await response.json();
+  return data;
+};
+
+export const verifyDigital = async (UID: any, finger: any, image: any) => {
+  const response = await fetch(`${BASE_URL}/verify`, {
+    method: 'POST',
+    headers: BASE_HEADER,
+    body: JSON.stringify({ UID, finger, image }),
+  });
+  const data = await response.json();
+  return data;
+};
+
+type GetConfigApi = {
+  id: number;
+  deviceModels: string[];
+  deviceType: string;
+  fps: number;
+  exposure: number;
+  zoom: number;
+  serviceType: string;
+  showButtonInfo: boolean;
+}[];
+
+export const getConfigsApi = async (): Promise<GetConfigApi> => {
+  const { data } = await axiosInstance.get('/configs', {
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${TOKEN}`,
+    },
+  });
+  return data.deviceParamsConfig;
+};
+
+export const verificaCPF = async (cpf: any) => {
+  const response = await fetch(`${BASE_URL}/validcpf`, {
+    method: 'POST',
+    headers: BASE_HEADER,
+    body: JSON.stringify({ cpf }),
+  });
+  const data = await response.json();
+  return data;
+};
+
+export const provaVida = async (
+  video: { path: any },
+  UID: string,
+  vlexposure: any
+) => {
+  const numeroAleatorio = gerarNumeroAleatorio();
+
+  const formData = new FormData();
+  formData.append('video', {
+    uri: Platform.select({
+      ios: video.path,
+      android: `file://${video.path}`,
+    }),
+    type: 'video/mp4',
+    name: `${UID}_${numeroAleatorio}.mp4`,
+  });
+
+  formData.append('video_key', numeroAleatorio);
+  formData.append('person_id', UID);
+  formData.append('exposure', vlexposure);
+
+  const response = await fetch(`${BASE_URL}/liveness`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'multipart/form-data',
+      'Authorization': `Bearer ${TOKEN}`,
+    },
+    body: formData,
+  });
+
+  if (response.status === 200) {
+    const json = await response.json();
+    return json;
+  } else {
+    const errorJson = {
+      code: -1,
+      message: 'Erro, por favor, verifique e tente novamente!',
+    };
+    return errorJson;
+  }
+};
+
+const gerarNumeroAleatorio = () => {
+  const min = 10000000; // Menor número de 8 dígitos (10 milhões)
+  const max = 99999999; // Maior número de 8 dígitos (99 milhões 999 mil 999)
+
+  // Gera um número aleatório entre min e max
+  const numeroAleatorio = Math.floor(Math.random() * (max - min + 1)) + min;
+
+  // Converte o número para string
+  const numeroString = numeroAleatorio.toString();
+
+  return numeroString;
+};
+
+//https://api.liveid.app.br/change_configs

package/src/types/screen.ts

@@ -0,0 +1,5 @@
+export interface ScreenProps {
+  id?: string;
+  cpf?: string;
+  base64Image?: string;
+}

package/src/utils/file.ts

@@ -0,0 +1,30 @@
+import RNFS from 'react-native-fs';
+
+export const encodeImageToBase64 = async (imagePath: string) => {
+  try {
+    const imageData = await RNFS.readFile(imagePath, 'base64');
+    return imageData;
+  } catch (error) {
+    return null;
+  }
+};
+
+export const validarBase64 = (array: string | any[]) => {
+  // Verifica se o argumento é um array e tem exatamente 3 elementos
+  if (!Array.isArray(array) || array.length !== 3) {
+    return false;
+  }
+
+  // Regex para validar base64
+  const base64Regex = /^[a-zA-Z0-9+/]*={0,2}$/;
+
+  // Verifica se cada elemento do array é uma string válida em base64
+  for (let i = 0; i < array.length; i++) {
+    if (typeof array[i] !== 'string' || !base64Regex.test(array[i])) {
+      return false;
+    }
+  }
+
+  // Se chegou até aqui, o array é válido
+  return true;
+};

package/src/utils/getConfigCamera.ts

@@ -0,0 +1,45 @@
+import { Platform } from 'react-native';
+import { getModel } from 'react-native-device-info';
+import { getConfigsApi } from '../services';
+
+type ServiceType = 'finger' | 'liveness';
+
+type GetConfigCameraReturn =
+  | {
+      id: number;
+      deviceModels: string[];
+      deviceType: string;
+      fps: number;
+      exposure: number;
+      zoom: number;
+      serviceType: string;
+      showButtonInfo: boolean;
+    }
+  | undefined;
+
+const getConfigCamera = async (
+  serviceType: ServiceType
+): Promise<GetConfigCameraReturn> => {
+  const deviceModel = getModel();
+  const deviceType = Platform.OS;
+  try {
+    const configs = await getConfigsApi();
+    const configsDeviceType = configs.filter(
+      (config) =>
+        config.deviceType === deviceType && config.serviceType === serviceType
+    );
+    const configDeviceModel = configsDeviceType.find(
+      (config) =>
+        config.deviceModels.includes(deviceModel) ||
+        config.deviceModels.includes('default')
+    );
+
+    return configDeviceModel;
+  } catch (error) {
+    console.error(error);
+    // Estudar futuramente a possibilidade de incluir um wrapper para personalização de erro
+    return;
+  }
+};
+
+export default getConfigCamera;

package/src/utils/index.ts

@@ -0,0 +1,3 @@
+import getConfigCamera from './getConfigCamera';
+
+export { getConfigCamera };