easyproctor-hml 2.6.0 → 2.7.0

package/modules/BaseDetection.d.ts

@@ -22,7 +22,7 @@ export declare class BaseDetection {
     }, paramsConfig?: IParamsConfig, classVideo?: string, classDiv?: string);
     initializeDetector(): Promise<void>;
     stopDetection(): void;
-    enableCam(cameraStream?: MediaProvider | null | undefined): void;
+    enableCam(cameraStream?: MediaProvider | null | undefined, delay?: number): void;
     lastVideoTime: number;
     lastExecutionDate: number;
     predictWebcam(): Promise<void>;

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

@@ -5,13 +5,16 @@ import IParamsConfig from "../../interfaces/ParamsConfig";
 import { ProctoringSessionOptions } from "../../proctoring/options/ProctoringOptions";
 export declare class BackendService {
     private readonly options;
-    private readonly baseUrl;
+    private baseUrl;
     token: string;
     constructor(options: {
         type: string;
         token?: string;
+        isRealtime?: boolean;
     });
-    selectBaseUrl(type: string): "https://proctoring-api-dev.easyproctor.tech/api" | "https://proctoring-api-hml.easyproctor.tech/api" | "https://proctoring-api.easyproctor.tech/api";
+    getBaseUrl(): string;
+    selectBaseUrl(type: string, isRealtime?: boolean): "https://easyproctor-realtime-api-dev.easyproctor.tech/api" | "https://easyproctor-realtime-api-hml.easyproctor.tech/api" | "https://easyproctor-realtime-api.easyproctor.tech/api" | "https://proctoring-api-dev.easyproctor.tech/api" | "https://proctoring-api-hml.easyproctor.tech/api" | "https://proctoring-api.easyproctor.tech/api";
+    setRealtime(isRealtime: boolean): void;
     getSocketUrl(): string;
     loginAuth(cpf: string, base64: string): Promise<any>;
     externalCameraRegister(body: any): Promise<any>;
@@ -28,6 +31,7 @@ export declare class BackendService {
     getParamsConfig(proctoringOptions: ProctoringContext): Promise<IParamsConfig>;
     getSignedUrlImage(token: string, body: any): Promise<string[]>;
     getSignedUrl(token: string, file: File, proctoringId?: string): Promise<string>;
+    initiateUpload(token: string, objectName: string, contentType: string): Promise<string>;
     saveAlerts(proctoringOptions: ProctoringContext, proctoringSession: ProctoringSession): Promise<void>;
     finishAndSendUrls(proctoringOptions: ProctoringContext): Promise<any>;
     log(eventName: string, properties?: {
@@ -40,6 +44,7 @@ export declare class BackendService {
     startRealtimeAlert(body: any): Promise<any>;
     stopRealtimeAlert(body: any): Promise<any>;
     verifyFace(proctoringId: any, faceImage: any, retry: boolean): Promise<any>;
+    checkUpload(token: string, objectName: string, contentType: string): Promise<boolean>;
     getServerHour(token: string): Promise<string>;
     private makeRequest;
     makeRequestAxios<R>(data: {

package/new-flow/chunk/BackgroundUploadService.d.ts

@@ -0,0 +1,38 @@
+import { BackendService } from "../backend/BackendService";
+import { ChunkStorageService } from "./ChunkStorageService";
+export interface BackgroundUploadConfig {
+    pollInterval?: number;
+    maxRetries?: number;
+    baseRetryDelay?: number;
+    cleanAfterUpload?: boolean;
+}
+export declare class BackgroundUploadService {
+    private readonly config;
+    private readonly chunkStorage;
+    private readonly backend;
+    private readonly proctoringId;
+    private readonly token;
+    private pollTimer;
+    private isProcessing;
+    private isRunning;
+    private retryCount;
+    private sessionUrl;
+    private currentOffset;
+    private totalBytesPurged;
+    private readonly STORAGE_KEY_PREFIX;
+    private readonly GCS_CHUNK_SIZE;
+    onChunkUploaded?: (chunkId: number, chunkIndex: number) => void;
+    onUploadError?: (chunkId: number, error: any) => void;
+    constructor(proctoringId: string, token: string, backend: BackendService, chunkStorage: ChunkStorageService, config?: BackgroundUploadConfig);
+    private loadSessionState;
+    private saveSessionState;
+    private clearSessionState;
+    start(): void;
+    stop(): void;
+    flush(): Promise<void>;
+    private syncOffset;
+    private processQueue;
+    private uploadData;
+    static recoverPendingUploads(backend: BackendService, token: string): Promise<string[]>;
+    private sleep;
+}

package/new-flow/chunk/ChunkStorageService.d.ts

@@ -0,0 +1,25 @@
+export interface VideoChunk {
+    id?: number;
+    proctoringId: string;
+    chunkIndex: number;
+    blob: Blob;
+    timestamp: number;
+    uploaded: number;
+    mimeType: string;
+}
+export declare class ChunkStorageService {
+    private static readonly DB_NAME;
+    private static readonly DB_VERSION;
+    private static readonly STORE_NAME;
+    private db;
+    connect(): Promise<IDBDatabase>;
+    saveChunk(chunk: Omit<VideoChunk, "id">): Promise<number>;
+    getPendingChunks(proctoringId: string): Promise<VideoChunk[]>;
+    getAllChunks(proctoringId: string): Promise<VideoChunk[]>;
+    markAsUploaded(chunkId: number): Promise<void>;
+    clearUploadedChunks(proctoringId: string): Promise<void>;
+    clearAllChunks(proctoringId: string): Promise<void>;
+    hasAnyPendingChunks(): Promise<boolean>;
+    getPendingProctoringIds(): Promise<string[]>;
+    close(): void;
+}

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

@@ -27,6 +27,7 @@ export declare enum AlertCategory {
     ChangeDevices = 39,
     ClipBoardUse = 42,
     SplitScreen = 43,
+    RealtimeOffline = 44,
     System = 200
 }
 export declare enum FinishRealtimeWarningCategory {

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

@@ -30,6 +30,7 @@ export declare class CameraRecorder implements IRecorder {
     faceDetection: FaceDetection;
     objectDetection: ObjectDetection;
     filesToUpload: File[];
+    pendingPackages: File[][];
     private intervalNoiseDetection;
     private volumeMeter;
     private animationFrameId;
@@ -39,6 +40,17 @@ export declare class CameraRecorder implements IRecorder {
     private videoElement;
     private duration;
     stopped: boolean;
+    private static readonly CHUNK_TIMESLICE_MS;
+    private static readonly LS_SESSION_KEY;
+    private chunkStorage;
+    private backgroundUpload;
+    private chunkIndex;
+    private pendingChunkSaves;
+    onSessionInterrupted?: () => void;
+    onVisibilityRestored?: () => void;
+    private boundVisibilityHandler;
+    private boundPageHideHandler;
+    private get isChunkEnabled();
     constructor(options: {
         cameraId?: string;
         microphoneId?: string;
@@ -57,6 +69,17 @@ export declare class CameraRecorder implements IRecorder {
     getStartTime: () => any;
     getDuration: () => any;
     setProctoringId(proctoringId: string): void;
+    private persistSessionState;
+    private clearSessionState;
+    static checkForActiveSession(): {
+        proctoringId: string;
+        status: string;
+        timestamp: number;
+    } | null;
+    private setupLifecycleListeners;
+    private removeLifecycleListeners;
+    private handleVisibilityChange;
+    private handlePageHide;
     initializeDetectors(): Promise<void>;
     configImageCapture(): void;
     currentRetries: number;
@@ -67,16 +90,19 @@ export declare class CameraRecorder implements IRecorder {
     attachAndWarmup(stream: MediaStream): Promise<void>;
     startRecording(): Promise<void>;
     stopRecording(): Promise<void>;
+    private handleNewChunk;
     pauseRecording(): Promise<void>;
     resumeRecording(): Promise<void>;
     getCurrentImageBase64(): Promise<string>;
     packageCount: number;
     captureFrame(): Promise<void>;
     startRealtimeCapture(): Promise<void>;
-    sendPackage(framesToSend: File[]): Promise<void>;
+    private failedUploads;
+    sendPackage(): Promise<void>;
     download(file: File): void;
     saveOnSession(session: ProctoringSession): Promise<void>;
     getFile(file: string, name: string, type: string): Promise<File>;
+    private checkInternetStability;
     noiseWait: number;
     private onNoiseDetected;
 }

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

@@ -34,6 +34,7 @@ export declare class NoiseRecorder implements IRecorder {
     private readonly MAX_PRE_ROLL_CHUNKS;
     private lastNoiseTime;
     private readonly SILENCE_THRESHOLD;
+    private filesToUpload;
     constructor(optionsProctoring: ProctoringSessionOptions, proctoringSession: ProctoringSession, paramsConfig: IParamsConfig, cameraRecorder: CameraRecorder, onRealtimeAlertsCallback: (response: any) => void, backend?: BackendService, backendToken?: string);
     setProctoringId(proctoringId: string): void;
     startRecording(): Promise<void>;
@@ -44,7 +45,6 @@ export declare class NoiseRecorder implements IRecorder {
     private onNoiseDetectedRecord;
     private stopSoundRecord;
     private download;
-    private uploadRecord;
     private hasDesiredResult;
     private createAudioClassifier;
     private streamingAudioClassification;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "easyproctor-hml",
-  "version": "2.6.0",
+  "version": "2.7.0",
   "description": "Modulo web de gravação do EasyProctor",
   "main": "./index.js",
   "module": "./esm/index.js",
@@ -17,6 +17,7 @@
   "scripts": {
     "build": "node scripts/build.js && tsc",
     "dev": "node scripts/serve.js -w",
+    "dev:https": "node scripts/build.js && node scripts/serve-https.js",
     "publish": "npm publish ./dist"
   },
   "author": "IARIS",

package/plugins/recorder.d.ts

@@ -1,5 +1,9 @@
 export declare function setRecorderProctoringId(id: string): void;
-export default function recorder(stream: MediaStream, buffer: Blob[], onBufferSizeError?: boolean, onBufferSizeErrorCallback?: (e?: any) => void, audio?: boolean): {
+export interface RecorderOptions {
+    timeslice?: number;
+    onChunkAvailable?: (blob: Blob, chunkIndex: number) => void;
+}
+export default function recorder(stream: MediaStream, buffer: Blob[], onBufferSizeError?: boolean, onBufferSizeErrorCallback?: (e?: any) => void, audio?: boolean, recorderOpts?: RecorderOptions): {
     startRecording: () => Promise<void>;
     stopRecording: () => Promise<void>;
     pauseRecording: () => Promise<void>;

package/proctoring/proctoring.d.ts

@@ -59,6 +59,10 @@ export declare class Proctoring {
     appChecker: ExternalCameraChecker;
     private verifyFirstFaceInterval;
     private onStopSharingScreenCallback;
+    private onVisibilityLostCallback;
+    private onVisibilityRestoredCallback;
+    setOnVisibilityLostCallback(cb: () => void): void;
+    setOnVisibilityRestoredCallback(cb: () => void): void;
     setOnStopSharingScreenCallback(cb: () => void): void;
     private setOnLostFocusAlertRecorderCallback;
     private setOnFocusAlertRecorderCallback;
@@ -74,6 +78,8 @@ export declare class Proctoring {
     private convertRealtimeTypeToWarningType;
     private stopRealtimeAlert;
     private onRealtimeAlertsCallback;
+    private sendPendingRealtimeAlerts;
+    private realtimeAlertsToSend;
     private internalOnRealtimeAlerts;
     onRealtimeAlerts(options?: ProctoringRealtimeAlertsOptions): Promise<void>;
     private onBufferSizeErrorCallback;

package/proctoring/useProctoring.d.ts

@@ -28,4 +28,6 @@ export declare function useProctoring(proctoringOptions: ProctoringContext, envi
     takeExternalCameraPicture: (waitingPositionValidation: boolean, onTakePictureCallback: (response: any) => void) => Promise<void>;
     goToExternalCameraPositionStep: () => Promise<void>;
     startExternalCameraTransmission: (proctoringId: string) => Promise<void>;
+    onVisibilityLost: (cb: () => void) => void;
+    onVisibilityRestored: (cb: () => void) => void;
 };