easyproctor 2.3.5 → 2.5.0

package/interfaces/Devices.d.ts

@@ -8,4 +8,5 @@ export default interface Devices {
 }
 export interface DevicesChanged extends Devices {
     status: string;
+    isActiveDevice: boolean;
 }

package/modules/BaseDetection.d.ts

@@ -17,6 +17,7 @@ export declare class BaseDetection {
     detectorType: string;
     modelAssetPath: string;
     createdVideo: boolean;
+    startTime: Date | undefined;
     constructor(detectorType: any, modelAssetPath: string, options?: {
         onRealtimeAlertsCallback?: (response: any) => void;
     }, paramsConfig?: IParamsConfig, classVideo?: string, classDiv?: string);

package/modules/faceDetection.d.ts

@@ -4,11 +4,13 @@ export declare class FaceDetection extends BaseDetection {
     constructor(options?: {
         onRealtimeAlertsCallback?: (response: any) => void;
     }, paramsConfig?: IParamsConfig, classVideo?: string, classDiv?: string);
+    stopDetection(): void;
     displayVideoDetections(result: {
         detections: any;
     }): void;
     numFacesSent: number;
     emmitedPositionAlert: boolean;
+    emmitedFaceAlert: boolean;
     verify(result: {
         detections: any;
     }): void;

package/modules/objectDetection.d.ts

@@ -4,6 +4,7 @@ export declare class ObjectDetection extends BaseDetection {
     constructor(options?: {
         onRealtimeAlertsCallback?: (response: any) => void;
     }, paramsConfig?: IParamsConfig, classVideo?: string, classDiv?: string);
+    stopDetection(): void;
     displayVideoDetections(result: {
         detections: any;
     }): void;

package/modules/onChangeDevices.d.ts

@@ -1,9 +1,12 @@
 import { ISessionRepository } from "../new-flow/repository/ISessionRepository";
+import { ProctoringSessionOptions } from "../proctoring/options/ProctoringOptions";
 import { ProctoringChangeDevicesOptions } from "../proctoring/proctoring";
 export declare class onChangeDevices {
     private repositoryDevices;
     private proctoringId;
-    constructor(repositoryDevices: ISessionRepository, proctoringId: string);
+    private sessionOptions;
+    private allRecorders;
+    constructor(repositoryDevices: ISessionRepository, proctoringId: string, sessionOptions: ProctoringSessionOptions, allRecorders: any);
     startRecording(options: ProctoringChangeDevicesOptions): void;
     onChangeDevices(options: ProctoringChangeDevicesOptions): Promise<void>;
 }

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

@@ -2,6 +2,7 @@ import StartProctoringResponse from "../../dtos/StartProctoringResponse";
 import { ProctoringSession } from "../proctoring/ProctoringSession";
 import { ProctoringContext } from "../../proctoring/proctoring";
 import IParamsConfig from "../../interfaces/ParamsConfig";
+import { ProctoringSessionOptions } from "../../proctoring/options/ProctoringOptions";
 export declare class BackendService {
     private readonly options;
     private readonly baseUrl;
@@ -17,22 +18,28 @@ export declare class BackendService {
     externalCameraCheckTransmission(externalSessionId: string): Promise<any>;
     externalCameraStartTransmission(externalSessionId: string, proctoringId: string): Promise<any>;
     externalCameraStartSession(): Promise<any>;
+    goToExternalCameraPositionStep(externalSessionId: string): Promise<any>;
     externalCameraFinish(externalSessionId: string): Promise<any>;
     confirmStart(proctoringOptions: {
         examId: any;
         clientId: any;
         token: any;
-    }, proctoringType: string, latitude?: number, longitude?: number): Promise<StartProctoringResponse>;
+    }, sessionOptions: ProctoringSessionOptions, latitude?: number, longitude?: number): Promise<StartProctoringResponse>;
     getParamsConfig(proctoringOptions: ProctoringContext): Promise<IParamsConfig>;
     getSignedUrlImage(token: string, body: any): Promise<string[]>;
     getSignedUrl(token: string, file: File, proctoringId?: string): Promise<string>;
     saveAlerts(proctoringOptions: ProctoringContext, proctoringSession: ProctoringSession): Promise<void>;
-    finishAndSendUrls(proctoringOptions: ProctoringContext, proctoringSession: ProctoringSession): Promise<void>;
+    finishAndSendUrls(proctoringOptions: ProctoringContext): Promise<any>;
     log(eventName: string, properties?: {
         [key: string]: any;
     }): Promise<string>;
     signTerm(): Promise<string>;
     signTermUrl(): Promise<string>;
+    startChallenge(body: any): Promise<any>;
+    stopChallenge(challengeId: string, body: any): Promise<any>;
+    startRealtimeAlert(body: any): Promise<any>;
+    stopRealtimeAlert(body: any): Promise<any>;
+    verifyFace(proctoringId: any, faceImage: any): Promise<any>;
     getServerHour(token: string): Promise<string>;
     private makeRequest;
     makeRequestAxios<R>(data: {

package/new-flow/checkers/DeviceCheckerService.d.ts

@@ -17,6 +17,7 @@ export interface checkDevicesReturn {
     };
 }
 export declare class DeviceCheckerService {
+    private deviceCheckResult;
     private static isModalOpen;
     private options;
     private videoOptions;
@@ -41,6 +42,7 @@ export declare class DeviceCheckerService {
     private spycam;
     private spydevices;
     constructor(context: ProctoringContext);
+    getDeviceCheckResult(): any;
     runCheckDevicesFlow(options: ProctoringSessionOptions, _videoOptions: Partial<ProctoringVideoOptions>, onModalConfirm: (resolve: (cameraId: string, microphoneId: string) => void) => void, onModalCancel: (reject: (error: Error) => void) => void, onUpdate: (feedback: any) => void): Promise<any>;
     private onUpdateCallback;
     checkDevices(options?: ProctoringSessionOptions, _videoOptions?: ProctoringVideoOptions): Promise<checkDevicesReturn>;

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

@@ -16,9 +16,19 @@ export declare enum RecordingOrigin {
     Camera = "Camera"
 }
 export declare enum AlertCategory {
+    NoFace = 1,
+    MultipleFaces = 2,
     LostFocus = 25,
+    EnvironmentMultiplePeople = 28,
+    EnvironmentNoPeople = 29,
     PotentialCamera = 32,
-    SpyDeviceDisconnected = 33
+    SpyDeviceDisconnected = 33,
+    StopSharingScreen = 34,
+    ChangeDevices = 39
+}
+export declare enum FinishRealtimeWarningCategory {
+    Face = 0,
+    People = 1
 }
 export declare enum AlertType {
     Audio = 1,

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

@@ -1,5 +1,5 @@
 import { ProctoringSessionOptions } from "../../proctoring/options/ProctoringOptions";
-import { ProctoringSession } from "../proctoring/ProctoringSession";
+import { AlertCategory, AlertType, ProctoringSession } from "../proctoring/ProctoringSession";
 import { IRecorder } from "./IRecorder";
 export declare class AlertRecorder implements IRecorder {
     private alerts;
@@ -18,4 +18,8 @@ export declare class AlertRecorder implements IRecorder {
     saveOnSession(session: ProctoringSession): Promise<void>;
     private onLostFocus;
     private onReturnFocus;
+    addAlert({ alert, type }: {
+        alert: AlertCategory;
+        type: AlertType;
+    }): void;
 }

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

@@ -32,6 +32,10 @@ export declare class CameraRecorder implements IRecorder {
     filesToUpload: File[];
     private intervalNoiseDetection;
     private volumeMeter;
+    private animationFrameId;
+    private isCanvasLoopActive;
+    private hardwareStream;
+    private internalClonedStream;
     constructor(options: {
         cameraId?: string;
         microphoneId?: string;
@@ -59,6 +63,7 @@ export declare class CameraRecorder implements IRecorder {
     pauseRecording(): Promise<void>;
     resumeRecording(): Promise<void>;
     photoShotsCycle(): void;
+    getCurrentImageBase64(): Promise<string>;
     captureFrame(): void;
     sendFrame(): void;
     download(file: File): void;
@@ -66,4 +71,5 @@ export declare class CameraRecorder implements IRecorder {
     getFile(file: string, name: string, type: string): Promise<File>;
     noiseWait: number;
     private onNoiseDetected;
+    private createRotatedStream;
 }

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

@@ -12,6 +12,10 @@ export declare class ScreenRecorder implements IRecorder {
     constructor(options: {
         allowOnlyFirstMonitor: boolean;
         allowMultipleMonitors: boolean;
+        screenRecorderOptions: {
+            width: number;
+            height: number;
+        };
         onStopSharingScreenCallback: () => void;
         onBufferSizeError?: boolean;
         onBufferSizeErrorCallback: () => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "easyproctor",
-  "version": "2.3.5",
+  "version": "2.5.0",
   "description": "Modulo web de gravação do EasyProctor",
   "main": "./index.js",
   "module": "./esm/index.js",

package/plugins/insights.d.ts

@@ -2,6 +2,7 @@ import { ServiceType } from '../proctoring/proctoring';
 import { BackendService } from '../new-flow/backend/BackendService';
 declare const init: (backend: BackendService) => BackendService;
 declare const trackers: {
+    registerDevicesChecked: (proctoringId: string, success: boolean, description: string) => Promise<string>;
     registerStart: (proctoringId: string, success: boolean, description: string) => Promise<string>;
     registerFinish: (proctoringId: string, success: boolean, description: string) => Promise<string>;
     registerError: (proctoringId: string, description: string) => Promise<string>;

package/proctoring/options/ProctoringOptions.d.ts

@@ -11,5 +11,10 @@ export interface ProctoringSessionOptions {
     useGeolocation?: boolean;
     useSpyScan?: boolean;
     useExternalCamera?: boolean;
+    useChallenge?: boolean;
+    screenRecorderOptions?: {
+        width: number;
+        height: number;
+    };
 }
 export declare const getDefaultProctoringOptions: ProctoringSessionOptions;

package/proctoring/proctoring.d.ts

@@ -15,6 +15,7 @@ export interface ProctoringContext {
 }
 export interface ProctoringFinisherOptions {
     onProgress?: (percentage: number) => void;
+    onFinish?: (score: number, approved: boolean) => void;
 }
 export interface ProctoringChangeDevicesOptions {
     status?: (devices: DevicesChanged) => void;
@@ -40,6 +41,7 @@ export declare class Proctoring {
     private readonly repository;
     private readonly repositoryDevices;
     private extension;
+    private deviceData;
     private paramsConfig;
     private proctoringId;
     private insights?;
@@ -61,10 +63,13 @@ export declare class Proctoring {
     setOnFocusCallback(cb: () => void): void;
     private onChangeDevicesCallback;
     onChangeDevices(options?: ProctoringChangeDevicesOptions): Promise<void>;
+    private convertRealtimeCategoryToAlertCategory;
+    private convertRealtimeTypeToWarningType;
     private onRealtimeAlertsCallback;
     onRealtimeAlerts(options?: ProctoringRealtimeAlertsOptions): Promise<void>;
     private onBufferSizeErrorCallback;
     setOnBufferSizeErrorCallback(cb: (cameraStream?: any) => void): void;
+    setDeviceCheckData(data: any): void;
     constructor(context: ProctoringContext);
     private createRecorders;
     login(): Promise<void>;

package/proctoring/useProctoring.d.ts

@@ -3,7 +3,7 @@ import enumarateDevices from "../modules/enumarateDevices";
 import { ProctoringContext } from "./proctoring";
 export declare function useProctoring(proctoringOptions: ProctoringContext, enviromentConfig?: string): {
     login: () => Promise<void>;
-    start: (options?: import("./options/ProctoringOptions").ProctoringSessionOptions, _videoOptions?: Partial<import("./options/ProctoringVideoOptions").ProctoringVideoOptions>) => Promise<import("../dtos/StartProctoringResponse").default>;
+    start: (parameters: any) => Promise<import("../dtos/StartProctoringResponse").default>;
     finish: (options?: import("./proctoring").ProctoringFinisherOptions) => Promise<void>;
     onFocus: (cb: () => void) => void;
     onLostFocus: (cb: () => void) => void;