easyproctor 2.5.2 → 2.5.3

package/README.md

@@ -263,6 +263,9 @@ const {
   token: "...",
 });
 ```
+## Release Note V 2.5.3
+- Fix: Resolução do video
+- Melhorias no proctoring do tipo REALTIME
 
 ## Release Note V 2.5.2
 - Alteração do nome do callback 'onFinish' para 'onResultAvailable'

package/esm/index.js

@@ -8791,6 +8791,14 @@ var BaseDetection = class {
         return "Face n\xE3o centralizada, mova-se para cima";
       case "wrong_face_position_move_bottom_detected":
         return "Face n\xE3o centralizada, mova-se para baixo";
+      case "face_turned_left_detected":
+        return "Face virada para a esquerda, centralize-a";
+      case "face_turned_right_detected":
+        return "Face virada para a direita, centralize-a";
+      case "face_turned_up_detected":
+        return "Face virada para cima, centralize-a";
+      case "face_turned_down_detected":
+        return "Face virada para baixo, centralize-a";
       default:
         return description;
     }
@@ -8821,7 +8829,14 @@ function buildVideoPreview() {
 // src/modules/faceDetection.ts
 var FaceDetection = class extends BaseDetection {
   constructor(options, paramsConfig, classVideo = "videoPreviewFrameDetection", classDiv = "liveViewFrameDetection") {
-    super("FaceDetector", `https://storage.googleapis.com/mediapipe-models/face_detector/blaze_face_short_range/float16/1/blaze_face_short_range.tflite`, options, paramsConfig, classVideo, classDiv);
+    super(
+      "FaceDetector",
+      `https://storage.googleapis.com/mediapipe-models/face_detector/blaze_face_short_range/float16/1/blaze_face_short_range.tflite`,
+      options,
+      paramsConfig,
+      classVideo,
+      classDiv
+    );
     this.emmitedPositionAlert = false;
     this.emmitedFaceAlert = false;
   }
@@ -8967,8 +8982,8 @@ var FaceDetection = class extends BaseDetection {
         for (const keypoint of detection.keypoints) {
           const keypointEl = document.createElement("span");
           keypointEl.className = "key-point";
-          let kpX = keypoint.x < 2 ? keypoint.x * videoElement.videoWidth : keypoint.x;
-          let kpY = keypoint.y < 2 ? keypoint.y * videoElement.videoHeight : keypoint.y;
+          const kpX = keypoint.x < 2 ? keypoint.x * videoElement.videoWidth : keypoint.x;
+          const kpY = keypoint.y < 2 ? keypoint.y * videoElement.videoHeight : keypoint.y;
           const mirroredKpX = videoElement.videoWidth - kpX;
           const screenX = mirroredKpX * scaleX;
           const screenY = kpY * scaleY;
@@ -9007,55 +9022,87 @@ var FaceDetection = class extends BaseDetection {
       }
     }
     if (result.detections.length === 0) return;
-    let face = result.detections[0].boundingBox;
-    let video = document.getElementById(this.classVideo);
+    let failedFacePosition = false;
+    const video = document.getElementById(this.classVideo);
     const imageWidth = video.videoWidth;
     const imageHeight = video.videoHeight;
-    let failedFacePosition = false;
+    const detection = result.detections[0];
+    const face = detection.boundingBox;
+    const keypoints = detection.keypoints;
+    const rightEye = keypoints[0];
+    const leftEye = keypoints[1];
+    const mouth = keypoints[3];
+    const rightEar = keypoints[4];
+    const leftEar = keypoints[5];
+    const nose = keypoints[2];
     if (imageWidth > imageHeight) {
       if (face.height / imageHeight > 0.7) {
-        !this.emmitedPositionAlert && this.handleAlert("wrong_face_size_detected", "position_detection_on_stream");
+        !this.emmitedPositionAlert && this.handleAlert(
+          "wrong_face_size_detected",
+          "position_detection_on_stream"
+        );
         failedFacePosition = true;
         this.emmitedPositionAlert = true;
       } else if (face.width / imageWidth > 0.7) {
-        !this.emmitedPositionAlert && this.handleAlert("wrong_face_size_detected", "position_detection_on_stream");
+        !this.emmitedPositionAlert && this.handleAlert(
+          "wrong_face_size_detected",
+          "position_detection_on_stream"
+        );
         this.emmitedPositionAlert = true;
         failedFacePosition = true;
       }
     }
-    let start = [face.originX, face.originY];
-    let end = [face.originX + face.width, face.originY + face.height];
+    const start = [face.originX, face.originY];
+    const end = [face.originX + face.width, face.originY + face.height];
     if (start[0] < 0.1 * face.width || start[1] < 0.2 * face.height || end[0] > imageWidth - 0.1 * face.width || end[1] > imageHeight - 5) {
-      !this.emmitedPositionAlert && this.handleAlert("wrong_face_position_edge_detected", "position_detection_on_stream");
+      !this.emmitedPositionAlert && this.handleAlert(
+        "wrong_face_position_edge_detected",
+        "position_detection_on_stream"
+      );
       this.emmitedPositionAlert = true;
       failedFacePosition = true;
     }
-    let leftGap = start[0];
-    let rightGap = imageWidth - end[0];
-    let topGap = start[1];
-    let bottomGap = imageHeight - end[1];
+    const leftGap = start[0];
+    const rightGap = imageWidth - end[0];
+    const topGap = start[1];
+    const bottomGap = imageHeight - end[1];
     if (leftGap > 2 * rightGap) {
-      !this.emmitedPositionAlert && this.handleAlert("wrong_face_position_move_right_detected", "position_detection_on_stream");
+      !this.emmitedPositionAlert && this.handleAlert(
+        "wrong_face_position_move_right_detected",
+        "position_detection_on_stream"
+      );
       this.emmitedPositionAlert = true;
       failedFacePosition = true;
     }
     if (topGap > 4 * bottomGap) {
-      !this.emmitedPositionAlert && this.handleAlert("wrong_face_position_move_top_detected", "position_detection_on_stream");
+      !this.emmitedPositionAlert && this.handleAlert(
+        "wrong_face_position_move_top_detected",
+        "position_detection_on_stream"
+      );
       this.emmitedPositionAlert = true;
       failedFacePosition = true;
     }
     if (rightGap > 2 * leftGap) {
-      !this.emmitedPositionAlert && this.handleAlert("wrong_face_position_move_left_detected", "position_detection_on_stream");
+      !this.emmitedPositionAlert && this.handleAlert(
+        "wrong_face_position_move_left_detected",
+        "position_detection_on_stream"
+      );
       this.emmitedPositionAlert = true;
       failedFacePosition = true;
     }
     if (bottomGap > 3 * topGap) {
-      !this.emmitedPositionAlert && this.handleAlert("wrong_face_position_move_bottom_detected", "position_detection_on_stream");
+      !this.emmitedPositionAlert && this.handleAlert(
+        "wrong_face_position_move_bottom_detected",
+        "position_detection_on_stream"
+      );
       this.emmitedPositionAlert = true;
       failedFacePosition = true;
     }
     if (failedFacePosition == false) {
-      this.emmitedPositionAlert && this.handleOk("ok_position_face_detected", "position_detection_on_stream");
+      this.emmitedPositionAlert && this.handleOk(
+        "ok_position_face_detected",
+        "position_detection_on_stream"
+      );
       this.emmitedPositionAlert = false;
     }
   }
@@ -11772,12 +11819,12 @@ var BackendService = class {
     });
     return result.data;
   }
-  async verifyFace(proctoringId2, faceImage) {
+  async verifyFace(proctoringId2, faceImage, retry) {
     const result = await this.makeRequestAxios({
       path: `/Realtime/verify-face`,
       method: "POST",
       jwt: this.token,
-      body: { "proctoringId": proctoringId2, "base64": faceImage }
+      body: { "proctoringId": proctoringId2, "base64": faceImage, "retry": retry }
     });
     return result.data;
   }
@@ -12653,7 +12700,6 @@ var CameraRecorder = class {
         noiseLimit: 40
       },
       imageBehaviourParameters: {
-        frames: 40,
         useUploadImage: true,
         uploadInterval: 20,
         saveVideo: true
@@ -12665,7 +12711,6 @@ var CameraRecorder = class {
       }
     };
     // private imageParams: ImageParameters = {
-    //     frames: 40,
     //     useUploadImage: true,
     //     uploadInterval: 20,
     //     saveVideo: true
@@ -13574,8 +13619,20 @@ var DeviceCheckerUI = class {
     );
     checkmark_FacePosition.appendChild(checkmark_stem_FacePosition);
     checkmark_FacePosition.appendChild(checkmark_kick_FacePosition);
+    const info_FacePosition = document.createElement("span");
+    const info_stem_FacePosition = document.createElement("div");
+    const info_kick_FacePosition = document.createElement("div");
+    info_FacePosition.style.marginLeft = "10px";
+    info_FacePosition.setAttribute("class", "info");
+    info_FacePosition.setAttribute("id", "info_FacePosition");
+    info_FacePosition.style.display = "none";
+    info_stem_FacePosition.setAttribute("class", "info_stem");
+    info_kick_FacePosition.setAttribute("class", "info_kick");
+    info_FacePosition.appendChild(info_stem_FacePosition);
+    info_FacePosition.appendChild(info_kick_FacePosition);
     alertDivFacePosition.appendChild(checkmark_FacePosition);
     alertDivFacePosition.appendChild(facePositionAlert);
+    alertDivFacePosition.appendChild(info_FacePosition);
     const alertDivAmbientVerify = document.createElement("div");
     alertDivAmbientVerify.setAttribute("class", "alert-div");
     alertDivAmbientVerify.setAttribute("id", "alertDivAmbientVerify");
@@ -13906,6 +13963,8 @@ var DeviceCheckerUI = class {
   realtimeAlertsUI(response) {
     const facePositionAlert = document.getElementById("facePositionAlert");
     const ambientVerifyAlert = document.getElementById("ambientVerifyAlert");
+    const alertDivFacePosition = document.getElementById("alertDivFacePosition");
+    const info_FacePosition = document.getElementById("info_FacePosition");
     const checkmark_FacePosition = document.getElementById("checkmark_FacePosition");
     const checkmark_stem_FacePosition = document.getElementById("checkmark_stem_FacePosition");
     const checkmark_kick_FacePosition = document.getElementById("checkmark_kick_FacePosition");
@@ -13916,6 +13975,8 @@ var DeviceCheckerUI = class {
     if (response.status === "OK") {
       facePositionAlert && (facePositionAlert.style.color = "#16A34A");
       ambientVerifyAlert && (ambientVerifyAlert.style.color = "#16A34A");
+      alertDivFacePosition && alertDivFacePosition.setAttribute("title", ``);
+      info_FacePosition && (info_FacePosition.style.display = "none");
       alertDivAmbientVerify && alertDivAmbientVerify.setAttribute("title", ``);
       if (checkmark_FacePosition) {
         checkmark_FacePosition.setAttribute("class", "checkmark");
@@ -13930,6 +13991,8 @@ var DeviceCheckerUI = class {
     } else {
       if (checkmark_FacePosition && (response.type === "position_detection_on_stream" || response.type === "face_detection_on_stream")) {
         facePositionAlert && (facePositionAlert.style.color = "#FF0000");
+        info_FacePosition && (info_FacePosition.style.display = "block");
+        alertDivFacePosition && alertDivFacePosition.setAttribute("title", response.description);
         checkmark_FacePosition.setAttribute("class", "checkmark_error");
         checkmark_stem_FacePosition.setAttribute("class", "checkmark_stem_error");
         checkmark_kick_FacePosition.setAttribute("class", "checkmark_kick_error");
@@ -15040,64 +15103,186 @@ var ProctoringUploader = class {
 var AlertRecorder = class {
   constructor(options, optionsProctoring) {
     this.alerts = [];
+    // Variáveis para controle de inatividade
+    this.lastActivityTime = Date.now();
+    this.IDLE_THRESHOLD_MS = 3e4;
+    // ==========================================
+    // HANDLERS (Funções Arrow para preservar o 'this')
+    // ==========================================
+    // 1. LOST / RETURN FOCUS
+    this.handleLostFocus = () => {
+      if (this.getRelativeTime() > 1e4) {
+        const alertPayload = {
+          begin: this.getRelativeTime(),
+          end: 0,
+          alert: 25 /* FocusOff */,
+          type: 3 /* Screen */
+        };
+        this.onLostFocusCallback(alertPayload);
+        this.alerts.push(alertPayload);
+      }
+    };
+    this.handleReturnFocus = () => {
+      const lastAlert = this.alerts[this.alerts.length - 1];
+      if (lastAlert) {
+        this.onFocusCallback({
+          begin: lastAlert.begin,
+          end: this.getRelativeTime(),
+          alert: 25 /* FocusOff */,
+          type: 3 /* Screen */
+        });
+        lastAlert.end = this.getRelativeTime();
+      }
+    };
+    // 2. SPLIT SCREEN DETECTION
+    this.handleResize = () => {
+      clearTimeout(this.resizeTimeout);
+      this.resizeTimeout = setTimeout(() => {
+        const screenWidth = window.screen.availWidth;
+        const windowWidth = window.outerWidth;
+        if (windowWidth < screenWidth * 0.85) {
+          const msg = `Split Screen Detectado: Janela ocupa ${(windowWidth / screenWidth * 100).toFixed(0)}% da tela`;
+          this.createAlert(200 /* System */, 3 /* Screen */, msg);
+          this.onRealtimeAlertCallback && this.onRealtimeAlertCallback({
+            status: "ALERT",
+            description: msg,
+            type: "split_screen"
+          });
+        }
+      }, 1e3);
+    };
+    // 3. DETECÇÃO DE INATIVIDADE (NO INPUT)
+    this.handleUserActivity = (e3) => {
+      this.lastActivityTime = Date.now();
+      console.log("\u{1F449} handleUserActivity", e3);
+    };
+    // 5. CLIPBOARD HANDLERS 
+    this.handleCopy = (e3) => {
+      e3.preventDefault();
+      const msg = "Tentativa de Copiar (Clipboard)";
+      this.createAlert(100 /* ForbiddenAction */, 6 /* System */, msg);
+      this.onRealtimeAlertCallback && this.onRealtimeAlertCallback({
+        status: "ALERT",
+        description: msg,
+        type: "clipboard_copy"
+      });
+    };
+    this.handleCut = (e3) => {
+      e3.preventDefault();
+      const msg = "Tentativa de Recortar (Clipboard)";
+      this.createAlert(100 /* ForbiddenAction */, 6 /* System */, msg);
+      this.onRealtimeAlertCallback && this.onRealtimeAlertCallback({
+        status: "ALERT",
+        description: msg,
+        type: "clipboard_cut"
+      });
+    };
+    this.handlePaste = (e3) => {
+      e3.preventDefault();
+      const msg = "Tentativa de Colar (Clipboard)";
+      this.createAlert(100 /* ForbiddenAction */, 6 /* System */, msg);
+      this.onRealtimeAlertCallback && this.onRealtimeAlertCallback({
+        status: "ALERT",
+        description: msg,
+        type: "clipboard_paste"
+      });
+    };
     this.onLostFocusCallback = options.onLostFocusCallback;
     this.onFocusCallback = options.onFocusCallback;
+    this.onRealtimeAlertCallback = options.onRealtimeAlertCallback;
     this.optionsProctoring = optionsProctoring;
   }
   async startRecording() {
     this.startTime = new Date(Date.now());
-    if (this.optionsProctoring.captureScreen) {
-      window.addEventListener("blur", () => this.onLostFocus());
-      window.addEventListener("focus", () => this.onReturnFocus());
-    }
+    this.alerts = [];
+    this.attachListeners();
   }
   async pauseRecording() {
-    window.removeEventListener("blur", () => this.onLostFocus());
-    window.removeEventListener("focus", () => this.onReturnFocus());
+    this.detachListeners();
   }
   async resumeRecording() {
-    if (this.optionsProctoring.captureScreen) {
-      window.addEventListener("blur", () => this.onLostFocus());
-      window.addEventListener("focus", () => this.onReturnFocus());
-    }
+    this.attachListeners();
   }
   async stopRecording() {
-    window.removeEventListener("blur", () => this.onLostFocus());
-    window.removeEventListener("focus", () => this.onReturnFocus());
+    this.detachListeners();
   }
   async saveOnSession(session) {
     this.alerts.forEach((alert) => {
       session.addAlert(alert);
     });
   }
-  onLostFocus() {
-    var _a2;
-    if (Date.now() - ((_a2 = this.startTime) == null ? void 0 : _a2.getTime()) > 1e4) {
-      this.onLostFocusCallback({
-        begin: Date.now() - this.startTime.getTime(),
-        end: 0,
-        alert: 25 /* FocusOff */,
-        type: 3 /* Screen */
-      });
-      this.alerts.push({
-        begin: Date.now() - this.startTime.getTime(),
-        end: 0,
-        alert: 25 /* FocusOff */,
-        type: 3 /* Screen */
-      });
-    }
+  // ==========================================
+  // GERENCIAMENTO DE LISTENERS
+  // ==========================================
+  attachListeners() {
+    if (this.optionsProctoring.captureScreen) {
+      window.addEventListener("blur", this.handleLostFocus);
+      window.addEventListener("focus", this.handleReturnFocus);
+      window.addEventListener("resize", this.handleResize);
+      window.document.addEventListener("copy", this.handleCopy);
+      window.document.addEventListener("cut", this.handleCut);
+      window.document.addEventListener("paste", this.handlePaste);
+    }
+  }
+  detachListeners() {
+    window.removeEventListener("blur", this.handleLostFocus);
+    window.removeEventListener("focus", this.handleReturnFocus);
+    window.removeEventListener("resize", this.handleResize);
+    window.document.removeEventListener("copy", this.handleCopy);
+    window.document.removeEventListener("cut", this.handleCut);
+    window.document.removeEventListener("paste", this.handlePaste);
+  }
+  // private startIdleChecker() {
+  //   this.stopIdleChecker(); // Garante que não tenha duplicação
+  //   this.idleCheckInterval = setInterval(() => {
+  //       const idleTime = Date.now() - this.lastActivityTime;
+  //       if (idleTime > this.IDLE_THRESHOLD_MS) {
+  //           // Verifica se já não mandamos esse alerta recentemente para não floodar
+  //           const lastAlert = this.alerts[this.alerts.length - 1];
+  //           // Se o último alerta não foi de inatividade ou foi há muito tempo, cria novo
+  //           if (!lastAlert || lastAlert.alert !== AlertCategory.ForbiddenAction || (this.getRelativeTime() - lastAlert.begin > 5000)) {
+  //               const msg = "Usuário inativo por muito tempo";
+  //               // Assumindo ForbiddenAction ou outra categoria adequada
+  //               this.createAlert(AlertCategory.ForbiddenAction, AlertType.System, msg);
+  //               this.onRealtimeAlertCallback && this.onRealtimeAlertCallback({
+  //                   status: 'ALERT',
+  //                   description: msg,
+  //                   type: 'user_idle'
+  //               });
+  //           }
+  //       }
+  //   }, 5000); // Checa a cada 5 segundos
+  // }
+  // private stopIdleChecker() {
+  //   if (this.idleCheckInterval) {
+  //       clearInterval(this.idleCheckInterval);
+  //       this.idleCheckInterval = null;
+  //   }
+  // }
+  // 4. BACKGROUND EVENTS (Eventos disparados manualmente)
+  addBackgroundEvent(description, category = 200 /* System */) {
+    this.createAlert(category, 6 /* System */, description);
+    this.onRealtimeAlertCallback && this.onRealtimeAlertCallback({
+      status: "ALERT",
+      description,
+      type: "background_event"
+    });
   }
-  onReturnFocus() {
-    const lastAlert = this.alerts[this.alerts.length - 1];
-    if (lastAlert) {
-      this.onFocusCallback({
-        begin: lastAlert.begin,
-        end: Date.now() - this.startTime.getTime(),
-        alert: 25 /* FocusOff */,
-        type: 3 /* Screen */
-      });
-      lastAlert.end = Date.now() - this.startTime.getTime();
-    }
+  // ==========================================
+  // HELPERS
+  // ==========================================
+  getRelativeTime() {
+    return Date.now() - this.startTime.getTime();
+  }
+  createAlert(category, type, description) {
+    this.alerts.push({
+      begin: this.getRelativeTime(),
+      end: this.getRelativeTime(),
+      // Eventos pontuais começam e terminam no mesmo ms (exceto focus)
+      alert: category,
+      type
+      // description: description // Se sua interface Alert suportar descrição, descomente
+    });
   }
   addAlert({ alert, type }) {
     this.alerts.push({
@@ -21520,7 +21705,6 @@ var Proctoring = class {
         noiseLimit: 40
       },
       imageBehaviourParameters: {
-        frames: 40,
         useUploadImage: true,
         uploadInterval: 20,
         saveVideo: true
@@ -21738,7 +21922,8 @@ var Proctoring = class {
     const alertRecorder = new AlertRecorder(
       {
         onFocusCallback: (response) => this.onFocusAlertRecorderCallback(response),
-        onLostFocusCallback: (response) => this.onLostFocusAlertRecorderCallback(response)
+        onLostFocusCallback: (response) => this.onLostFocusAlertRecorderCallback(response),
+        onRealtimeAlertCallback: (response) => this.onRealtimeAlertsCallback(response)
       },
       options
     );
@@ -21846,11 +22031,23 @@ Navigator: ${JSON.stringify(_navigator2)}`
         startResponse.screenStream = this.allRecorders.screenRecorder.screenStream;
       }
       this.state = "Recording" /* Recording */;
-      setTimeout(async () => {
+      let verifyFirstFaceIntervalCount = 0;
+      let verifyingFace = false;
+      this.verifyFirstFaceInterval = setInterval(async () => {
         if (this.sessionOptions.proctoringType === "REALTIME") {
-          await this.backend.verifyFace(this.proctoringId, await this.allRecorders.cameraRecorder.getCurrentImageBase64());
+          if (verifyingFace) return;
+          verifyingFace = true;
+          verifyFirstFaceIntervalCount++;
+          try {
+            var response = await this.backend.verifyFace(this.proctoringId, await this.allRecorders.cameraRecorder.getCurrentImageBase64(), verifyFirstFaceIntervalCount > 5 ? false : true);
+            verifyingFace = false;
+            clearInterval(this.verifyFirstFaceInterval);
+          } catch (error) {
+            verifyingFace = false;
+            return;
+          }
         }
-      }, 1e3);
+      }, 1500);
       return startResponse;
     } catch (error) {
       console.log(error);
@@ -21987,6 +22184,9 @@ Upload Services: ${uploaderServices}`,
           await this.backend.externalCameraFinish(externalSessionId);
         }
       }
+      if (this.verifyFirstFaceInterval) {
+        clearInterval(this.verifyFirstFaceInterval);
+      }
       this.state = "Stop" /* Stop */;
     } catch (error) {
       await this.cancel();
@@ -22321,12 +22521,12 @@ function useProctoring(proctoringOptions, enviromentConfig = "prod") {
   const photo = new CapturePhoto();
   const login = proctoring.login.bind(proctoring);
   const originalStart = proctoring.start.bind(proctoring);
-  const start = async (parameters2) => {
+  const start = async (parameters2, videoOptions) => {
     const deviceResult = checker.getDeviceCheckResult();
     if (deviceResult) {
       proctoring.setDeviceCheckData(deviceResult);
     }
-    return originalStart(parameters2);
+    return originalStart(parameters2, videoOptions);
   };
   const finish = proctoring.finish.bind(proctoring);
   const pause = proctoring.pause.bind(proctoring);