easyproctor 0.0.19 → 0.0.20

package/README.md

@@ -35,14 +35,7 @@ Em um bundler
 ```javascript
 import { useProctoring } from "easyproctor";
 
-const {
-  start,
-  finish,
-  onFocus,
-  onLostFocus,
-  enumarateDevices,
-  checkPermissions,
-} = useProctoring({
+const { start, finish, pause, resume, onFocus, onLostFocus, enumarateDevices, checkPermissions, checkIfhasMultipleMonitors, onStopSharingScreen } = useProctoring({
   examId: "00001",
   clientId: "000001",
   token: "...",
@@ -54,14 +47,7 @@ Via CDN: A função "useProctoring" é injetada para ser utilizada globalmente
 ```html
 <script src="https://cdn.jsdelivr.net/npm/easyproctor/unpkg/easyproctor.min.js"></script>
 <script>
-  const {
-    start,
-    finish,
-    onFocus,
-    onLostFocus,
-    enumarateDevices,
-    checkPermissions,
-  } = useProctoring({
+  const { start, finish, pause, resume, onFocus, onLostFocus, enumarateDevices, checkPermissions, checkIfhasMultipleMonitors, onStopSharingScreen } = useProctoring({
     examId: "00001",
     clientId: "000001",
     token: "...",
@@ -198,6 +184,12 @@ const {
   // Inicia a gravação da prova
   start,
 
+  // Pausa a gravação
+  pause,
+
+  // Reinicia a gravação
+  resume,
+
   // Finaliza a gravação da prova retornando os arquivos gerados
   finish,
 
@@ -207,11 +199,19 @@ const {
   // Adiciona uma função callback para ser executada quando o usuário perde o foco da tela
   onLostFocus,
 
+  // Adiciona uma função callback para ser executada quando o usuário cancela o compartilhamento de tela
+  onStopSharingScreen
+
   // Enumera os dispositivos de camera e microfone
   enumarateDevices,
 
   // Checa as permissões de camera e microfone
   checkPermissions,
+
+  // Checa se existe mais de um monitor
+  checkIfhasMultipleMonitors
+
+  
 } = useProctoring({
   examId: "00001",
   clientId: "000001",

package/errors/errors.d.ts

@@ -0,0 +1,10 @@
+export declare const SCRIPT_NOT_CALLED_INSIDE_BODY = "script_not_called_inside_body";
+export declare const INCOMPATIBLE_NAVIGATOR = "incompatible_navigator";
+export declare const REQUIRED_FIELD_NOT_PROVIDED = "required_field_not_provided";
+export declare const NOT_SHARED_FIRST_SCREEN = "not_shared_first_screen";
+export declare const MULTIPLE_MONITORS_DETECTED = "multiple_monitors_detected";
+export declare const PROCTORING_ALREADY_STARTED = "proctoring_already_started";
+export declare const PROCTORING_NOT_STARTED = "proctoring_not_started";
+export declare const PROCTORING_RUNNING = "proctoring_running";
+export declare const NO_VIDEOS_RECORDED = "no_videos_recorded";
+export declare const PERMISSIONS_NOT_GRANTED = "permissions_not_granted";

package/esm/index.js

@@ -16,11 +16,15 @@ function recorder(stream, buffer) {
   mediaRecorder.start();
   function stopRecording() {
     return new Promise((resolve) => {
-      resolvePromise = resolve;
-      mediaRecorder.stop();
-      stream.getTracks().forEach((el) => {
-        el.stop();
-      });
+      if (mediaRecorder.state == "recording") {
+        resolvePromise = resolve;
+        mediaRecorder.stop();
+        stream.getTracks().forEach((el) => {
+          el.stop();
+        });
+      } else {
+        resolve();
+      }
     });
   }
   return stopRecording;
@@ -43,8 +47,20 @@ async function startCameraCapture(buffer, options = { cameraId: void 0, micropho
   return { cameraStream, stopCameraRecording };
 }
 
+// src/errors/errors.ts
+var SCRIPT_NOT_CALLED_INSIDE_BODY = "script_not_called_inside_body";
+var INCOMPATIBLE_NAVIGATOR = "incompatible_navigator";
+var REQUIRED_FIELD_NOT_PROVIDED = "required_field_not_provided";
+var NOT_SHARED_FIRST_SCREEN = "not_shared_first_screen";
+var MULTIPLE_MONITORS_DETECTED = "multiple_monitors_detected";
+var PROCTORING_ALREADY_STARTED = "proctoring_already_started";
+var PROCTORING_NOT_STARTED = "proctoring_not_started";
+var PROCTORING_RUNNING = "proctoring_running";
+var NO_VIDEOS_RECORDED = "no_videos_recorded";
+
 // src/modules/startScreenCapture.ts
-async function startScreenCapture(buffer) {
+async function startScreenCapture(buffer, options) {
+  const { allowOnlyFirstMonitor, onStopSharingScreenCallback } = options;
   const displayMediaStreamConstraints = {
     video: {
       cursor: "always"
@@ -52,6 +68,15 @@ async function startScreenCapture(buffer) {
     audio: false
   };
   const screenStream = await navigator.mediaDevices.getDisplayMedia(displayMediaStreamConstraints);
+  const tracks = screenStream.getVideoTracks();
+  tracks[0].onended = onStopSharingScreenCallback;
+  const sharedFirstScreen = tracks.find((el) => el.getSettings().deviceId == "screen:0:0") != null;
+  if (!sharedFirstScreen && allowOnlyFirstMonitor) {
+    tracks.forEach((el) => {
+      el.stop();
+    });
+    throw NOT_SHARED_FIRST_SCREEN;
+  }
   const stopScreenRecorder = recorder(screenStream, buffer);
   return { screenStream, stopScreenRecorder };
 }
@@ -125,21 +150,87 @@ async function checkPermissions() {
     return false;
   }
 }
+async function checkIfhasMultipleMonitors() {
+  return new Promise((resolve, reject) => {
+    const presentationRequest = new PresentationRequest("receiver.html");
+    presentationRequest.getAvailability().then((availability) => {
+      let hasMultipleMonitors = availability.value;
+      availability.addEventListener("change", function() {
+        hasMultipleMonitors = availability.value;
+      });
+      setTimeout(() => {
+        resolve(hasMultipleMonitors);
+      }, 1e3);
+    }).catch((error) => reject(error));
+  });
+}
+
+// src/modules/database.ts
+var databaseName = "EasyProctorPlugin";
+var databaseVersion = 2;
+function initializeDatabase(table) {
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(databaseName, databaseVersion);
+    request.onupgradeneeded = () => {
+      request.result.createObjectStore("exams", { keyPath: "id" });
+    };
+    request.onerror = (e) => {
+      console.log(e);
+      reject("N\xE3o foi poss\xEDvel inicializar a biblioteca, por favor, entre em contato com o suporte e informe o erro acima");
+    };
+    request.onsuccess = () => {
+      const db = request.result;
+      const tableRef = db.transaction(table, "readwrite");
+      const store = tableRef.objectStore(table);
+      resolve(store);
+    };
+  });
+}
+async function insertRecord(table, data) {
+  const store = await initializeDatabase(table);
+  return new Promise((resolve, reject) => {
+    const request = store.put(data);
+    request.onsuccess = () => resolve();
+    request.onerror = (e) => reject(e);
+  });
+}
+async function getRecord(table) {
+  const store = await initializeDatabase(table);
+  return new Promise((resolve, reject) => {
+    const request = store.getAll();
+    request.onsuccess = () => {
+      const data = request.result[0];
+      resolve(data);
+    };
+    request.onerror = (e) => reject(e);
+  });
+}
+async function clearBuffers(table) {
+  const store = await initializeDatabase(table);
+  return new Promise((resolve, reject) => {
+    const request = store.clear();
+    request.onsuccess = () => resolve();
+    request.onerror = (e) => reject(e);
+  });
+}
 
 // src/index.ts
+var defaultProctoringOptions = {
+  cameraId: void 0,
+  microphoneId: void 0,
+  allowMulipleMonitors: false,
+  allowOnlyFirstMonitor: true
+};
 var azureBlobUrl = "https://iarisprod.blob.core.windows.net/iaris";
 function useProctoring(proctoringOptions) {
   ["examId", "clientId", "token"].forEach((el) => {
     const key = el;
     if (!proctoringOptions[key]) {
-      throw `O campo ${key} \xE9 obrigat\xF3rio`;
+      throw REQUIRED_FIELD_NOT_PROVIDED + ": " + key;
     }
   });
-  if (!navigator.mediaDevices.getDisplayMedia) {
-    throw "Voc\xEA est\xE1 utilizando uma vers\xE3o muito antiga do navegador, por favor, atualize a vers\xE3o";
-  }
-  if (!window.indexedDB) {
-    throw "Voc\xEA est\xE1 usando uma vers\xE3o muito antiga do navegador, n\xE3o \xE9 poss\xEDvel relizar a requisi\xE7\xE3o";
+  if (!navigator.mediaDevices.getDisplayMedia || !window.indexedDB || typeof PresentationRequest === "undefined") {
+    throw INCOMPATIBLE_NAVIGATOR;
   }
   function download(file) {
     const url = URL.createObjectURL(file);
@@ -158,25 +249,36 @@ function useProctoring(proctoringOptions) {
   let alerts = [];
   let onLostFocusCallback;
   let onFocusCallback;
+  let onStopSharingScreenCallback = void 0;
   let cancelCallback = null;
+  function _clear() {
+    cameraBuffer = [];
+    screenBuffer = [];
+    proctoringId = "";
+    startTime = 0;
+    alerts = [];
+  }
   async function _startCapture(options) {
-    console.log(cancelCallback);
     if (!document.body) {
-      throw "A execu\xE7\xE3o do script deve ser feita por algum elemento dentro do <body> da p\xE1gina html";
+      throw SCRIPT_NOT_CALLED_INSIDE_BODY;
     }
     if (cancelCallback != null) {
-      throw "Uma grava\xE7\xE3o ja est\xE1 em andamento";
+      throw PROCTORING_ALREADY_STARTED;
     }
     let cancelCameraCapture = null;
     let cancelScreenCapture = null;
+    const { cameraId, microphoneId, allowOnlyFirstMonitor } = options;
     try {
-      const { screenStream, stopScreenRecorder } = await startScreenCapture(screenBuffer);
-      const { cameraId, microphoneId } = options;
+      const { screenStream, stopScreenRecorder } = await startScreenCapture(screenBuffer, {
+        allowOnlyFirstMonitor,
+        onStopSharingScreenCallback: () => onStopSharingScreenCallback && onStopSharingScreenCallback()
+      });
       const { cameraStream, stopCameraRecording } = await startCameraCapture(cameraBuffer, { cameraId, microphoneId });
       cancelScreenCapture = stopScreenRecorder;
       cancelCameraCapture = stopCameraRecording;
       cancelCallback = async function() {
         await Promise.all([cancelCameraCapture(), cancelScreenCapture()]);
+        cancelCallback = null;
       };
       return { screenStream, cameraStream };
     } catch (error) {
@@ -185,7 +287,7 @@ function useProctoring(proctoringOptions) {
       cancelCameraCapture && await cancelCameraCapture();
       cameraBuffer = [];
       screenBuffer = [];
-      throw "N\xE3o foi poss\xEDvel iniciar a captura, por favor, verifique as permiss\xF5es de camera e microfone";
+      throw error;
     }
   }
   const _onLostFocus = () => {
@@ -211,11 +313,33 @@ function useProctoring(proctoringOptions) {
     window.removeEventListener("blur", _onLostFocus);
     window.removeEventListener("focus", _onReturnFocus);
   };
-  async function start(options = { microphoneId: void 0, cameraId: void 0 }) {
-    const { cameraId, microphoneId } = options;
-    const { cameraStream, screenStream } = await _startCapture({ cameraId, microphoneId });
-    startTime = Date.now();
+  const _generateFiles = (index) => {
+    const finalCameraBuffer = cameraBuffer;
+    const finalScreenBuffer = screenBuffer;
+    if (finalCameraBuffer.length == 0 || finalScreenBuffer.length == 0) {
+      throw PROCTORING_NOT_STARTED;
+    }
+    const cameraFileName = `EP_${proctoringId}_camera_${index}.webm`;
+    const screenFIleName = `EP_${proctoringId}_screen_${index}.webm`;
+    const cameraFile = new File(finalCameraBuffer, cameraFileName, { type: "video/webm" });
+    const screenFile = new File(finalScreenBuffer, screenFIleName, { type: "video/webm" });
+    return { cameraFile, screenFile };
+  };
+  async function start(options = defaultProctoringOptions) {
+    const { cameraId, microphoneId, allowOnlyFirstMonitor = true, allowMulipleMonitors = false } = options;
+    if (!allowMulipleMonitors) {
+      const hasMultipleMonitors = await checkIfhasMultipleMonitors();
+      if (hasMultipleMonitors) {
+        throw MULTIPLE_MONITORS_DETECTED;
+      }
+    }
+    const hasExam = await getRecord("exams");
+    if (hasExam != null) {
+      throw PROCTORING_ALREADY_STARTED;
+    }
     try {
+      const { cameraStream, screenStream } = await _startCapture({ cameraId, microphoneId, allowOnlyFirstMonitor });
+      startTime = Date.now();
       const resp = await makeRequest({
         url: `/proctoring/start/${proctoringOptions.examId}`,
         method: "POST",
@@ -224,6 +348,12 @@ function useProctoring(proctoringOptions) {
       });
       resp.cameraStream = cameraStream;
       resp.screenStream = screenStream;
+      await insertRecord("exams", {
+        id: resp.id,
+        cameraBuffers: [],
+        screenBuffers: [],
+        alerts: []
+      });
       proctoringId = resp.id;
       _addListeners();
       return resp;
@@ -232,36 +362,74 @@ function useProctoring(proctoringOptions) {
       throw error;
     }
   }
+  async function pause() {
+    const record = await getRecord("exams");
+    if (!cancelCallback || !record) {
+      throw PROCTORING_NOT_STARTED;
+    }
+    onStopSharingScreenCallback = void 0;
+    await cancelCallback();
+    const { cameraFile, screenFile } = _generateFiles(record.cameraBuffers.length);
+    record.cameraBuffers.push(cameraFile);
+    record.screenBuffers.push(screenFile);
+    record.alerts.push(...alerts);
+    await insertRecord("exams", record);
+    _clear();
+  }
+  async function resume(options = defaultProctoringOptions) {
+    _clear();
+    const { cameraId, microphoneId, allowOnlyFirstMonitor = true, allowMulipleMonitors = false } = options;
+    if (!allowMulipleMonitors) {
+      const hasMultipleMonitors = await checkIfhasMultipleMonitors();
+      if (hasMultipleMonitors) {
+        throw MULTIPLE_MONITORS_DETECTED;
+      }
+    }
+    if (cancelCallback) {
+      throw PROCTORING_RUNNING;
+    }
+    const record = await getRecord("exams");
+    if (!record) {
+      throw PROCTORING_NOT_STARTED;
+    }
+    const { cameraStream, screenStream } = await _startCapture({ cameraId, microphoneId, allowOnlyFirstMonitor });
+    proctoringId = record.id;
+    startTime = Date.now();
+    return { cameraStream, screenStream };
+  }
   async function finish(options = {}) {
     const { onProgress } = options;
+    const record = await getRecord("exams");
+    if (!record) {
+      throw PROCTORING_NOT_STARTED;
+    }
+    onStopSharingScreenCallback = void 0;
     if (cancelCallback) {
       await cancelCallback();
+      const { cameraFile, screenFile } = _generateFiles(record.cameraBuffers.length);
+      record.cameraBuffers.push(cameraFile);
+      record.screenBuffers.push(screenFile);
     }
-    const time = new Date().toISOString();
-    const finalCameraBuffer = cameraBuffer;
-    const finalScreenBuffer = screenBuffer;
-    if (finalCameraBuffer.length == 0 || finalScreenBuffer.length == 0) {
-      throw "N\xE3o existe nenhuma grava\xE7\xE3o iniciada";
+    if (record.cameraBuffers.length == 0 || record.screenBuffers.length == 0) {
+      throw NO_VIDEOS_RECORDED;
     }
-    const cameraFileName = `EP_${proctoringId}_camera_0.webm`;
-    const screenFIleName = `EP_${proctoringId}_screen_0.webm`;
-    const cameraFile = new File(finalCameraBuffer, cameraFileName, { type: "video/webm" });
-    const screenFile = new File(finalScreenBuffer, screenFIleName, { type: "video/webm" });
-    let cameraProgress = 0;
-    let screenProgress = 0;
+    const time = new Date().toISOString();
+    const totalFiles = record.cameraBuffers.length + record.screenBuffers.length;
+    const uploadProgress = Array(totalFiles).fill(0);
     const handleOnProgress = () => {
-      onProgress && onProgress((cameraProgress + screenProgress) / 2);
+      onProgress && onProgress(uploadProgress.reduce((acc, el) => acc += el, 0) / totalFiles);
     };
-    await Promise.all([
-      upload_default({ file: cameraFile, onProgress: (progress) => {
-        cameraProgress = progress;
-        handleOnProgress();
-      } }),
-      upload_default({ file: screenFile, onProgress: (progress) => {
-        screenProgress = progress;
-        handleOnProgress();
-      } })
-    ]);
+    const allFiles = [...record.cameraBuffers, ...record.screenBuffers];
+    const uploadPromises = allFiles.map((c, i) => {
+      return upload_default({
+        file: c,
+        onProgress: (progress) => {
+          uploadProgress[i] = progress;
+          handleOnProgress();
+        }
+      });
+    });
+    await Promise.all(uploadPromises);
     _removeListeners();
     await makeRequest({
       url: "/proctoring/save-screen",
@@ -269,19 +437,20 @@ function useProctoring(proctoringOptions) {
       jwt: proctoringOptions.token,
       body: {
         proctoringId,
-        alerts: [...alerts]
+        alerts: [...record.alerts, ...alerts]
       }
     });
     await makeRequest({
-      url: `/proctoring/finish/${proctoringOptions.examId}`,
+      url: `/proctoring/finish/${record.id}`,
       method: "POST",
       body: {
         endDate: time,
-        videoCameraUrl: `${azureBlobUrl}/${cameraFileName}`,
-        videoScreenUrl: `${azureBlobUrl}/${screenFIleName}`
+        videoCameraUrl: `${azureBlobUrl}/${proctoringId}/cameraFiles`,
+        videoScreenUrl: `${azureBlobUrl}/${proctoringId}/screenFiles`
       },
       jwt: proctoringOptions.token
     });
+    await clearBuffers("exams");
     cameraBuffer = [];
     screenBuffer = [];
     alerts = [];
@@ -290,10 +459,13 @@ function useProctoring(proctoringOptions) {
   function onFocus(cb) {
     onFocusCallback = cb;
   }
+  function onStopSharingScreen(cb) {
+    onStopSharingScreenCallback = cb;
+  }
   function onLostFocus(cb) {
     onLostFocusCallback = cb;
   }
-  return { start, finish, download, onFocus, onLostFocus, enumarateDevices, checkPermissions };
+  return { start, finish, pause, resume, onFocus, onLostFocus, enumarateDevices, checkPermissions, checkIfhasMultipleMonitors, onStopSharingScreen };
 }
 if (typeof window !== "undefined") {
   window.useProctoring = useProctoring;

package/index.d.ts

@@ -1,21 +1,31 @@
 import enumarateDevices from "./modules/enumarateDevices";
-import checkPermissions from "./modules/checkPermissions";
+import { checkPermissions, checkIfhasMultipleMonitors } from "./modules/checkPermissions";
 import StartProctoringResponse from "./dtos/StartProctoringResponse";
+interface ProctoringOptions {
+    cameraId?: string;
+    microphoneId?: string;
+    allowMulipleMonitors?: boolean;
+    allowOnlyFirstMonitor?: boolean;
+}
 export declare function useProctoring(proctoringOptions: {
     examId: string;
     clientId: string;
     token: string;
 }): {
-    start: (options?: {
-        cameraId?: string;
-        microphoneId?: string;
-    }) => Promise<StartProctoringResponse>;
+    start: (options?: ProctoringOptions) => Promise<StartProctoringResponse>;
     finish: (options?: {
         onProgress?: ((percentage: number) => void) | undefined;
     }) => Promise<void>;
-    download: (file: File) => void;
+    pause: () => Promise<void>;
+    resume: (options?: ProctoringOptions) => Promise<{
+        cameraStream: MediaStream;
+        screenStream: MediaStream;
+    }>;
     onFocus: (cb: () => void) => void;
     onLostFocus: (cb: () => void) => void;
     enumarateDevices: typeof enumarateDevices;
     checkPermissions: typeof checkPermissions;
+    checkIfhasMultipleMonitors: typeof checkIfhasMultipleMonitors;
+    onStopSharingScreen: (cb: () => void) => void;
 };
+export {};