@ha_tecno/live-id-sdk 2.12.3 → 2.13.0

package/lib/typescript/src/utils/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/utils/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAE3C,QAAA,MAAM,eAAe,QAAO,MAE3B,CAAC;AAEF,QAAA,MAAM,eAAe,sBACA,MAAM,EAAE,SACpB;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,EAAE,KACxC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,EAElC,CAAC;AAEF,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,CAAC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/utils/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAE3C,QAAA,MAAM,eAAe,QAAO,MAE3B,CAAC;AAEF,QAAA,MAAM,eAAe,sBACA,MAAM,EAAE,SACpB;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,EAAE,KACxC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,EAElC,CAAC;AAEF,QAAA,MAAM,SAAS,UAAW,MAAM,OAAO,MAAM,OAAO,MAAM,WAEzD,CAAC;AAEF,QAAA,MAAM,gBAAgB,gBAAiB,MAAM,OAAO,MAAM,OAAO,MAAM,WAEtE,CAAC;AAEF,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,SAAS,EAAE,gBAAgB,EAAE,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ha_tecno/live-id-sdk",
-  "version": "2.12.3",
+  "version": "2.13.0",
   "description": "React Native SDK for Live ID",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -147,6 +147,7 @@
   },
   "dependencies": {
     "@react-native-camera-roll/camera-roll": "^7.8.3",
+    "@react-native-community/slider": "^4.5.3",
     "@react-native-picker/picker": "^2.7.7",
     "axios": "^1.6.8",
     "react-native-device-info": "^10.13.1",

package/src/components/Typograph/typograph.tsx

@@ -0,0 +1,24 @@
+import React from "react";
+import { Text, TextStyle, useColorScheme } from "react-native";
+import { RFValue } from "react-native-responsive-fontsize";
+
+type Props = {
+  children: string | string[] | undefined;
+  bold?: boolean;
+  style?: TextStyle;
+};
+
+const HAText = ({ children, bold, style }: Props) => {
+  const isDark = useColorScheme() === "dark";
+
+  const textStyle: TextStyle = {
+    fontWeight: bold ? "bold" : "normal",
+    color: isDark ? "white" : "black",
+    fontSize: RFValue(16),
+    ...style
+  };
+
+  return <Text style={textStyle}>{children}</Text>;
+};
+
+export default HAText;

package/src/components/index.ts

@@ -4,5 +4,7 @@ import RecordButton from "./recordButton/recordButton";
 import CaptureButton from "./CaptureButton";
 import CameraConfigInfo from "./CameraConfigInfo";
 import Gabarito from "./Gabarito";
+import HAText from "./Typograph/typograph";
+import Icon from "./icon/icon";
 
-export { DeviceNotFound, ModalMessage, RecordButton, CaptureButton, CameraConfigInfo, Gabarito };
+export { DeviceNotFound, ModalMessage, RecordButton, CaptureButton, CameraConfigInfo, Gabarito, HAText, Icon };

package/src/index.tsx

@@ -1,3 +1,15 @@
-import { LifeCertificate, FingerRegister, FingerAuth } from "./screens";
+import {
+  LifeCertificate,
+  FingerRegister,
+  FingerAuth,
+  RegisterOperationPointsBiometrics,
+  RegisterOperationPointsLifeCertificate
+} from "./screens";
 
-export { LifeCertificate, FingerRegister, FingerAuth };
+export {
+  LifeCertificate,
+  FingerRegister,
+  FingerAuth,
+  RegisterOperationPointsBiometrics,
+  RegisterOperationPointsLifeCertificate
+};

package/src/screens/RegisterOperations/registerOperationPointsBiometrics.tsx

@@ -0,0 +1,168 @@
+import React, { useCallback, useEffect, useRef, useState } from "react";
+import { ActivityIndicator, Alert, BackHandler, Modal, View, useColorScheme } from "react-native";
+import { Camera, Point, useCameraDevice, useCameraFormat, useCameraPermission } from "react-native-vision-camera";
+import { runOnJS } from "react-native-reanimated";
+import { Gesture, GestureDetector, GestureHandlerRootView } from "react-native-gesture-handler";
+import { readFile } from "react-native-fs";
+import Slider from "@react-native-community/slider";
+
+import { useDispatch, useSelector } from "../../store/modules/operationPoints";
+import { scale0to1Inverse, useIsForeground } from "../../utils";
+import { CaptureButton, DeviceNotFound, Gabarito, HAText } from "../../components";
+import { styles } from "./styles";
+
+type Props = {
+  onSuccess: () => void;
+};
+
+const RegisterOperationPointsBiometrics = ({ onSuccess }: Props) => {
+  const isDark = useColorScheme() === "dark";
+  const backgroundColor = isDark ? "black" : "white";
+  const [zoom, setZoom] = useState<number>(2);
+  const [torch, setTorch] = useState<"off" | "on">("off");
+  const dispatch = useDispatch();
+  const { hasPermission, requestPermission } = useCameraPermission();
+  const cameraRef = useRef<Camera>(null);
+  const isForeground = useIsForeground();
+  const isActive = isForeground;
+
+  const { loading, exposureScaleZeroToOneBiometrics, message, base64Images } = useSelector();
+  const imagesCount = base64Images.length;
+
+  const containerCaptureStyled = [styles.containerCapture, { bottom: 20 }];
+
+  const device = useCameraDevice("back");
+  const cameraFormat = useCameraFormat(device, [
+    {
+      photoResolution: {
+        width: 1280,
+        height: 720
+      }
+    }
+  ]);
+
+  const cameraPermission = useCallback(async () => {
+    if (!hasPermission) {
+      await requestPermission();
+    }
+  }, [hasPermission, requestPermission]);
+
+  useEffect(() => {
+    cameraPermission();
+  }, [cameraPermission]);
+
+  useEffect(() => {
+    if (imagesCount === 3 && device != null) {
+      dispatch.sendImagesBase64({
+        base64Images,
+        exposureScaleZeroToOneBiometrics,
+        exposureMin: device.minExposure,
+        exposureMax: device.maxExposure,
+        zoomMin: device.minZoom,
+        zoomMax: device.maxZoom
+      });
+    }
+  }, [imagesCount, device, dispatch]);
+
+  const takePhoto = async () => {
+    const photo = await cameraRef.current?.takePhoto();
+    if (photo != null) {
+      const imageBase64 = await readFile(photo.path, "base64");
+      dispatch.setImageBase64(imageBase64);
+    }
+  };
+
+  const focus = useCallback((point: Point) => {
+    const camera = cameraRef.current;
+    if (camera != null) {
+      camera.focus(point);
+    }
+  }, []);
+
+  const gesture = Gesture.Tap().onBegin(({ x, y }) => {
+    runOnJS(focus)({ x, y });
+  });
+
+  useEffect(() => {
+    if (loading === "succeeded") {
+      Alert.alert("Sucesso", message, [{ text: "OK", onPress: () => onSuccess && onSuccess() }]);
+    }
+    if (loading === "failed") {
+      Alert.alert("Continue", message, [
+        {
+          text: "OK",
+          onPress: () => dispatch.changeExposureBiometrics()
+        }
+      ]);
+    }
+  }, [loading, message, dispatch]);
+
+  const backAction = () => {
+    const exit = BackHandler.exitApp;
+    Alert.alert("Atenção!", "Tem certeza que deseja sair?", [
+      {
+        text: "Cancelar",
+        onPress: () => null,
+        style: "cancel"
+      },
+      { text: "Sim", onPress: exit }
+    ]);
+    return true;
+  };
+
+  useEffect(
+    useCallback(() => {
+      const onBackPress = () => {
+        backAction();
+        return true;
+      };
+      BackHandler.addEventListener("hardwareBackPress", onBackPress);
+      return () => {
+        BackHandler.removeEventListener("hardwareBackPress", onBackPress);
+      };
+    }, [backAction])
+  );
+
+  const onInitialized = () => setTorch("on");
+
+  if (device == null || hasPermission === false)
+    return <DeviceNotFound hasPermission cameraPermission={cameraPermission} />;
+
+  return (
+    <GestureHandlerRootView style={{ flex: 1 }}>
+      <GestureDetector gesture={gesture}>
+        <View style={styles.containerCamera}>
+          <Camera
+            ref={cameraRef}
+            device={device}
+            style={styles.camera}
+            format={cameraFormat}
+            isActive={isActive}
+            torch={torch}
+            exposure={scale0to1Inverse(exposureScaleZeroToOneBiometrics, device.minExposure, device.maxExposure)}
+            zoom={zoom}
+            onInitialized={onInitialized}
+            photo
+          />
+          <Gabarito />
+        </View>
+      </GestureDetector>
+      <View style={containerCaptureStyled}>
+        <CaptureButton onPress={takePhoto} imagesCount={imagesCount} />
+      </View>
+      <View style={[styles.containerSlider, { backgroundColor }]}>
+        <HAText bold>{`Ponto de operação`}</HAText>
+        <Slider maximumValue={4} minimumValue={2} value={zoom} onValueChange={(value) => setZoom(value)} step={1} />
+      </View>
+      {loading === "pending" && (
+        <Modal animationType="fade" transparent visible={true}>
+          <View style={styles.containerModalLoading}>
+            <ActivityIndicator size="large" color="#fff" />
+          </View>
+        </Modal>
+      )}
+    </GestureHandlerRootView>
+  );
+};
+
+export default RegisterOperationPointsBiometrics;

package/src/screens/RegisterOperations/registerOperationPointsLifeCertificate.tsx

@@ -0,0 +1,175 @@
+import React, { useCallback, useEffect, useRef, useState } from "react";
+import { ActivityIndicator, Alert, BackHandler, Modal, View } from "react-native";
+import { Camera, useCameraDevice, useCameraFormat, useCameraPermission } from "react-native-vision-camera";
+
+import { useDispatch, useSelector } from "../../store/modules/operationPoints";
+import { scale0to1Inverse, useIsForeground } from "../../utils";
+import { DeviceNotFound, RecordButton } from "../../components";
+import { styles } from "./styles";
+
+type Props = {
+  onSuccess: () => void;
+};
+
+const RegisterOperationPointsLifeCertificate = ({ onSuccess }: Props) => {
+  const [torch, setTorch] = useState<"off" | "on">("off");
+  const dispatch = useDispatch();
+  const { hasPermission, requestPermission } = useCameraPermission();
+  const cameraRef = useRef<Camera>(null);
+  const isForeground = useIsForeground();
+  const isActive = isForeground;
+
+  const [intervalState, setIntervalState] = useState<NodeJS.Timeout | null>(null);
+  const [timer, setTimer] = useState(10);
+  const [isRecord, setIsRecord] = useState(false);
+
+  const { loading, registered, exposureScaleZeroToOneLifeCertificate, message } = useSelector();
+
+  const device = useCameraDevice("back");
+  const cameraFormat = useCameraFormat(device, [
+    {
+      videoResolution: {
+        width: 1280,
+        height: 720
+      }
+    }
+  ]);
+  const exposure = scale0to1Inverse(
+    exposureScaleZeroToOneLifeCertificate,
+    device !== undefined ? device.minExposure : 0,
+    device !== undefined ? device.maxExposure : 0
+  );
+
+  const cameraPermission = useCallback(async () => {
+    if (!hasPermission) {
+      await requestPermission();
+    }
+  }, [hasPermission, requestPermission]);
+
+  useEffect(() => {
+    cameraPermission();
+  }, [cameraPermission]);
+
+  useEffect(() => {
+    if (loading === "succeeded") {
+      Alert.alert("Sucesso", message, [
+        {
+          text: "OK",
+          onPress: () => {
+            registered ? () => onSuccess && onSuccess() : null;
+          }
+        }
+      ]);
+    }
+    if (loading === "failed") {
+      Alert.alert("Continue", message, [
+        {
+          text: "OK",
+          onPress: () => dispatch.changeExposureLifeCertificate()
+        }
+      ]);
+    }
+    setTimer(10);
+  }, [loading, message, dispatch]);
+
+  const backAction = () => {
+    const exit = BackHandler.exitApp;
+    Alert.alert("Atenção!", "Tem certeza que deseja sair?", [
+      {
+        text: "Cancelar",
+        onPress: () => null,
+        style: "cancel"
+      },
+      { text: "Sim", onPress: exit }
+    ]);
+    return true;
+  };
+
+  useEffect(
+    useCallback(() => {
+      const onBackPress = () => {
+        backAction();
+        return true;
+      };
+      BackHandler.addEventListener("hardwareBackPress", onBackPress);
+      return () => {
+        BackHandler.removeEventListener("hardwareBackPress", onBackPress);
+      };
+    }, [backAction])
+  );
+
+  const startVideoRecording = useCallback(() => {
+    setIsRecord(true);
+    if (device !== undefined) {
+      cameraRef.current?.startRecording({
+        fileType: "mp4",
+        onRecordingFinished: (video) =>
+          dispatch.sendVideosLifeCertificate({
+            exposureScaleZeroToOneLifeCertificate,
+            exposureMax: device.maxExposure,
+            exposureMin: device.minExposure,
+            videoPath: video.path
+          }),
+        onRecordingError: (error) => console.error(error)
+      });
+    }
+  }, [dispatch]);
+
+  const recordingVideo = useCallback(() => {
+    startVideoRecording();
+    setIntervalState(
+      setInterval(() => {
+        setTimer((prevTimer) => prevTimer - 1);
+      }, 1000)
+    );
+  }, [startVideoRecording]);
+
+  const stopRecodingVideo = useCallback(async () => {
+    setIsRecord(false);
+    await cameraRef.current?.stopRecording();
+  }, [dispatch]);
+
+  useEffect(() => {
+    if (timer < 0) {
+      if (!intervalState) return;
+      clearInterval(intervalState);
+      stopRecodingVideo();
+    }
+  }, [timer, intervalState, stopRecodingVideo]);
+
+  const onInitialized = () => setTorch("on");
+
+  if (device == null || hasPermission === false)
+    return <DeviceNotFound hasPermission={hasPermission} cameraPermission={cameraPermission} />;
+
+  return (
+    <>
+      <View style={styles.containerCamera}>
+        <Camera
+          ref={cameraRef}
+          device={device}
+          style={styles.camera}
+          format={cameraFormat}
+          isActive={isActive}
+          torch={torch}
+          exposure={exposure}
+          zoom={0}
+          onInitialized={onInitialized}
+          video
+        />
+      </View>
+      <View style={[styles.containerCapture, { bottom: 0 }]}>
+        <RecordButton onPress={recordingVideo} disabled={loading === "pending"} timer={timer} isRecording={isRecord} />
+      </View>
+      {loading === "pending" && (
+        <Modal animationType="fade" transparent visible>
+          <View style={styles.containerModalLoading}>
+            <ActivityIndicator size="large" color="#fff" />
+          </View>
+        </Modal>
+      )}
+    </>
+  );
+};
+
+export default RegisterOperationPointsLifeCertificate;

package/src/screens/RegisterOperations/styles.ts

@@ -0,0 +1,41 @@
+import { StyleSheet, Platform } from "react-native";
+
+export const styles = StyleSheet.create({
+  containerCamera: {
+    flex: 1,
+    justifyContent: "center"
+  },
+  camera: {
+    flex: 1
+  },
+  box: {
+    flexDirection: "row",
+    height: 50,
+    justifyContent: "center",
+    alignItems: "center",
+    borderRadius: 50,
+    backgroundColor: "#1F75FF",
+    marginVertical: Platform.OS === "android" ? 100 : 120
+  },
+  text: {
+    position: "absolute",
+    color: "#fff"
+  },
+  containerCapture: {
+    position: "absolute",
+    width: "100%",
+    marginBottom: "30%",
+    alignItems: "center"
+  },
+  containerModalLoading: {
+    flex: 1,
+    justifyContent: "center",
+    alignItems: "center",
+    backgroundColor: "rgba(0, 0, 0, 0.5)"
+  },
+  containerSlider: {
+    height: Platform.OS === "android" ? 100 : 120,
+    padding: 20,
+    gap: 10
+  }
+});

package/src/screens/index.ts

@@ -1,5 +1,13 @@
 import FingerRegister from "./FingerRegister/FingerRegister";
 import LifeCertificate from "./LifeCertificate/LifeCertificate";
 import FingerAuth from "./FingerAuth/FingerAuth";
+import RegisterOperationPointsBiometrics from "./RegisterOperations/registerOperationPointsBiometrics";
+import RegisterOperationPointsLifeCertificate from "./RegisterOperations/registerOperationPointsLifeCertificate";
 
-export { FingerRegister, LifeCertificate, FingerAuth };
+export {
+  FingerRegister,
+  LifeCertificate,
+  FingerAuth,
+  RegisterOperationPointsBiometrics,
+  RegisterOperationPointsLifeCertificate
+};

package/src/services/index.ts

@@ -1,4 +1,12 @@
-import { lifeCertificate, getConfigsApi, registerFingerImages, authFinger } from "./services";
+import {
+  lifeCertificate,
+  getConfigsApi,
+  registerFingerImages,
+  authFinger,
+  getConfigOperationPoints,
+  sendImagesForRegisterOperationPoints,
+  sendVideoForRegisterOperationPoints
+} from "./services";
 
 const BASE_URL = "https://api.liveid.app.br";
 const TOKEN =
@@ -39,4 +47,12 @@ export const verificaCPF = async (cpf: any) => {
   return data;
 };
 
-export { lifeCertificate, getConfigsApi, registerFingerImages, authFinger };
+export {
+  lifeCertificate,
+  getConfigsApi,
+  registerFingerImages,
+  authFinger,
+  getConfigOperationPoints,
+  sendImagesForRegisterOperationPoints,
+  sendVideoForRegisterOperationPoints
+};

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;