@ha_tecno/live-id-sdk 2.12.3 → 2.13.0

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 };