easyproctor 2.0.2 → 2.1.0

package/modules/BaseDetection.d.ts

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

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

@@ -0,0 +1,54 @@
+import { ProctoringSessionOptions } from "../../proctoring/options/ProctoringOptions";
+import { ProctoringVideoOptions } from "../../proctoring/options/ProctoringVideoOptions";
+import { ProctoringContext } from "../../proctoring/proctoring";
+export interface checkDevicesReturn {
+    cameraId?: string;
+    microphoneId?: string;
+    volumeRange?: number;
+    allowedResolution?: boolean;
+    allowedAmbient?: boolean;
+    allowedPositionFace?: boolean;
+    allowedMicrophone?: boolean;
+    result: boolean;
+    faceDetectionAlerts?: {
+        status: string;
+        description: string;
+    };
+}
+export declare class DeviceCheckerService {
+    private static isModalOpen;
+    private options;
+    private videoOptions;
+    private cameraRecorder;
+    private DeviceCheckerUI;
+    private volumeMeter;
+    private volumeMedia;
+    private volumeSum;
+    private volumeCounter;
+    private faceDetection;
+    private faceDetectionAlerts;
+    private microphoneMinThreshold;
+    private allowedResolution;
+    private allowedAmbient;
+    private allowedPositionFace;
+    private allowedMicrophone;
+    private readonly backend;
+    private readonly context;
+    private noiseLimit;
+    private onUpdateCb;
+    constructor(context: ProctoringContext);
+    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 | undefined, _videoOptions: ProctoringVideoOptions): Promise<checkDevicesReturn>;
+    private isUnderResolution;
+    private realtimeAlerts;
+    private videoDeviceInterface;
+    private audioDeviceInterface;
+    changeSelectedDevice({ cameraId, microphoneId }: any): Promise<{
+        cameraStream: MediaStream;
+    }>;
+    startCheckDevices(options: ProctoringSessionOptions | undefined, _videoOptions: Partial<ProctoringVideoOptions>): Promise<{
+        cameraStream: MediaStream;
+    }>;
+    closeCheckDevices(): Promise<void>;
+}

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

@@ -0,0 +1,49 @@
+import { ProctoringSessionOptions } from "../../proctoring/options/ProctoringOptions";
+import { ProctoringVideoOptions } from "../../proctoring/options/ProctoringVideoOptions";
+import { CameraRecorder } from "../recorders/CameraRecorder";
+import { VolumeMeter } from "../recorders/VolumeMeter";
+export interface checkDevicesInterfaceReturn {
+    cameraId: string;
+    microphoneId: string;
+    result: boolean;
+}
+export declare class DeviceCheckerUI {
+    options: ProctoringSessionOptions;
+    videoOptions: ProctoringVideoOptions;
+    cameraRecorder: CameraRecorder;
+    volumeMeter: VolumeMeter | undefined;
+    constructor(options: ProctoringSessionOptions | undefined, _videoOptions: ProctoringVideoOptions);
+    checkDevicesInterface(): void;
+    setSelectOption(options: ProctoringSessionOptions, changeSelectedDevice: (arg0: {
+        cameras: any;
+        microphones: any;
+    } | {
+        cameras: HTMLSelectElement | null;
+        microphones: HTMLSelectElement | null;
+    }) => any): Promise<void>;
+    onSelectOptionChange(changeSelectedDevice: {
+        (e: any): any;
+        (arg0: {
+            cameraId: string | undefined;
+            microphoneId: string | undefined;
+        }): any;
+    }): Promise<void>;
+    closeModal(): void;
+    modalActions(closeCheckDevices: {
+        (): Promise<void>;
+        (): void;
+    }): Promise<checkDevicesInterfaceReturn>;
+    realtimeAlertsUI(response: {
+        status: string;
+        description: string;
+        type?: string;
+    }): void;
+    isUnderResolutionUI(allowedResolution: boolean): void;
+    videoDeviceInterfaceUI(stream: MediaStream): void;
+    audioDeviceInterfaceUIAllowedAmbient(allowedAmbient: boolean): void;
+    audioDeviceInterfaceUIMicrophoneWorks(microphoneWorks: boolean): void;
+    audioDeviceInterfaceUIErrorExec(): void;
+    audioDeviceInterfaceUIPills(value: number): void;
+    addStyleMask(): Promise<void>;
+    applyStyles(element: any, styles: any): void;
+}

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

@@ -1,6 +1,5 @@
 import { ProctoringSessionOptions } from "../../proctoring/options/ProctoringOptions";
 import { ProctoringSession } from "../proctoring/ProctoringSession";
-import { CameraRecorder } from "./CameraRecorder";
 import { IRecorder } from "./IRecorder";
 export declare class AlertRecorder implements IRecorder {
     private alerts;
@@ -8,13 +7,10 @@ export declare class AlertRecorder implements IRecorder {
     private onLostFocusCallback;
     private onFocusCallback;
     private optionsProctoring;
-    private cameraRecorder;
-    private intervalNoiseDetection;
-    private volumeMeter;
     constructor(options: {
         onLostFocusCallback: () => void;
         onFocusCallback: () => void;
-    }, optionsProctoring: ProctoringSessionOptions, cameraRecorder: CameraRecorder);
+    }, optionsProctoring: ProctoringSessionOptions);
     startRecording(): Promise<void>;
     pauseRecording(): Promise<void>;
     resumeRecording(): Promise<void>;

package/package.json

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

package/proctoring/useProctoring.d.ts

@@ -10,7 +10,11 @@ export declare function useProctoring(proctoringOptions: ProctoringContext, envi
     onChangeDevices: (options?: import("./proctoring").ProctoringChangeDevicesOptions) => Promise<void>;
     onBufferSizeError: (cb: () => void) => void;
     onRealtimeAlerts: (options?: import("./proctoring").ProctoringRealtimeAlertsOptions) => Promise<void>;
-    checkDevices: (options: import("./options/ProctoringOptions").ProctoringSessionOptions | undefined, _videoOptions: import("./options/ProctoringVideoOptions").ProctoringVideoOptions) => Promise<import("./DeviceChecker").checkDevicesReturn>;
+    checkDevices: (options: import("./options/ProctoringOptions").ProctoringSessionOptions | undefined, _videoOptions: import("./options/ProctoringVideoOptions").ProctoringVideoOptions) => Promise<import("../new-flow/checkers/DeviceCheckerService").checkDevicesReturn>;
+    runCheckDevicesFlow: (options: import("./options/ProctoringOptions").ProctoringSessionOptions, _videoOptions: Partial<import("./options/ProctoringVideoOptions").ProctoringVideoOptions>, onModalConfirm: (resolve: (cameraId: string, microphoneId: string) => void) => void, onModalCancel: (reject: (error: Error) => void) => void, onUpdate: (feedback: any) => void) => Promise<any>;
+    changeSelectedDevice: ({ cameraId, microphoneId }: any) => Promise<{
+        cameraStream: MediaStream;
+    }>;
     capturePhoto: (title: string, subtitle: string, resolution?: import("./CapturePhoto").IResolution) => Promise<import("./CapturePhoto").cameraInterface>;
     enumarateDevices: typeof enumarateDevices;
     checkPermissions: typeof checkPermissions;