easyproctor 2.5.2 → 2.5.4

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
@@ -12757,7 +12802,7 @@ var CameraRecorder = class {
     }
   }
   async startRecording(options) {
-    var _a2, _b, _c2, _d, _e3, _f, _g, _h, _i3;
+    var _a2, _b, _c2, _d, _e3, _f, _g, _h;
     if ((((_a2 = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _a2.detectPerson) || ((_b = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _b.detectCellPhone) || ((_c2 = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _c2.detectFace)) && !(options == null ? void 0 : options.retry)) {
       await this.initializeDetectors();
     }
@@ -12837,7 +12882,6 @@ Setting: ${JSON.stringify(settings, null, 2)}`
     this.filesToUpload = [];
     if (this.options.proctoringType == "REALTIME") {
       this.captureFrame();
-      this.sendFrameInterval = setInterval(() => this.captureFrame(), 1e3 * ((_i3 = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _i3.realtimeUploadInterval));
     }
     this.packageCount = 0;
   }
@@ -12868,7 +12912,8 @@ Setting: ${JSON.stringify(settings, null, 2)}`
     clearInterval(this.imageInterval);
     clearInterval(this.sendFrameInterval);
     if (this.options.proctoringType == "REALTIME" && this.upload && this.backendToken) {
-      await this.sendPackage();
+      await this.sendPackage(this.filesToUpload);
+      await this.filesToUpload.splice(0, this.filesToUpload.length);
     }
     this.volumeMeter && this.volumeMeter.stop();
     this.intervalNoiseDetection && clearInterval(this.intervalNoiseDetection);
@@ -12938,23 +12983,29 @@ Setting: ${JSON.stringify(settings, null, 2)}`
     this.canvas.getContext("2d").drawImage(this.video, 0, 0, this.canvas.width, this.canvas.height);
     return this.canvas.toDataURL("image/jpeg");
   }
-  // De um em um segundo captura um frame (é ligado de 30 em 30 segundos)
+  // captura um frame a cada intervalo de tempo definido no paramsConfig.videoBehaviourParameters?.realtimeCaptureInterval!
   captureFrame() {
-    var _a2;
+    var _a2, _b;
     let imageFile;
     this.configImageCapture();
+    let newCanvasWidth = this.videoOptions.width / 2;
+    let newCanvasHeight = this.videoOptions.height / 2;
+    if (newCanvasWidth < 320) newCanvasWidth = 320;
+    if (newCanvasHeight < 180) newCanvasHeight = 180;
+    this.canvas.width = newCanvasWidth;
+    this.canvas.height = newCanvasHeight;
     const packSize = (_a2 = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _a2.realtimePackageSize;
-    let initSend = false;
-    this.imageCount++;
+    this.imageCount = 0;
     this.imageInterval = setInterval(async () => {
+      console.log("capturando frame " + this.imageCount);
       this.canvas.getContext("2d").drawImage(this.video, 0, 0, this.canvas.width, this.canvas.height);
       const image_data_url = this.canvas.toDataURL("image/jpeg");
       if (this.proctoringId == void 0) return;
-      if (initSend == false && packSize == this.imageCount) {
-        initSend = true;
+      if (packSize == this.imageCount) {
         this.imageCount = 0;
-        clearInterval(this.imageInterval);
-        this.sendPackage();
+        const framesToSend = [...this.filesToUpload];
+        this.sendPackage(framesToSend);
+        await this.filesToUpload.splice(0, this.filesToUpload.length);
       }
       let imageName = `${this.proctoringId}_${this.imageCount + 1}.jpg`;
       imageFile = await this.getFile(image_data_url, imageName, "image/jpeg");
@@ -12962,22 +13013,24 @@ Setting: ${JSON.stringify(settings, null, 2)}`
         this.filesToUpload.push(imageFile);
         this.imageCount++;
       }
-    }, 1e3);
+    }, ((_b = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _b.realtimeCaptureInterval) * 1e3);
   }
   // envia pacote de imagens
-  async sendPackage() {
+  async sendPackage(framesToSend) {
+    var _a2, _b;
     let pending = false;
     let undeliveredPackagesCount = 0;
+    const packSize = (_a2 = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _a2.realtimePackageSize;
+    const packCaptureInterval = ((_b = this.paramsConfig.videoBehaviourParameters) == null ? void 0 : _b.realtimeCaptureInterval) + 1;
     if (this.upload && this.backendToken && !pending && this.filesToUpload.length > 0) {
       undeliveredPackagesCount = 0;
       pending = true;
       const zip = new import_jszip_min.default();
-      const files = this.filesToUpload;
-      for (const file of files) {
+      for (const file of framesToSend) {
         zip.file(file.name, file);
       }
       const blob = await zip.generateAsync({ type: "blob" });
-      let packageName = "realtime_package_" + 30 * this.packageCount + ".zip";
+      let packageName = "realtime_package_" + packSize * packCaptureInterval * this.packageCount + ".zip";
       const myPackage = new File(
         [blob],
         packageName,
@@ -12990,7 +13043,6 @@ Setting: ${JSON.stringify(settings, null, 2)}`
         this.backendToken
       );
       if (uploadResult.uploaded == true) {
-        await this.filesToUpload.splice(0, this.filesToUpload.length);
         this.packageCount++;
       } else {
         console.log("erro no upload do pacote");
@@ -13574,8 +13626,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 +13970,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 +13982,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 +13998,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 +15110,191 @@ 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.handleVisibilityChange = () => {
+      if (document.visibilityState === "visible") {
+        this.handleReturnFocus();
+      } else {
+        this.handleLostFocus();
+      }
+    };
+    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(43 /* SplitScreen */, 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(42 /* ClipBoardUse */, 3 /* Screen */, 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(42 /* ClipBoardUse */, 3 /* Screen */, 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(42 /* ClipBoardUse */, 3 /* Screen */, 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("visibilitychange", this.handleVisibilityChange);
+      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("visibilitychange", this.handleVisibilityChange);
+    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, 3 /* Screen */, 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({
@@ -21314,7 +21511,8 @@ var _ExternalCameraChecker = class _ExternalCameraChecker {
     this.connection = new HubConnectionBuilder().withUrl(hubUrl, {
       accessTokenFactory: () => this.context.token,
       transport: HttpTransportType.WebSockets,
-      withCredentials: false
+      withCredentials: false,
+      skipNegotiation: true
     }).withAutomaticReconnect().configureLogging(LogLevel.Information).build();
     this.connection.on(
       "ReceiveMessage",
@@ -21520,7 +21718,6 @@ var Proctoring = class {
         noiseLimit: 40
       },
       imageBehaviourParameters: {
-        frames: 40,
         useUploadImage: true,
         uploadInterval: 20,
         saveVideo: true
@@ -21531,8 +21728,8 @@ var Proctoring = class {
         detectCellPhone: false,
         detectNoise: false,
         detectSpeech: false,
-        realtimePackageSize: 20,
-        realtimeUploadInterval: 30
+        realtimePackageSize: 10,
+        realtimeCaptureInterval: 2
       }
     };
     this.proctoringId = "";
@@ -21668,6 +21865,29 @@ var Proctoring = class {
         return null;
     }
   }
+  // metodo para fechar o alerta realtime e fica tentando verificar a face até 5 vezes
+  async stopRealtimeAlert(alert) {
+    const verifyMaxRetries = 3;
+    const verifyFace = async (verifyCount) => {
+      if (verifyCount > verifyMaxRetries) return;
+      try {
+        var response = await this.backend.stopRealtimeAlert({
+          proctoringId: this.proctoringId,
+          begin: alert.begin,
+          end: alert.end,
+          warningCategoryEnum: this.convertRealtimeTypeToWarningType(alert.type),
+          alertImageBase64: await this.allRecorders.cameraRecorder.getCurrentImageBase64(),
+          retry: verifyCount < verifyMaxRetries - 1 ? true : false
+        });
+        console.log("response stopRealtimeAlert", response);
+        return response;
+      } catch (error) {
+        console.log("error stopRealtimeAlert", error);
+        return verifyFace(verifyCount + 1);
+      }
+    };
+    await verifyFace(1);
+  }
   async onRealtimeAlerts(options = {}) {
     this.setOnLostFocusAlertRecorderCallback();
     this.setOnFocusAlertRecorderCallback();
@@ -21682,13 +21902,7 @@ var Proctoring = class {
             alert: this.convertRealtimeCategoryToAlertCategory(response.category)
           });
         } else if (response.status === "OK") {
-          await this.backend.stopRealtimeAlert({
-            proctoringId: this.proctoringId,
-            begin: response.begin,
-            end: response.end,
-            warningCategoryEnum: this.convertRealtimeTypeToWarningType(response.type),
-            alertImageBase64: await this.allRecorders.cameraRecorder.getCurrentImageBase64()
-          });
+          await this.stopRealtimeAlert(response);
         }
       }
     };
@@ -21738,7 +21952,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 +22061,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 +22214,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 +22551,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);