easyproctor 2.5.1 → 2.5.3

package/interfaces/ParamsConfig.d.ts

@@ -5,7 +5,6 @@ export type AudioBehaviourParameters = {
     noiseLimit?: number;
 };
 export type ImageBehaviourParameters = {
-    frames?: number;
     useUploadImage?: boolean;
     uploadInterval?: number;
     saveVideo?: boolean;
@@ -25,6 +24,8 @@ export type VideoBehaviourParameters = {
     detectSpeech?: boolean;
     retryEnabled?: boolean;
     maxRetries?: number;
+    realtimePackageSize?: number;
+    realtimeUploadInterval?: number;
 };
 export default interface IParamsConfig {
     audioBehaviourParameters?: AudioBehaviourParameters;

package/new-flow/backend/BackendService.d.ts

@@ -39,7 +39,7 @@ export declare class BackendService {
     stopChallenge(challengeId: string, body: any): Promise<any>;
     startRealtimeAlert(body: any): Promise<any>;
     stopRealtimeAlert(body: any): Promise<any>;
-    verifyFace(proctoringId: any, faceImage: any): Promise<any>;
+    verifyFace(proctoringId: any, faceImage: any, retry: boolean): Promise<any>;
     getServerHour(token: string): Promise<string>;
     private makeRequest;
     makeRequestAxios<R>(data: {

package/new-flow/proctoring/ProctoringSession.d.ts

@@ -18,24 +18,28 @@ export declare enum RecordingOrigin {
 export declare enum AlertCategory {
     NoFace = 1,
     MultipleFaces = 2,
-    LostFocus = 25,
+    FocusOff = 25,
     EnvironmentMultiplePeople = 28,
     EnvironmentNoPeople = 29,
     PotentialCamera = 32,
     SpyDeviceDisconnected = 33,
     StopSharingScreen = 34,
-    ChangeDevices = 39
+    ChangeDevices = 39,
+    ForbiddenAction = 100,
+    System = 200
 }
 export declare enum FinishRealtimeWarningCategory {
     Face = 0,
-    People = 1
+    People = 1,
+    LostFocus = 2
 }
 export declare enum AlertType {
     Audio = 1,
     Video = 2,
     Screen = 3,
     Image = 4,
-    Environment = 5
+    Environment = 5,
+    System = 6
 }
 export interface Alert {
     begin: number;

package/new-flow/recorders/AlertRecorder.d.ts

@@ -6,18 +6,34 @@ export declare class AlertRecorder implements IRecorder {
     private startTime;
     private onLostFocusCallback;
     private onFocusCallback;
+    private onRealtimeAlertCallback?;
     private optionsProctoring;
+    private lastActivityTime;
+    private idleCheckInterval;
+    private readonly IDLE_THRESHOLD_MS;
+    private resizeTimeout;
     constructor(options: {
-        onLostFocusCallback: () => void;
-        onFocusCallback: () => void;
+        onLostFocusCallback: (response: any) => void;
+        onFocusCallback: (response: any) => void;
+        onRealtimeAlertCallback?: (response: any) => void;
     }, optionsProctoring: ProctoringSessionOptions);
     startRecording(): Promise<void>;
     pauseRecording(): Promise<void>;
     resumeRecording(): Promise<void>;
     stopRecording(): Promise<void>;
     saveOnSession(session: ProctoringSession): Promise<void>;
-    private onLostFocus;
-    private onReturnFocus;
+    private attachListeners;
+    private detachListeners;
+    private handleLostFocus;
+    private handleReturnFocus;
+    private handleResize;
+    private handleUserActivity;
+    addBackgroundEvent(description: string, category?: AlertCategory): void;
+    private handleCopy;
+    private handleCut;
+    private handlePaste;
+    private getRelativeTime;
+    private createAlert;
     addAlert({ alert, type }: {
         alert: AlertCategory;
         type: AlertType;

package/new-flow/recorders/CameraRecorder.d.ts

@@ -64,8 +64,9 @@ export declare class CameraRecorder implements IRecorder {
     resumeRecording(): Promise<void>;
     photoShotsCycle(): void;
     getCurrentImageBase64(): Promise<string>;
+    packageCount: number;
     captureFrame(): void;
-    sendFrame(): void;
+    sendPackage(): Promise<void>;
     download(file: File): void;
     saveOnSession(session: ProctoringSession): Promise<void>;
     getFile(file: string, name: string, type: string): Promise<File>;

package/new-flow/recorders/NoiseRecorder.d.ts

@@ -29,6 +29,13 @@ export declare class NoiseRecorder implements IRecorder {
     backend: BackendService | undefined;
     backendToken: string | undefined;
     proctoringId: string | undefined;
+    private preRollBuffer;
+    private recordingChunks;
+    private readonly PRE_ROLL_SECONDS;
+    private readonly SAMPLE_RATE;
+    private readonly MAX_PRE_ROLL_CHUNKS;
+    private lastNoiseTime;
+    private readonly SILENCE_THRESHOLD;
     constructor(optionsProctoring: ProctoringSessionOptions, proctoringSession: ProctoringSession, paramsConfig: IParamsConfig, cameraRecorder: CameraRecorder, onRealtimeAlertsCallback: (response: any) => void, backend?: BackendService, backendToken?: string);
     setProctoringId(proctoringId: string): void;
     startRecording(): Promise<void>;

package/new-flow/upload/UploadService.d.ts

@@ -8,6 +8,7 @@ export declare class UploadService implements IUploadService {
     private imageBatchNum;
     private contImages;
     constructor(proctoringId: string, backend: BackendService);
+    uploadPackage(data: UploadDataDTO, token: string): Promise<any>;
     uploadImages(data: UploadDataDTO, token: string, packSize: number): Promise<UploadResult>;
     upload(data: UploadDataDTO, token: string, image?: boolean): Promise<UploadResult>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "easyproctor",
-  "version": "2.5.1",
+  "version": "2.5.3",
   "description": "Modulo web de gravação do EasyProctor",
   "main": "./index.js",
   "module": "./esm/index.js",
@@ -24,6 +24,7 @@
   "devDependencies": {
     "@types/dom-mediacapture-record": "^1.0.11",
     "@types/file-saver": "^2.0.7",
+    "@types/jszip": "^3.4.0",
     "@types/qrcode": "^1.5.5",
     "@types/recordrtc": "^5.6.8",
     "@typescript-eslint/eslint-plugin": "^5.8.0",
@@ -32,6 +33,7 @@
     "esbuild-serve": "^1.0.1",
     "eslint": "^8.2.0",
     "eslint-plugin-html": "^6.2.0",
+    "jszip": "^3.10.1",
     "typescript": "^4.5.4"
   },
   "dependencies": {

package/proctoring/proctoring.d.ts

@@ -15,7 +15,7 @@ export interface ProctoringContext {
 }
 export interface ProctoringFinisherOptions {
     onProgress?: (percentage: number) => void;
-    onFinish?: (score: number, scoreThreshold: number, approved: boolean, justification: string) => void;
+    onResultAvailable?: (score: number, scoreThreshold: number, approved: boolean, justification: string) => void;
 }
 export interface ProctoringChangeDevicesOptions {
     status?: (devices: DevicesChanged) => void;
@@ -55,12 +55,17 @@ export declare class Proctoring {
     private allRecorders;
     private spyCam;
     appChecker: ExternalCameraChecker;
+    private verifyFirstFaceInterval;
     private onStopSharingScreenCallback;
     setOnStopSharingScreenCallback(cb: () => void): void;
+    private setOnLostFocusAlertRecorderCallback;
+    private setOnFocusAlertRecorderCallback;
     private onLostFocusCallback;
-    setOnLostFocusCallback(cb: () => void): void;
+    private onLostFocusAlertRecorderCallback;
+    setOnLostFocusCallback(cb: () => void): Promise<void>;
     private onFocusCallback;
-    setOnFocusCallback(cb: () => void): void;
+    private onFocusAlertRecorderCallback;
+    setOnFocusCallback(cb: () => void): Promise<void>;
     private onChangeDevicesCallback;
     onChangeDevices(options?: ProctoringChangeDevicesOptions): Promise<void>;
     private convertRealtimeCategoryToAlertCategory;

package/proctoring/useProctoring.d.ts

@@ -3,10 +3,10 @@ import enumarateDevices from "../modules/enumarateDevices";
 import { ProctoringContext } from "./proctoring";
 export declare function useProctoring(proctoringOptions: ProctoringContext, enviromentConfig?: string): {
     login: () => Promise<void>;
-    start: (parameters: any) => Promise<import("../dtos/StartProctoringResponse").default>;
+    start: (parameters: any, videoOptions: any) => Promise<import("../dtos/StartProctoringResponse").default>;
     finish: (options?: import("./proctoring").ProctoringFinisherOptions) => Promise<void>;
-    onFocus: (cb: () => void) => void;
-    onLostFocus: (cb: () => void) => void;
+    onFocus: (cb: () => void) => Promise<void>;
+    onLostFocus: (cb: () => void) => Promise<void>;
     onChangeDevices: (options?: import("./proctoring").ProctoringChangeDevicesOptions) => Promise<void>;
     onBufferSizeError: (cb: (cameraStream?: any) => void) => void;
     onRealtimeAlerts: (options?: import("./proctoring").ProctoringRealtimeAlertsOptions) => Promise<void>;