@ha_tecno/live-id-sdk 2.12.2 → 2.13.0

package/src/services/services.ts

@@ -8,7 +8,11 @@ import type {
   RegisterFingerResponse,
   RegisterFingerImagesType,
   AuthFingerType,
-  AuthFingerResponse
+  AuthFingerResponse,
+  SendImagesForRegisterOperationPointsType,
+  SendImagesForRegisterOperationPointsResponse,
+  SendVideoForRegisterOperationPointsType,
+  SendVideoForRegisterOperationPointsResponse
 } from "./types";
 import DeviceInfo from "react-native-device-info";
 
@@ -136,3 +140,111 @@ export const lifeCertificate = async ({
     };
   }
 };
+
+export const getConfigOperationPoints = async (): Promise<GetConfigApiResponse> => {
+  const { data } = await axiosInstance.get("/configs", {
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${TOKEN}`
+    }
+  });
+  return data.deviceParamsConfig;
+};
+
+export const sendImagesForRegisterOperationPoints = async ({
+  deviceModel,
+  exposure,
+  exposureMax,
+  exposureMin,
+  exposureScaleZeroToOneBiometrics,
+  images,
+  zoom,
+  zoomMax,
+  zoomMin,
+  zoomScaleZeroToOne
+}: SendImagesForRegisterOperationPointsType): Promise<SendImagesForRegisterOperationPointsResponse> => {
+  try {
+    const { data } = await axiosInstance.post(
+      "/images-quality",
+      {
+        device_model: deviceModel,
+        images,
+        exposure,
+        exposureMin,
+        exposureMax,
+        exposureScaleZeroToOne: exposureScaleZeroToOneBiometrics,
+        zoom,
+        zoomMin,
+        zoomMax,
+        zoomScaleZeroToOne,
+        operationalSystem: Platform.OS
+      },
+      {
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${TOKEN}`
+        }
+      }
+    );
+    return {
+      message: "Cadastro de ponto de operação realizado com sucesso!",
+      status: data.status
+    };
+  } catch (error: any) {
+    return {
+      message: "Continue, faça com o próximo ponto de operação.",
+      status: error.response.data.status
+    };
+  }
+};
+
+export const sendVideoForRegisterOperationPoints = async ({
+  deviceModel,
+  exposure,
+  exposureMax,
+  exposureMin,
+  exposureScaleZeroToOneLifeCertificate,
+  videoPath
+}: SendVideoForRegisterOperationPointsType): Promise<SendVideoForRegisterOperationPointsResponse> => {
+  try {
+    const uuidv4 = uuid.v4();
+    const formData = new FormData();
+
+    formData.append("video", {
+      uri: Platform.select({
+        ios: videoPath,
+        android: `file://${videoPath}`
+      }),
+      type: "video/mp4",
+      name: `${uuidv4}.mp4`
+    });
+
+    formData.append("video_key", uuidv4);
+    formData.append("device_model", deviceModel);
+    formData.append("operationalSystem", Platform.OS);
+    formData.append("exposure", exposure);
+    formData.append("exposureMin", exposureMin);
+    formData.append("exposureMax", exposureMax);
+    formData.append("exposureScaleZeroToOne", exposureScaleZeroToOneLifeCertificate);
+
+    const { data } = await axiosInstance.post("/video-quality", formData, {
+      headers: {
+        "Content-Type": "multipart/form-data",
+        Authorization: `Bearer ${TOKEN}`
+      }
+    });
+    const hasConfig = data.config !== undefined;
+    return {
+      message: hasConfig
+        ? "Cadastro de ponto de operação realizado com sucesso!"
+        : "A calibração foi um sucesso, faça novamente mais uma vez!",
+      status: data.status,
+      hasConfig
+    };
+  } catch (e: any) {
+    return {
+      message: "Continue, faça com o próximo ponto de operação.",
+      status: e.response.data.status
+    };
+  }
+};

package/src/services/types.ts

@@ -58,3 +58,36 @@ export type LifeCertificateResponse = {
   bpm?: number;
   message?: string;
 };
+
+export type SendImagesForRegisterOperationPointsType = {
+  deviceModel: string;
+  images: string[];
+  exposure: number;
+  exposureMin: number;
+  exposureMax: number;
+  exposureScaleZeroToOneBiometrics: number;
+  zoom: number;
+  zoomMax: number;
+  zoomMin: number;
+  zoomScaleZeroToOne: number;
+};
+
+export type SendImagesForRegisterOperationPointsResponse = {
+  status: number;
+  message: string;
+};
+
+export type SendVideoForRegisterOperationPointsType = {
+  deviceModel: string;
+  videoPath: string;
+  exposure: number;
+  exposureScaleZeroToOneLifeCertificate: number;
+  exposureMin: number;
+  exposureMax: number;
+};
+
+export type SendVideoForRegisterOperationPointsResponse = {
+  status: number;
+  message: string;
+  hasConfig?: boolean;
+};

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

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

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

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

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

@@ -0,0 +1,240 @@
+import { create } from "zustand";
+import {
+  ExposureMapOperationPoints,
+  InitialState,
+  OperationPointsState,
+  SendImagesBase64Payload,
+  SetImageBase64Payload,
+  sendVideosLifeCertificatePayload
+} from "./types";
+import { Platform } from "react-native";
+import {
+  getConfigOperationPoints,
+  sendImagesForRegisterOperationPoints,
+  sendVideoForRegisterOperationPoints
+} from "../../../services";
+import { getModel } from "react-native-device-info";
+import { scale0to1, scale0to1Inverse } from "../../../utils";
+
+const initialState: InitialState = {
+  state: {
+    loading: "idle",
+    hasConfigOperationPointsBiometrics: "idle",
+    hasConfigOperationPointsLifeCertificate: "idle",
+    base64Images: [],
+    exposureScaleZeroToOneBiometrics: Platform.OS === "android" ? 0.12 : 0.3,
+    exposureScaleZeroToOneLifeCertificate: Platform.OS === "android" ? 0.12 : 0.3,
+    registered: false,
+    helpStep: "introduction"
+  }
+};
+
+const resetState = () => {
+  slice.setState((state) => ({
+    state: {
+      ...state.state,
+      loading: "idle",
+      base64Images: [],
+      registered: false,
+      helpStep: "introduction"
+    }
+  }));
+};
+
+const loadingPending = () => {
+  slice.setState((state) => ({
+    state: {
+      ...state.state,
+      loading: "pending"
+    }
+  }));
+};
+
+const setImageBase64 = (imageBase64: SetImageBase64Payload) => {
+  slice.setState((state) => ({
+    state: {
+      ...state.state,
+      base64Images: [...state.state.base64Images, imageBase64]
+    }
+  }));
+};
+
+const changeExposureBiometrics = () => {
+  resetState();
+  const exposureMap: ExposureMapOperationPoints = {
+    0.12: 0.2,
+    0.2: 0.35,
+    0.3: 0.4,
+    0.35: 0.5,
+    0.4: 0.5,
+    0.5: Platform.OS === "android" ? 0.65 : 0.6,
+    0.65: 0.8,
+    0.6: 0.7,
+    0.7: 0.3,
+    0.8: 0.12
+  };
+  slice.setState((state) => {
+    const { exposureScaleZeroToOneBiometrics } = state.state;
+    return {
+      state: {
+        ...state.state,
+        exposureScaleZeroToOneBiometrics:
+          exposureMap[exposureScaleZeroToOneBiometrics] || exposureScaleZeroToOneBiometrics
+      }
+    };
+  });
+};
+
+const changeExposureLifeCertificate = () => {
+  resetState();
+  const exposureMap: ExposureMapOperationPoints = {
+    0.12: 0.2,
+    0.2: 0.35,
+    0.3: 0.4,
+    0.35: 0.5,
+    0.4: 0.5,
+    0.5: Platform.OS === "android" ? 0.65 : 0.6,
+    0.65: 0.8,
+    0.6: 0.7,
+    0.7: 0.3,
+    0.8: 0.12
+  };
+  slice.setState((state) => {
+    const { exposureScaleZeroToOneLifeCertificate } = state.state;
+    return {
+      state: {
+        ...state.state,
+        exposureScaleZeroToOneLifeCertificate:
+          exposureMap[exposureScaleZeroToOneLifeCertificate] || exposureScaleZeroToOneLifeCertificate
+      }
+    };
+  });
+};
+
+const handleStepHelp = () => {
+  slice.setState((state) => {
+    const { helpStep } = state.state;
+    return {
+      state: {
+        ...state.state,
+        helpStep: helpStep === "introduction" ? "instruction" : "introduction"
+      }
+    };
+  });
+};
+
+// separar a lógica do store
+const getConfigDefault = async (operation: "finger" | "liveness") => {
+  const configs = await getConfigOperationPoints();
+  const deviceModel = getModel();
+  const deviceType = Platform.OS;
+  const configsDeviceType = configs.filter(
+    (config) => config.deviceType === deviceType && config.serviceType === operation
+  );
+  const configDeviceModel = configsDeviceType.find((config) => config.deviceModels.includes(deviceModel));
+  return configDeviceModel === undefined ? false : true;
+};
+
+const getConfigDefaultBiometrics = async () => {
+  const payload = await getConfigDefault("finger");
+  slice.setState((state) => ({
+    state: {
+      ...state.state,
+      hasConfigOperationPointsBiometrics: payload ? "notEmpty" : "empty"
+    }
+  }));
+  resetState();
+};
+
+const getConfigDefaultLifeCertificate = async () => {
+  const payload = await getConfigDefault("liveness");
+  slice.setState((state) => ({
+    state: {
+      ...state.state,
+      hasConfigOperationPointsLifeCertificate: payload ? "notEmpty" : "empty"
+    }
+  }));
+  resetState();
+};
+
+// separar a lógica do store
+const sendImagesBase64 = async ({
+  exposureScaleZeroToOneBiometrics,
+  base64Images,
+  exposureMax,
+  exposureMin,
+  zoomMax,
+  zoomMin
+}: SendImagesBase64Payload) => {
+  loadingPending();
+  const deviceModel = getModel();
+  const zoom = 3;
+  const zoomScaleZeroToOne = scale0to1(zoom, zoomMin, zoomMax);
+  const exposure = scale0to1Inverse(exposureScaleZeroToOneBiometrics, exposureMin, exposureMax);
+  const { message, status } = await sendImagesForRegisterOperationPoints({
+    deviceModel,
+    images: base64Images,
+    exposure,
+    exposureMin,
+    exposureMax,
+    exposureScaleZeroToOneBiometrics,
+    zoom,
+    zoomMin,
+    zoomMax,
+    zoomScaleZeroToOne
+  });
+  slice.setState((state) => ({
+    state: {
+      ...state.state,
+      loading: status === 200 ? "succeeded" : "failed",
+      status: status,
+      message: message
+    }
+  }));
+};
+
+// separar a lógica do store
+const sendVideosLifeCertificate = async ({
+  exposureMax,
+  exposureMin,
+  videoPath,
+  exposureScaleZeroToOneLifeCertificate
+}: sendVideosLifeCertificatePayload) => {
+  loadingPending();
+  const deviceModel = getModel();
+  const exposure = scale0to1Inverse(exposureScaleZeroToOneLifeCertificate, exposureMin, exposureMax);
+  const { message, status, hasConfig } = await sendVideoForRegisterOperationPoints({
+    deviceModel,
+    exposure,
+    videoPath,
+    exposureMax,
+    exposureMin,
+    exposureScaleZeroToOneLifeCertificate
+  });
+  slice.setState((state) => ({
+    state: {
+      ...state.state,
+      registered: hasConfig ?? false,
+      loading: status === 200 && hasConfig ? "succeeded" : "failed",
+      status: status,
+      message: message
+    }
+  }));
+};
+
+const slice = create<OperationPointsState>(() => ({
+  ...initialState,
+  dispatch: {
+    setImageBase64,
+    resetState,
+    changeExposureBiometrics,
+    changeExposureLifeCertificate,
+    handleStepHelp,
+    getConfigDefaultBiometrics,
+    getConfigDefaultLifeCertificate,
+    sendImagesBase64,
+    sendVideosLifeCertificate
+  }
+}));
+
+export default slice;

package/src/store/modules/operationPoints/types.ts

@@ -0,0 +1,61 @@
+type ScaleZeroToOneAndroid = 0.12 | 0.2 | 0.35 | 0.5 | 0.65 | 0.8;
+type ScaleZeroToOneIOS = 0.3 | 0.4 | 0.5 | 0.6 | 0.7;
+
+type StatusConfigOperationPoints = "empty" | "notEmpty" | "idle";
+
+type State = {
+  exposureScaleZeroToOneBiometrics: ScaleZeroToOneIOS | ScaleZeroToOneAndroid;
+  exposureScaleZeroToOneLifeCertificate: ScaleZeroToOneIOS | ScaleZeroToOneAndroid;
+  loading: "idle" | "pending" | "succeeded" | "failed";
+  hasConfigOperationPointsBiometrics: StatusConfigOperationPoints;
+  hasConfigOperationPointsLifeCertificate: StatusConfigOperationPoints;
+  base64Images: string[];
+  status?: number;
+  message?: string;
+  registered: boolean;
+  helpStep: "introduction" | "instruction";
+};
+
+type Dispatch = {
+  setImageBase64: (imageBase64: SetImageBase64Payload) => void;
+  resetState: () => void;
+  changeExposureBiometrics: () => void;
+  changeExposureLifeCertificate: () => void;
+  handleStepHelp: () => void;
+  getConfigDefaultBiometrics: () => void;
+  getConfigDefaultLifeCertificate: () => void;
+  sendImagesBase64: (payload: SendImagesBase64Payload) => void;
+  sendVideosLifeCertificate: (payload: sendVideosLifeCertificatePayload) => void;
+};
+
+export type InitialState = {
+  state: State;
+};
+
+export type OperationPointsState = {
+  state: State;
+  dispatch: Dispatch;
+};
+
+export type ExposureMapOperationPoints = Record<
+  State["exposureScaleZeroToOneBiometrics"],
+  State["exposureScaleZeroToOneBiometrics"]
+>;
+
+export type SetImageBase64Payload = string;
+
+export type SendImagesBase64Payload = {
+  base64Images: string[];
+  exposureScaleZeroToOneBiometrics: State["exposureScaleZeroToOneBiometrics"];
+  exposureMin: number;
+  exposureMax: number;
+  zoomMin: number;
+  zoomMax: number;
+};
+
+export type sendVideosLifeCertificatePayload = {
+  exposureMin: number;
+  exposureMax: number;
+  videoPath: string;
+  exposureScaleZeroToOneLifeCertificate: State["exposureScaleZeroToOneLifeCertificate"];
+};

package/src/utils/index.ts

@@ -1,5 +1,5 @@
 import getConfigCamera from "./getConfigCamera";
-import { randomHeartRate, filteredFingers } from "./utils";
+import { randomHeartRate, filteredFingers, scale0to1, scale0to1Inverse } from "./utils";
 import { useIsForeground } from "./hooks/useIsForeground";
 
-export { getConfigCamera, useIsForeground, randomHeartRate, filteredFingers };
+export { getConfigCamera, useIsForeground, randomHeartRate, filteredFingers, scale0to1, scale0to1Inverse };

package/src/utils/utils.ts

@@ -11,4 +11,12 @@ const filteredFingers = (
   return items.filter((item) => !registeredFingers.includes(item.value));
 };
 
-export { randomHeartRate, filteredFingers };
+const scale0to1 = (value: number, min: number, max: number) => {
+  return (value - min) / (max - min);
+};
+
+const scale0to1Inverse = (scaledValue: number, min: number, max: number) => {
+  return scaledValue * (max - min) + min;
+};
+
+export { randomHeartRate, filteredFingers, scale0to1, scale0to1Inverse };