easyproctor-hml 0.0.41 → 0.0.43

package/errors/errors.d.ts

@@ -9,3 +9,4 @@ 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";
+export declare const ANOTHER_STREAM_ACTIVE = "another_stream_active";

package/esm/index.js

@@ -22429,7 +22429,8 @@ var eventNames = {
   FINISH: "finish",
   ERROR: "error",
   UPLOAD_VIDEO: "upload_video",
-  BUFFER_SIZE: "buffer_size"
+  BUFFER_SIZE: "buffer_size",
+  ANOTHER_STREAM: "another_stream"
 };
 var trackError = (exception) => insights.trackException({ exception });
 var registerCustomEvent = (eventName, properties) => insights.trackEvent({ name: eventName, properties });
@@ -22445,7 +22446,8 @@ var trackers = {
   registerChangeDevice: (proctoringId, inOrOut, devicesChanged) => registerCustomEvent(eventNames.UPLOAD_VIDEO, { proctoringId, inOrOut, devicesChanged }),
   registerStopSharingScreen: (proctoringId, description) => registerCustomEvent(eventNames.UPLOAD_VIDEO, { proctoringId, description }),
   registerErrorRecorderRTC: (proctoringId, description) => registerCustomEvent(eventNames.UPLOAD_VIDEO, { proctoringId, description }),
-  registerOnBufferSizeError: (proctoringId, description) => registerCustomEvent(eventNames.BUFFER_SIZE, { proctoringId, description })
+  registerOnBufferSizeError: (proctoringId, description) => registerCustomEvent(eventNames.BUFFER_SIZE, { proctoringId, description }),
+  registerAnotherStream: (proctoringId, description) => registerCustomEvent(eventNames.ANOTHER_STREAM, { proctoringId, description })
 };
 
 // src/plugins/recorder.ts
@@ -24319,28 +24321,65 @@ var axios_default2 = axios_default;
 var AzureUploadService = class {
   constructor(proctoringId, backend) {
     this.backend = backend;
+    this.imageUrlPackage = [];
+    this.imageBatchNum = 0;
+    this.contImages = 0;
     this.proctoringId = proctoringId;
   }
-  async upload(data, token) {
+  async upload(data, token, image) {
     const { file, onProgress } = data;
-    console.log(file);
     try {
       const progressCallback = (e) => {
         const progress = e.loadedBytes / file.size * 100;
         onProgress && onProgress(Math.round(progress));
       };
-      const uploadUrl = await this.backend.getAzureSignedUrl(token, file, this.proctoringId);
-      const uploaded = await axios_default2.request({
-        url: uploadUrl,
-        method: "PUT",
-        headers: {
-          "x-ms-blob-type": "BlockBlob"
-        },
-        data: file,
-        onUploadProgress: (p) => {
-          progressCallback({ loadedBytes: p.loaded });
+      let uploadUrl;
+      if (image) {
+        if (this.imageBatchNum === this.contImages) {
+          const batchArray = [];
+          for (let i = this.imageBatchNum; i < this.imageBatchNum + 20; i++) {
+            batchArray.push({
+              objectName: `${this.proctoringId}/${this.proctoringId}_${i + 1}.jpg`,
+              contentType: "image/jpeg"
+            });
+          }
+          const batchUrls = await this.backend.getAzureSignedUrlImage(token, batchArray);
+          batchUrls.map((item) => {
+            this.imageUrlPackage.push(item);
+          });
+          this.imageBatchNum += 20;
         }
-      }).then(() => true).catch(() => false);
+      } else {
+        uploadUrl = await this.backend.getAzureSignedUrl(token, file, this.proctoringId);
+      }
+      let uploaded = false;
+      if (image) {
+        uploaded = await axios_default2.request({
+          url: this.imageUrlPackage[this.contImages],
+          method: "PUT",
+          headers: {
+            "x-ms-blob-type": "BlockBlob"
+          },
+          data: file,
+          onUploadProgress: (p) => {
+            progressCallback({ loadedBytes: p.loaded });
+          }
+        }).then(() => true).catch(() => false).finally(() => {
+          this.contImages++;
+        });
+      } else {
+        uploaded = await axios_default2.request({
+          url: uploadUrl,
+          method: "PUT",
+          headers: {
+            "x-ms-blob-type": "BlockBlob"
+          },
+          data: file,
+          onUploadProgress: (p) => {
+            progressCallback({ loadedBytes: p.loaded });
+          }
+        }).then(() => true).catch(() => false);
+      }
       return {
         storage: "AzureBlob" /* AzureBlob */,
         url: uploadUrl,
@@ -24356,10 +24395,23 @@ var AzureUploadService = class {
   }
 };
 
+// src/errors/errors.ts
+var NOT_SHARED_FIRST_SCREEN = "not_shared_first_screen";
+var NOT_SHARED_SCREEN = "not_shared_screen";
+var MULTIPLE_MONITORS_DETECTED = "multiple_monitors_detected";
+var PROCTORING_ALREADY_STARTED = "proctoring_already_started";
+var PROCTORING_NOT_STARTED = "proctoring_not_started";
+var ANOTHER_STREAM_ACTIVE = "another_stream_active";
+
 // src/new-flow/recorders/CameraRecorder.ts
 var CameraRecorder = class {
-  constructor(options, videoOptions, backend, backendToken) {
+  constructor(options, videoOptions, imageProctoring, backend, backendToken) {
     this.blobs = [];
+    this.imageProctoring = {
+      useUploadImage: false,
+      uploadInterval: 20,
+      saveVideo: true
+    };
     this.options = {
       cameraId: void 0,
       microphoneId: void 0,
@@ -24377,11 +24429,21 @@ var CameraRecorder = class {
     this.videoOptions = videoOptions;
     this.backend = backend;
     this.backendToken = backendToken;
+    imageProctoring && (this.imageProctoring = imageProctoring);
   }
   setProctoringId(proctoringId) {
     this.proctoringId = proctoringId;
     this.proctoringId && this.backend && (this.azureUpload = new AzureUploadService(this.proctoringId, this.backend));
   }
+  configImageCapture() {
+    this.video = document.createElement("video");
+    this.canvas = document.createElement("canvas");
+    this.video.srcObject = this.cameraStream;
+    this.video.play();
+    this.video.muted = true;
+    this.canvas.width = 1280;
+    this.canvas.height = 720;
+  }
   async startRecording() {
     const { cameraId, microphoneId, onBufferSizeErrorCallback } = this.options;
     const constraints = {
@@ -24406,6 +24468,14 @@ var CameraRecorder = class {
     this.recordingPause = pauseRecording;
     this.recordingResume = resumeRecording;
     this.recordingStart();
+    const settings = this.cameraStream.getVideoTracks()[0].getSettings();
+    if (this.videoOptions.width !== settings.width || this.videoOptions.height !== settings.height) {
+      trackers.registerAnotherStream(this.proctoringId, `Maybe have another stream active
+Video Options: ${this.videoOptions}
+Setting: ${settings}`);
+      throw ANOTHER_STREAM_ACTIVE;
+    }
+    this.imageProctoring.useUploadImage && this.photoShotsCycle();
   }
   async stopRecording() {
     this.recordingStop && await this.recordingStop();
@@ -24417,17 +24487,44 @@ var CameraRecorder = class {
   async resumeRecording() {
     await this.recordingResume();
   }
+  photoShotsCycle() {
+    let imageFile;
+    this.configImageCapture();
+    this.imageInterval = setInterval(async () => {
+      this.canvas.getContext("2d").drawImage(this.video, 0, 0, 1280, 720);
+      const image_data_url = this.canvas.toDataURL("image/jpeg");
+      imageFile = await this.getFile(image_data_url, `${this.proctoringId}_${this.imageCount + 1}.jpg`, "image/jpeg");
+      if (imageFile && this.azureUpload && this.backendToken) {
+        this.azureUpload.upload({
+          file: imageFile
+        }, this.backendToken, true);
+        this.imageCount++;
+      }
+    }, this.imageProctoring.uploadInterval * 1e3);
+  }
   async saveOnSession(session) {
     const settings = this.cameraStream.getVideoTracks()[0].getSettings();
     const settingsAudio = this.cameraStream.getAudioTracks()[0].getSettings();
-    session.addRecording({
-      device: `Audio
+    if (this.imageProctoring.saveVideo) {
+      session.addRecording({
+        device: `Audio
 	Sample Rate: ${settingsAudio.sampleRate}
 	Sample Size: ${settingsAudio.sampleSize}`,
-      file: new File(this.blobs, `EP_${session.id}_camera_0.webm`, {
-        type: "video/webm"
-      }),
-      origin: "Camera" /* Camera */
+        file: new File(this.blobs, `EP_${session.id}_camera_0.webm`, {
+          type: "video/webm"
+        }),
+        origin: "Camera" /* Camera */
+      });
+    }
+  }
+  async getFile(file, name, type) {
+    return new Promise((resolve, reject) => {
+      file.length > 5 && fetch(file).then((res) => res.blob()).then((blob) => {
+        const file2 = new File([blob], name, { type });
+        resolve(file2);
+      }).catch((e) => {
+        reject(e);
+      });
     });
   }
 };
@@ -24438,7 +24535,6 @@ var CapturePhoto = class {
   }
   async takePicture(title, subtitle, resolution = { width: 1080, height: 720 }) {
     this.resolution = resolution;
-    console.log(this.resolution);
     return await this.takePictureInterface(title, subtitle);
   }
   async startCapture(cameraId = "default") {
@@ -24463,7 +24559,6 @@ var CapturePhoto = class {
     cameraContainer.play();
   }
   shot() {
-    console.log("shot");
     const cameraContainer = document.querySelector("#cameraStream");
     const canvas = document.querySelector("#canvas");
     const picture = document.querySelector("#image");
@@ -25021,6 +25116,7 @@ var DeviceChecker = class {
       this.cameraRecorder = new CameraRecorder({
         cameraId: cameras == null ? void 0 : cameras.value,
         microphoneId: microphones == null ? void 0 : microphones.value,
+        onBufferSizeError: false,
         onBufferSizeErrorCallback: () => {
         }
       }, {
@@ -25038,6 +25134,7 @@ var DeviceChecker = class {
       this.cameraRecorder = new CameraRecorder({
         cameraId: cameras == null ? void 0 : cameras.value,
         microphoneId: microphones == null ? void 0 : microphones.value,
+        onBufferSizeError: false,
         onBufferSizeErrorCallback: () => {
         }
       }, {
@@ -25056,6 +25153,7 @@ var DeviceChecker = class {
     this.cameraRecorder = new CameraRecorder({
       cameraId: options.cameraId,
       microphoneId: options.microphoneId,
+      onBufferSizeError: false,
       onBufferSizeErrorCallback: () => {
       }
     }, {
@@ -25081,12 +25179,6 @@ var DeviceChecker = class {
   }
 };
 
-// src/errors/errors.ts
-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";
-
 // src/extension/extension.ts
 var Extension = class {
   constructor() {
@@ -25215,6 +25307,16 @@ var BackendService = class {
     });
     return insights2.data;
   }
+  async getImageConfig(proctoringOptions) {
+    const imageConfig = await this.makeRequestAxios({
+      path: `/Client/image-config`,
+      method: "GET",
+      jwt: proctoringOptions.token
+    }).catch((error) => {
+      throw "N\xE3o foi poss\xEDvel realizar a requisi\xE7\xE3o, tente novamente mais tarde";
+    });
+    return imageConfig.data;
+  }
   async getAzureBlobUrl(proctoringOptions) {
     const blobUrl = await this.makeRequestAxios({
       path: `/AzureKey/get-blob-url`,
@@ -25237,15 +25339,12 @@ var BackendService = class {
     });
     return urlAzure.data;
   }
-  async getAzureSignedUrlImage(token, file) {
+  async getAzureSignedUrlImage(token, body) {
     const urlAzure = await this.makeRequestAxios({
-      path: `/AzureKey/signed-url`,
+      path: `/AzureKey/signed-url-batch`,
       method: "POST",
       jwt: token,
-      body: {
-        objectName: file.name,
-        contentType: file.type
-      }
+      body
     });
     return urlAzure.data;
   }
@@ -25481,9 +25580,9 @@ var ProctoringUploader = class {
           rec.upload.storage = result.storage;
         }
         if (result.storage === "AzureBlob" /* AzureBlob */) {
-          rec.upload.azureUrl = result.url;
+          result.url && (rec.upload.azureUrl = result.url);
         } else {
-          rec.upload.awsUrl = result.url;
+          result.url && (rec.upload.awsUrl = result.url);
         }
       }
     }
@@ -25658,7 +25757,7 @@ var ScreenRecorder = class {
   }
   async startRecording() {
     this.startTime = new Date(Date.now());
-    const { allowOnlyFirstMonitor, onStopSharingScreenCallback, onBufferSizeErrorCallback } = this.options;
+    const { allowOnlyFirstMonitor, allowMultipleMonitors, onStopSharingScreenCallback, onBufferSizeErrorCallback } = this.options;
     const displayMediaStreamConstraints = {
       video: {
         cursor: "always",
@@ -25670,12 +25769,18 @@ var ScreenRecorder = class {
     this.screenStream = await navigator.mediaDevices.getDisplayMedia(displayMediaStreamConstraints);
     const tracks = this.screenStream.getVideoTracks();
     tracks[0].onended = onStopSharingScreenCallback;
-    console.log(tracks);
+    const isFirefox = navigator.userAgent.indexOf("Firefox") > -1;
+    if (isFirefox) {
+      const hasMultipleMonitors = tracks.find((el) => el.label == "");
+      if (hasMultipleMonitors && allowOnlyFirstMonitor || hasMultipleMonitors && !allowMultipleMonitors) {
+        throw MULTIPLE_MONITORS_DETECTED;
+      }
+    }
     const sharedFirstScreen = tracks.find((el) => {
       return ["screen:0:0", "Primary Monitor"].includes(el.label);
     }) != null;
     const sharedScreen = tracks.find((el) => {
-      return ["screen:0:0", "Primary Monitor"].includes(el.label) || ["screen:"].some((substring) => el.label.includes(substring));
+      return ["screen:0:0", "Primary Monitor", ""].includes(el.label) || ["screen:"].some((substring) => el.label.includes(substring));
     }) != null;
     const sharedNotAllowed = tracks.find((el) => {
       return ["web-contents-media-stream", "window"].some((substring) => el.label.includes(substring));
@@ -25686,6 +25791,10 @@ var ScreenRecorder = class {
       });
       throw NOT_SHARED_FIRST_SCREEN;
     } else if (!sharedScreen || sharedNotAllowed) {
+      tracks.forEach((el) => {
+        el.stop();
+      });
+      throw NOT_SHARED_SCREEN;
     }
     const { startRecording, stopRecording } = recorder(this.screenStream, this.blobs, this.proctoringId, this.options.onBufferSizeError, onBufferSizeErrorCallback);
     this.recordingStart = startRecording;
@@ -25843,13 +25952,16 @@ function versionVerify() {
 var Proctoring = class {
   constructor(context) {
     this.context = context;
+    this.imageProctoring = {
+      useUploadImage: false,
+      uploadInterval: 20,
+      saveVideo: true
+    };
     this.proctoringId = "";
     this.insights = void 0;
     this.state = "Stop" /* Stop */;
     this.serviceType = "Upload" /* Upload */;
     this.onStopSharingScreenCallback = () => {
-      console.log("Stop sharing screen");
-      trackers.registerStopSharingScreen(this.proctoringId, "Stop sharing screen");
     };
     this.onLostFocusCallback = () => {
     };
@@ -25867,7 +25979,10 @@ var Proctoring = class {
     this.repositoryDevices = new IndexDbSessionRepository("EasyProctorDbDevices", "devices");
   }
   setOnStopSharingScreenCallback(cb) {
-    this.onStopSharingScreenCallback = () => cb();
+    this.onStopSharingScreenCallback = () => {
+      trackers.registerStopSharingScreen(this.proctoringId, "Stop sharing screen");
+      cb();
+    };
   }
   setOnLostFocusCallback(cb) {
     this.onLostFocusCallback = () => cb();
@@ -25886,7 +26001,7 @@ var Proctoring = class {
     this.onBufferSizeErrorCallback = () => cb();
   }
   createRecorders(options = getDefaultProctoringOptions) {
-    var _a2;
+    var _a2, _b;
     const cameraRecorder = new CameraRecorder({
       cameraId: this.sessionOptions.cameraId,
       microphoneId: this.sessionOptions.microphoneId,
@@ -25895,10 +26010,11 @@ var Proctoring = class {
     }, {
       width: this.videoOptions.width,
       height: this.videoOptions.height
-    }, this.backend, this.context.token);
+    }, this.imageProctoring, this.backend, this.context.token);
     const audioRecorder = new AudioRecorder();
     const screenRecorder = this.sessionOptions.captureScreen ? new ScreenRecorder({
       allowOnlyFirstMonitor: (_a2 = this.sessionOptions.allowOnlyFirstMonitor) != null ? _a2 : true,
+      allowMultipleMonitors: (_b = this.sessionOptions.allowMultipleMonitors) != null ? _b : true,
       onStopSharingScreenCallback: () => this.onStopSharingScreenCallback(),
       onBufferSizeError: this.sessionOptions.onBufferSizeError,
       onBufferSizeErrorCallback: () => this.onBufferSizeErrorCallback()
@@ -25928,7 +26044,7 @@ var Proctoring = class {
       this.sessionOptions = { ...getDefaultProctoringOptions, ...options };
       this.videoOptions = validatePartialVideoOptions(_videoOptions);
       await this.initConfig();
-      await this.verifyMultipleMonitors(this.sessionOptions);
+      this.sessionOptions.captureScreen && await this.verifyMultipleMonitors(this.sessionOptions);
       if (this.state != "Stop" /* Stop */) {
         throw PROCTORING_ALREADY_STARTED;
       }
@@ -25957,7 +26073,6 @@ Navigator: ${navigator}`);
       this.state = "Recording" /* Recording */;
       return startResponse;
     } catch (error) {
-      console.log(error);
       await this.cancel();
       trackers.registerStart(this.proctoringId, false, `Token: ${this.context.token}
 Version: ${versionVerify()}
@@ -26061,6 +26176,8 @@ Error: ` + error);
   async initConfig() {
     try {
       this.insights = await this.backend.getInsights(this.context);
+      const imageConfig = await this.backend.getImageConfig(this.context);
+      this.imageProctoring = { ...this.imageProctoring, ...imageConfig };
       this.insights ? init(this.insights) : () => {
         throw "Error on insights key";
       };
@@ -26094,7 +26211,6 @@ Error: ` + error);
       throw PROCTORING_NOT_STARTED;
     }
     await this.verifyMultipleMonitors(this.sessionOptions);
-    this.allRecorders = this.createRecorders(this.sessionOptions);
     await this.recorder.startAll();
     this.proctoringSession.recordings = [];
     await this.repository.save(this.proctoringSession);