@ha_tecno/live-id-sdk 1.0.0 → 2.2.0

package/src/screens/LifeCertificate/index.tsx

@@ -0,0 +1,152 @@
+import React, { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { StatusBar, View } from "react-native";
+import Orientation from "react-native-orientation-locker";
+import { Camera, VideoFile, useCameraDevice, useCameraFormat, useCameraPermission } from "react-native-vision-camera";
+import { useDispatch, useSelector } from "../../store/modules/lifeCertificate";
+import { DeviceNotFound, ModalMessage, RecordButton, CameraConfigInfo } from "../../components";
+import { styles } from "./styles";
+
+type Props = {
+  UID: string;
+};
+
+const LifeCertificate = ({ UID }: Props) => {
+  const camera = useRef<Camera>(null);
+  const state = useSelector();
+  const dispatch = useDispatch();
+  const { hasPermission, requestPermission } = useCameraPermission();
+  const [intervalState, setIntervalState] = useState<NodeJS.Timeout | null>(null);
+  const [timer, setTimer] = useState(10);
+  const device = useCameraDevice("back");
+
+  const format = useCameraFormat(device, [
+    {
+      videoResolution: {
+        height: 1280,
+        width: 720
+      }
+    }
+  ]);
+
+  const cameraPermission = useCallback(async () => {
+    if (!hasPermission) {
+      await requestPermission();
+    }
+  }, [hasPermission, requestPermission]);
+
+  useEffect(() => {
+    cameraPermission();
+    dispatch.getConfig("liveness");
+  }, [cameraPermission, dispatch.getConfig]);
+
+  const containerRecordStyled = useMemo(
+    () => [styles.containerRecord, { bottom: state.showButtonInfo ? 75 : 20 }],
+    [state.showButtonInfo]
+  );
+
+  useEffect(() => {
+    Orientation.lockToPortrait();
+  }, []);
+
+  useEffect(() => {
+    if (state.code === 0) {
+      dispatch.setModal("Sucesso!", `Seu batimento está em: ${state.bpm}.\nProva de vida concluída!`);
+      dispatch.handleLoading();
+    }
+    if (state.code !== 0 && state.code !== null) {
+      dispatch.setModal("Ocorreu um erro!", `Erro: ${state.message}`);
+      dispatch.handleLoading();
+    }
+    setTimer(10);
+    dispatch.resetState();
+  }, [state.bpm, state.code, state.message, dispatch.handleLoading, dispatch.resetState, dispatch.setModal]);
+
+  const sendFile = useCallback(
+    async (file: VideoFile) => {
+      if (!UID) {
+        dispatch.setModal("Ocorreu um erro!", "Erro ao enviar o arquivo (id error)");
+      }
+      dispatch.sendLifeCertificate({
+        videoFile: file,
+        UID: UID,
+        exposure: state.exposure
+      });
+    },
+    [state.exposure, dispatch.sendLifeCertificate, dispatch.setModal, UID]
+  );
+
+  useEffect(() => {
+    return () => {
+      setTimer(0);
+    };
+  }, []);
+
+  useEffect(() => {
+    if (timer < 0 && intervalState != null) {
+      clearInterval(intervalState);
+      stopRecodingVideo();
+    }
+  }, [timer, intervalState]);
+
+  const startVideoRecording = useCallback(() => {
+    dispatch.setIsRecording(true);
+    camera.current?.startRecording({
+      flash: "off",
+      fileType: "mp4",
+      onRecordingFinished: (video) => sendFile(video),
+      onRecordingError: (error) => console.error(error)
+    });
+  }, [sendFile, dispatch.setIsRecording]);
+
+  const recordingVideo = useCallback(async () => {
+    startVideoRecording();
+    setIntervalState(
+      setInterval(() => {
+        setTimer((prevTimer) => prevTimer - 1);
+      }, 1000)
+    );
+  }, [startVideoRecording]);
+
+  const stopRecodingVideo = async () => {
+    dispatch.setIsRecording(false);
+    await camera.current?.stopRecording();
+    dispatch.handleLoading();
+  };
+
+  if (device == null || hasPermission === false)
+    return <DeviceNotFound hasPermission={hasPermission} cameraPermission={cameraPermission} />;
+
+  return (
+    <View style={styles.containerCamera}>
+      <StatusBar barStyle="light-content" />
+      <Camera
+        ref={camera}
+        style={styles.camera}
+        isActive={true}
+        device={device}
+        video={true}
+        torch={"on"}
+        format={format}
+        exposure={state.exposure}
+        zoom={state.zoom}
+        focusable={true}
+        photo={true}
+        enableHighQualityPhotos={true}
+        fps={30}
+        pixelFormat="native"
+      />
+      <View style={containerRecordStyled}>
+        <RecordButton
+          onPress={recordingVideo}
+          disabled={state.isRecording || state.loading}
+          timer={timer}
+          isRecording={state.isRecording}
+        />
+      </View>
+      {state.showButtonInfo && <CameraConfigInfo exposure={state.exposure} zoom={state.zoom} />}
+      <ModalMessage isLoading={state.loading} modal={state.modal} />
+    </View>
+  );
+};
+
+export default LifeCertificate;

package/src/screens/LifeCertificate/styles.ts

@@ -0,0 +1,21 @@
+import { StyleSheet } from "react-native";
+
+export const styles = StyleSheet.create({
+  containerCamera: {
+    flex: 1,
+    backgroundColor: "#0d0d0d"
+  },
+  camera: {
+    flex: 1
+  },
+  containerRecord: {
+    position: "absolute",
+    width: "100%",
+    alignItems: "center"
+  },
+  text: {
+    fontSize: 20,
+    fontWeight: "500",
+    color: "#000"
+  }
+});

package/src/screens/index.ts

@@ -0,0 +1,5 @@
+import FingerRegister from "./FingerRegister";
+import LifeCertificate from "./LifeCertificate";
+import FingerAuth from "./FingerAuth/FingerAuth";
+
+export { FingerRegister, LifeCertificate, FingerAuth };

package/src/services/index.ts

@@ -1,24 +1,19 @@
-import { Platform } from 'react-native';
-import axios from 'axios';
+import { lifeCertificate, getConfigsApi, registerFingerImages, authFinger } from "./services";
 
-const BASE_URL = 'https://api.liveid.app.br';
+const BASE_URL = "https://api.liveid.app.br";
 const TOKEN =
-  'eyJhbGciOiJIUzI1NiJ9.NmU5ZmQ0MzEtOTE0Yy00Njc1LWFkYjAtZjVjNjRlZDUxNDg0.9J8eydQk5fbkH5GKdXkmXpt6wdQWyw8bsbaP5POU6YA';
+  "eyJhbGciOiJIUzI1NiJ9.NmU5ZmQ0MzEtOTE0Yy00Njc1LWFkYjAtZjVjNjRlZDUxNDg0.9J8eydQk5fbkH5GKdXkmXpt6wdQWyw8bsbaP5POU6YA";
 
 const BASE_HEADER = {
-  'Content-Type': 'application/json',
-  'Authorization': `Bearer ${TOKEN}`,
+  "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',
+    method: "POST",
     headers: BASE_HEADER,
-    body: JSON.stringify({ cpf, senha }),
+    body: JSON.stringify({ cpf, senha })
   });
   const data = await response.json();
   return data;
@@ -26,118 +21,22 @@ export const login = async (cpf: any, senha: any) => {
 
 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',
+    method: "POST",
     headers: BASE_HEADER,
-    body: JSON.stringify({ UID, finger, images }),
+    body: JSON.stringify({ cpf, name, senha })
   });
   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',
+    method: "POST",
     headers: BASE_HEADER,
-    body: JSON.stringify({ cpf }),
+    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
+export { lifeCertificate, getConfigsApi, registerFingerImages, authFinger };

package/src/services/services.ts

@@ -0,0 +1,129 @@
+import axios from "axios";
+import { Platform } from "react-native";
+import uuid from "react-native-uuid";
+import type {
+  GetConfigApiResponse,
+  LifeCertificateResponse,
+  LifeCertificateType,
+  RegisterFingerResponse,
+  RegisterFingerImagesType,
+  AuthFingerType,
+  AuthFingerResponse
+} from "./types";
+import DeviceInfo from "react-native-device-info";
+
+const API_URL = "https://api.liveid.app.br";
+const TOKEN =
+  "eyJhbGciOiJIUzI1NiJ9.NmU5ZmQ0MzEtOTE0Yy00Njc1LWFkYjAtZjVjNjRlZDUxNDg0.9J8eydQk5fbkH5GKdXkmXpt6wdQWyw8bsbaP5POU6YA";
+
+const axiosInstance = axios.create({
+  baseURL: API_URL
+});
+
+export const getConfigsApi = async (): Promise<GetConfigApiResponse> => {
+  const { data } = await axiosInstance.get("/configs", {
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${TOKEN}`
+    }
+  });
+  return data.deviceParamsConfig;
+};
+
+export const registerFingerImages = async ({
+  UID,
+  images
+}: RegisterFingerImagesType): Promise<RegisterFingerResponse> => {
+  try {
+    const finger = "DI";
+    const { data } = await axiosInstance.post(
+      "/enroll-images",
+      { UID, finger, images },
+      {
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${TOKEN}`
+        }
+      }
+    );
+    return {
+      code: data.code,
+      message: data.message
+    };
+  } catch (error: any) {
+    console.error(error.response.data);
+    return {
+      code: error.response.data.code,
+      message: error.response.data.message
+    };
+  }
+};
+
+export const authFinger = async ({ UID, image }: AuthFingerType): Promise<AuthFingerResponse> => {
+  try {
+    const finger = "DI";
+    const { data } = await axiosInstance.post(
+      "/verify",
+      { UID, finger, image },
+      {
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${TOKEN}`
+        }
+      }
+    );
+    console.log(data);
+    return {
+      code: data.code,
+      message: data.message
+    };
+  } catch (error: any) {
+    console.error(error.response.data);
+    return {
+      code: error.response.data.code,
+      message: error.response.data.message
+    };
+  }
+};
+
+export const lifeCertificate = async ({
+  videoPath,
+  exposure,
+  UID
+}: LifeCertificateType): Promise<LifeCertificateResponse> => {
+  try {
+    const uuidv4 = uuid.v4();
+    const deviceModel = DeviceInfo.getModel();
+    const formData = new FormData();
+    formData.append("video", {
+      uri: Platform.select({
+        ios: videoPath,
+        android: `file://${videoPath}`
+      }),
+      type: "video/mp4",
+      name: `${UID}_${uuidv4}.mp4`
+    });
+
+    formData.append("video_key", uuidv4);
+    formData.append("person_id", UID);
+    formData.append("device_model", deviceModel);
+    formData.append("exposure", exposure);
+
+    const { data } = await axiosInstance.post("/liveness", formData, {
+      headers: {
+        "Content-Type": "multipart/form-data",
+        Authorization: `Bearer ${TOKEN}`
+      }
+    });
+    return {
+      code: data.code,
+      bpm: data.bpm
+    };
+  } catch (error: any) {
+    console.error(error.response.data.message);
+    return {
+      code: error.response.data.code,
+      message: error.response.data.message
+    };
+  }
+};

package/src/services/types.ts

@@ -0,0 +1,42 @@
+export type GetConfigApiResponse = {
+  id: number;
+  deviceModels: string[];
+  deviceType: string;
+  fps: number;
+  exposure: number;
+  zoom: number;
+  serviceType: string;
+  showButtonInfo: boolean;
+}[];
+
+export type RegisterFingerImagesType = {
+  UID: string;
+  images: string[];
+};
+
+export type RegisterFingerResponse = {
+  code: number;
+  message?: string;
+};
+
+export type AuthFingerType = {
+  UID: string;
+  image: string;
+};
+
+export type AuthFingerResponse = {
+  code: number;
+  message?: string;
+};
+
+export type LifeCertificateType = {
+  videoPath: string;
+  UID: string;
+  exposure: number;
+};
+
+export type LifeCertificateResponse = {
+  code: number;
+  bpm?: number;
+  message?: string;
+};

package/src/store/createSelectors.ts

@@ -0,0 +1,15 @@
+import { StoreApi, UseBoundStore } from "zustand";
+
+type WithSelectors<S> = S extends { getState: () => infer T } ? S & { use: { [K in keyof T]: () => T[K] } } : never;
+
+const createSelectors = <S extends UseBoundStore<StoreApi<object>>>(_store: S) => {
+  let store = _store as WithSelectors<typeof _store>;
+  store.use = {};
+  for (let k of Object.keys(store.getState())) {
+    (store.use as any)[k] = () => store((s) => s[k as keyof typeof s]);
+  }
+
+  return store;
+};
+
+export default createSelectors;

package/src/store/modules/fingerAuth/index.ts

@@ -0,0 +1,3 @@
+import { useDispatch, useSelector } from "./selectors";
+
+export { useDispatch, useSelector };

package/src/store/modules/fingerAuth/selectors.ts

@@ -0,0 +1,7 @@
+import createSelectors from "../../createSelectors";
+import FingerAuthStore from "./slice";
+
+const selector = createSelectors(FingerAuthStore);
+
+export const useSelector = selector.use.state;
+export const useDispatch = selector.use.dispatch;

package/src/store/modules/fingerAuth/slice.ts

@@ -0,0 +1,91 @@
+import { create } from "zustand";
+import { getConfigCamera } from "../../../utils";
+import { FingerAuthState, InitialState } from "./type";
+import { readFile } from "react-native-fs";
+import { authFinger } from "../../../services";
+
+const initialState: InitialState = {
+  state: {
+    exposure: 0,
+    zoom: 0,
+    showButtonInfo: false,
+    loading: false,
+    code: null,
+    message: "",
+    modal: {
+      title: "",
+      message: ""
+    }
+  }
+};
+
+const getConfig = async (serviceType: "finger" | "liveness") => {
+  const config = await getConfigCamera(serviceType);
+  slice.setState((state) => ({
+    state: {
+      ...state.state,
+      ...config
+    }
+  }));
+};
+
+const setModal = (title: string, message: string) => {
+  slice.setState((state) => ({
+    state: {
+      ...state.state,
+      modal: {
+        title,
+        message
+      }
+    }
+  }));
+};
+
+const handleLoading = () => {
+  slice.setState((state) => ({
+    state: {
+      ...state.state,
+      loading: !state.state.loading
+    }
+  }));
+};
+
+const sendImage = async (imagePath: string, UID: string) => {
+  try {
+    handleLoading();
+    const convertedImage = await readFile(imagePath, "base64");
+    const response = await authFinger({ UID, image: convertedImage });
+    slice.setState((state) => ({
+      state: {
+        ...state.state,
+        message: response.message ?? "",
+        code: response.code
+      }
+    }));
+  } catch (error) {
+    console.error("error:", error);
+  }
+};
+
+const resetState = () => {
+  slice.setState((state) => ({
+    state: {
+      ...state.state,
+      code: null,
+      message: ""
+    }
+  }));
+};
+
+const slice = create<FingerAuthState>(() => ({
+  ...initialState,
+  dispatch: {
+    getConfig,
+    sendImage,
+    resetState,
+    handleLoading,
+    setModal
+  }
+}));
+
+export default slice;

package/src/store/modules/fingerAuth/type.ts

@@ -0,0 +1,29 @@
+type State = {
+  exposure: number;
+  zoom: number;
+  showButtonInfo: boolean;
+  loading: boolean;
+  code: null | number;
+  message: string;
+  modal: {
+    title: string;
+    message: string;
+  };
+};
+
+type Dispatch = {
+  getConfig: (serviceType: "finger" | "liveness") => void;
+  handleLoading: () => void;
+  sendImage: (imagePath: string, UID: string) => void;
+  resetState: () => void;
+  setModal: (title: string, message: string) => void;
+};
+
+export type InitialState = {
+  state: State;
+};
+
+export type FingerAuthState = {
+  state: State;
+  dispatch: Dispatch;
+};

package/src/store/modules/fingerRegister/index.ts

@@ -0,0 +1,3 @@
+import { useDispatch, useSelector } from "./selectors";
+
+export { useDispatch, useSelector };

package/src/store/modules/fingerRegister/selectors.ts

@@ -0,0 +1,7 @@
+import createSelectors from "../../createSelectors";
+import FingerRegisterStore from "./slice";
+
+const selector = createSelectors(FingerRegisterStore);
+
+export const useSelector = selector.use.state;
+export const useDispatch = selector.use.dispatch;