@voicenter-team/opensips-js 1.0.10

package/README.md

@@ -0,0 +1,75 @@
+# Getting started
+## Installation
+Using npm:
+```shell
+$ npm i @voicenter-team/opensips-js
+```
+
+## Usage
+Firstly lets import the library and create the OpenSIPS instance:
+```javascript
+import OpenSIPSJS from '@voicenter-team/opensips-js'
+
+const openSIPSJS = new OpenSIPSJS({
+    configuration: {
+        session_timers: false,
+        uri: 'sip:extension_user@domain',
+        password: 'password',
+    },
+    socketInterfaces: [ 'wss://domain' ],
+    sipDomain: 'domain',
+    sipOptions: {
+        session_timers: false,
+        extraHeaders: [ 'X-Bar: bar' ],
+        pcConfig: {},
+    },
+})
+```
+
+Then you will be able to call next methods on openSIPSJS instance:
+
+### Methods
+- `async setMediaDevices(setDefaults: Boolean = false)` - will set up media devices
+- `async setMicrophone(deviceId: String)` - set passed device as input device for calls
+- `async setSpeaker(deviceId: String)` - set passed device as output device for calls
+- `async setCurrentActiveRoomId(roomId: Number)` - move to the room
+- `doCallHold({callId: Number, toHold: Boolean, automatic: Boolean})` - hold/unhold call by id
+- `doCall(target: String, addToCurrentRoom: Boolean)` - call to the target. If addToCurrentRoom is true then the call will be added to the user's current room
+- `callTerminate(callId: String)` - terminate call
+- `callTransfer({callId: String, target: String})` - transfer call to target
+- `callMerge(roomId: Number)` - merge calls in specific room
+- `callAnswer(callId: String)` - answer the call
+- `setMetricsConfig(config: WebrtcMetricsConfigType)` - set the metric config (used for audio quality indicator)
+- `doMute(muted: Boolean)` - set the agent muteness
+- `setDND(value: Boolean)` - set the agent "Do not disturb" status
+- `async callChangeRoom({callId: String, roomId: Number})` - move call to the room
+- `callMove({callId: String, roomId: Number})` - Same as callChangeRoom. Move call to the specific room
+- `subscribe({type: String, listener: function})` - subscribe to an event. Available events: `new_call`, `ended`, `progress`, `failed`, `confirmed`
+- `removeIListener(type: String)` - remove event listener
+
+WebrtcMetricsConfigType
+
+| Parameter      | Type                   |
+|----------------|------------------------|
+| `refreshEvery` | `number \| undefined`  |
+| `startAfter`   | `number \| undefined`  |
+| `startAfter`   | `number \| undefined`  |
+| `verbose`      | `boolean \| undefined` |
+| `pname`        | `string \| undefined`  |
+| `cid`          | `string \| undefined`  |
+| `uid`          | `string \| undefined`  |
+| `record`       | `boolean \| undefined` |
+| `ticket`       | `boolean \| undefined` |
+
+Also there are next public fields on openSIPSJS instance:
+### Fields
+- `getActiveRooms: { [key: number]: IRoom }` - returns an object of active rooms where key is room id and value is room data
+- `sipDomain: String` - returns sip domain
+- `sipOptions: Object` - returns sip options
+- `getInputDeviceList: []` - returns list of input devices
+- `getOutputDeviceList: []` - returns list of output devices
+- `currentActiveRoomId: Number` - returns current active room id
+- `selectedInputDevice: String` - returns current selected input device id
+- `selectedOutputDevice: String` - returns current selected output device id
+- `isDND: Boolean` - returns if the agent is in "Do not disturb" status
+- `isMuted: Boolean` - returns if the agent is muted

package/build/enum/call.event.listener.type.d.ts

@@ -0,0 +1,7 @@
+export declare const CALL_EVENT_LISTENER_TYPE: {
+    NEW_CALL: string;
+    CALL_CONFIRMED: string;
+    CALL_FAILED: string;
+    CALL_PROGRESS: string;
+    CALL_ENDED: string;
+};

package/build/enum/call.event.listener.type.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CALL_EVENT_LISTENER_TYPE = void 0;
+exports.CALL_EVENT_LISTENER_TYPE = {
+    NEW_CALL: 'new_call',
+    CALL_CONFIRMED: 'confirmed',
+    CALL_FAILED: 'failed',
+    CALL_PROGRESS: 'progress',
+    CALL_ENDED: 'ended'
+};

package/build/enum/metric.keys.to.include.d.ts

@@ -0,0 +1,2 @@
+import { ProbeMetricInType } from '@/types/webrtcmetrics';
+export declare const METRIC_KEYS_TO_INCLUDE: (keyof ProbeMetricInType)[];

package/build/enum/metric.keys.to.include.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.METRIC_KEYS_TO_INCLUDE = void 0;
+exports.METRIC_KEYS_TO_INCLUDE = ['mos_in', 'codec_in', 'delta_KBytes_in', 'delta_kbs_in', 'delta_jitter_ms_in', 'delta_packets_lost_in'];

package/build/helpers/UA/index.d.ts

@@ -0,0 +1,6 @@
+import { UA } from 'jssip';
+import { CallOptionsExtended } from '@/types/rtc';
+import { RTCSession } from 'jssip/lib/RTCSession';
+export default class UAExtended extends UA {
+    call(target: string, options?: CallOptionsExtended): RTCSession;
+}

package/build/helpers/UA/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const jssip_1 = require("jssip");
+class UAExtended extends jssip_1.UA {
+    call(target, options) {
+        return super.call(target, options);
+    }
+}
+exports.default = UAExtended;

package/build/helpers/audio.helper.d.ts

@@ -0,0 +1,9 @@
+import { ICall, MediaEvent } from '@/types/rtc';
+import { Writeable } from '@/types/generic';
+type ICallKey = keyof ICall;
+declare const CALL_KEYS_TO_INCLUDE: Array<ICallKey>;
+export type ICallSimplified = Writeable<Pick<ICall, typeof CALL_KEYS_TO_INCLUDE[number]>>;
+export declare function simplifyCallObject(call: ICall): ICallSimplified;
+export declare function processAudioVolume(stream: MediaStream, volume: number): MediaStream;
+export declare function syncStream(event: MediaEvent, call: ICall, outputDevice: string, volume: number): void;
+export {};

package/build/helpers/audio.helper.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncStream = exports.processAudioVolume = exports.simplifyCallObject = void 0;
+const CALL_KEYS_TO_INCLUDE = [
+    'roomId',
+    '_audioMuted',
+    '_cancel_reason',
+    '_contact',
+    'direction',
+    '_end_time',
+    '_eventsCount',
+    '_from_tag',
+    '_id',
+    '_is_canceled',
+    '_is_confirmed',
+    '_late_sdp',
+    '_localHold',
+    '_videoMuted',
+    'status',
+    'start_time',
+    '_remote_identity',
+    'audioTag',
+    //'audioQuality',
+    'isOnHold',
+    //'originalStream',
+    'localMuted'
+];
+function simplifyCallObject(call) {
+    const simplified = {};
+    CALL_KEYS_TO_INCLUDE.forEach(key => {
+        if (call[key] !== undefined) {
+            simplified[key] = call[key];
+        }
+    });
+    simplified.localHold = call._localHold;
+    return simplified;
+}
+exports.simplifyCallObject = simplifyCallObject;
+function processAudioVolume(stream, volume) {
+    const audioContext = new AudioContext();
+    const audioSource = audioContext.createMediaStreamSource(stream);
+    const audioDestination = audioContext.createMediaStreamDestination();
+    const gainNode = audioContext.createGain();
+    audioSource.connect(gainNode);
+    gainNode.connect(audioDestination);
+    gainNode.gain.value = volume;
+    return audioDestination.stream;
+}
+exports.processAudioVolume = processAudioVolume;
+function syncStream(event, call, outputDevice, volume) {
+    const audio = document.createElement('audio');
+    audio.id = call._id;
+    audio.className = 'audioTag';
+    audio.srcObject = event.stream;
+    audio.setSinkId(outputDevice);
+    audio.volume = volume;
+    audio.play();
+    call.audioTag = audio;
+}
+exports.syncStream = syncStream;

package/build/helpers/filter.helper.d.ts

@@ -0,0 +1,2 @@
+import { ProbeMetricInType } from '@/types/webrtcmetrics';
+export declare function filterObjectKeys(fullObj: ProbeMetricInType, keys: Array<keyof ProbeMetricInType>): ProbeMetricInType;

package/build/helpers/filter.helper.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterObjectKeys = void 0;
+function filterObjectKeys(fullObj, keys) {
+    return Object.keys(fullObj)
+        .filter((key) => keys.includes(key))
+        .reduce((obj, key) => {
+        const k = key;
+        //const o = obj as ProbeMetricInType
+        //o[k] = fullObj[k] //as ProbeMetricInType[keyof ProbeMetricInType]
+        return Object.assign(Object.assign({}, obj), { [k]: fullObj[k] });
+    }, {});
+}
+exports.filterObjectKeys = filterObjectKeys;

package/build/helpers/time.helper.d.ts

@@ -0,0 +1,16 @@
+export interface ITimeData {
+    callId: string;
+    hours: number;
+    minutes: number;
+    seconds: number;
+    formatted: string;
+}
+export type TempTimeData = Omit<ITimeData, 'callId'> & {
+    callId: string | undefined;
+};
+export declare function setupTime(time: TempTimeData): {
+    seconds: number;
+    minutes: number;
+    hours: number;
+    formatted: string;
+};

package/build/helpers/time.helper.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupTime = void 0;
+function formatTime(time) {
+    return time < 10 ? `0${time}` : `${time}`;
+}
+function setupTime(time) {
+    let hours = time.hours || 0;
+    let minutes = time.minutes || 0;
+    let seconds = time.seconds || 0;
+    seconds++;
+    if (seconds === 60) {
+        seconds = 0;
+        minutes++;
+        if (minutes === 60) {
+            minutes = 0;
+            hours++;
+        }
+    }
+    const formatted = `${formatTime(hours)}:${formatTime(minutes)}:${formatTime(seconds)}`;
+    return {
+        seconds,
+        minutes,
+        hours,
+        formatted
+    };
+}
+exports.setupTime = setupTime;

package/build/helpers/volume.helper.d.ts

@@ -0,0 +1,2 @@
+export declare const runIndicator: (stream: MediaStream, deviceId: string) => void;
+export declare const clearVolumeInterval: () => void;

package/build/helpers/volume.helper.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearVolumeInterval = exports.runIndicator = void 0;
+const height = 20;
+const lineWidth = 4;
+let interval = undefined;
+const runIndicator = (stream, deviceId) => {
+    if (stream && stream.getTracks().length) {
+        //console.log('RUN INDICATOR IF')
+        getVolumeLevelBar(stream, deviceId);
+    }
+    else {
+        //console.log('RUN INDICATOR ELSE')
+        (0, exports.clearVolumeInterval)();
+    }
+};
+exports.runIndicator = runIndicator;
+const clearVolumeInterval = () => {
+    clearInterval(interval);
+};
+exports.clearVolumeInterval = clearVolumeInterval;
+const getMaxSmallIndicatorHeight = (value) => {
+    const halfLineHeight = height / 4;
+    return value < halfLineHeight ? value : halfLineHeight;
+};
+const getVolumeLevelBar = (stream, deviceId) => {
+    //console.log('IN GET VOLUME LEVEL BAR')
+    //console.log('TRACKS LENGTH', stream.getTracks().length)
+    clearInterval(interval);
+    const audioContext = new AudioContext();
+    const analyser = audioContext.createAnalyser();
+    const microphone = audioContext.createMediaStreamSource(stream);
+    const javascriptNode = audioContext.createScriptProcessor(2048, 1, 1);
+    analyser.smoothingTimeConstant = 0.8;
+    analyser.fftSize = 1024;
+    microphone.connect(analyser);
+    analyser.connect(javascriptNode);
+    javascriptNode.connect(audioContext.destination);
+    const canvas = document.getElementById(`canvas-${deviceId}`);
+    if (!canvas) {
+        return;
+    }
+    const indicatorWidth = lineWidth * 5;
+    const halfLineHeight = height / 2;
+    canvas.setAttribute('width', `${indicatorWidth}`);
+    canvas.setAttribute('height', `${height}`);
+    const canvasContext = canvas.getContext('2d');
+    interval = setInterval(() => {
+        if (!canvasContext) {
+            return;
+        }
+        const array = new Uint8Array(analyser.frequencyBinCount);
+        analyser.getByteFrequencyData(array);
+        let values = 0;
+        const length = array.length;
+        for (let i = 0; i < length; i++) {
+            values += (array[i]);
+        }
+        const average = values / length;
+        //console.log('average', average)
+        canvasContext.fillStyle = 'blue'; //getComputedStyle(document.body).getPropertyValue('--primary-actions')
+        const halfValue = average / 2;
+        canvasContext.clearRect(0, halfLineHeight, lineWidth, halfLineHeight);
+        canvasContext.fillRect(0, halfLineHeight, lineWidth, getMaxSmallIndicatorHeight(halfValue));
+        canvasContext.clearRect(0, halfLineHeight, lineWidth, -halfLineHeight);
+        canvasContext.fillRect(0, halfLineHeight, lineWidth, 0 - getMaxSmallIndicatorHeight(halfValue));
+        canvasContext.clearRect(lineWidth * 2, halfLineHeight, lineWidth, halfLineHeight);
+        canvasContext.fillRect(lineWidth * 2, halfLineHeight, lineWidth, average);
+        canvasContext.clearRect(lineWidth * 2, halfLineHeight, lineWidth, -halfLineHeight);
+        canvasContext.fillRect(lineWidth * 2, halfLineHeight, lineWidth, 0 - average);
+        canvasContext.clearRect(lineWidth * 4, halfLineHeight, lineWidth, halfLineHeight);
+        canvasContext.fillRect(lineWidth * 4, halfLineHeight, lineWidth, getMaxSmallIndicatorHeight(halfValue));
+        canvasContext.clearRect(lineWidth * 4, halfLineHeight, lineWidth, -halfLineHeight);
+        canvasContext.fillRect(lineWidth * 4, halfLineHeight, lineWidth, 0 - getMaxSmallIndicatorHeight(halfValue));
+    }, 200);
+};

package/build/helpers/webrtcmetrics/collector.d.ts

@@ -0,0 +1,32 @@
+export default class Collector {
+    constructor(cfg: any, refProbeId: any);
+    _callbacks: {
+        onreport: null;
+        onticket: null;
+    };
+    _id: string;
+    _moduleName: string;
+    _probeId: any;
+    _config: any;
+    _exporter: Exporter;
+    _state: string;
+    analyze(stats: any, previousReport: any, beforeLastReport: any, referenceReport: any): any;
+    takeReferenceStats(): Promise<any>;
+    collectStats(): Promise<any>;
+    start(): Promise<void>;
+    set state(arg: string);
+    get state(): string;
+    _startedTime: Date | undefined;
+    mute(): Promise<void>;
+    unmute(): Promise<void>;
+    stop(forced: any): Promise<void>;
+    _stoppedTime: Date | undefined;
+    registerCallback(name: any, callback: any, context: any): void;
+    unregisterCallback(name: any): void;
+    fireOnReport(report: any): void;
+    fireOnTicket(ticket: any): void;
+    updateConfig(config: any): void;
+    addCustomEvent(at: any, category: any, name: any, description: any): void;
+    registerToPCEvents(): Promise<void>;
+}
+import Exporter from "./exporter";

package/build/helpers/webrtcmetrics/collector.js

@@ -0,0 +1,282 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const exporter_1 = __importDefault(require("./exporter"));
+const extractor_1 = require("./extractor");
+const score_1 = require("./utils/score");
+const models_1 = require("./utils/models");
+const helper_1 = require("./utils/helper");
+const log_1 = require("./utils/log");
+class Collector {
+    constructor(cfg, refProbeId) {
+        this._callbacks = {
+            onreport: null,
+            onticket: null,
+        };
+        this._id = (0, helper_1.createCollectorId)();
+        this._moduleName = this._id;
+        this._probeId = refProbeId;
+        this._config = cfg;
+        this._exporter = new exporter_1.default(cfg);
+        this._state = models_1.COLLECTOR_STATE.IDLE;
+        this.registerToPCEvents();
+        (0, log_1.info)(this._moduleName, `new collector created for probe ${this._probeId}`);
+    }
+    analyze(stats, previousReport, beforeLastReport, referenceReport) {
+        const getDefaultSSRCMetric = (kind, reportType) => {
+            if (kind === models_1.VALUE.AUDIO) {
+                if (reportType === models_1.TYPE.INBOUND_RTP) {
+                    return Object.assign({}, models_1.defaultAudioMetricIn);
+                }
+                return Object.assign({}, models_1.defaultAudioMetricOut);
+            }
+            if (reportType === models_1.TYPE.INBOUND_RTP) {
+                return Object.assign({}, models_1.defaultVideoMetricIn);
+            }
+            return Object.assign({}, models_1.defaultVideoMetricOut);
+        };
+        const report = (0, models_1.getDefaultMetric)(previousReport);
+        report.pname = this._config.pname;
+        report.call_id = this._config.cid;
+        report.user_id = this._config.uid;
+        report.count = previousReport ? previousReport.count + 1 : 1;
+        let timestamp = null;
+        stats.forEach((stat) => {
+            if (!timestamp && stat.timestamp) {
+                timestamp = stat.timestamp;
+            }
+            const values = (0, extractor_1.extract)(stat, report, report.pname, referenceReport);
+            values.forEach((data) => {
+                if (data.value && data.type) {
+                    if (data.ssrc) {
+                        let ssrcReport = report[data.type][data.ssrc];
+                        if (!ssrcReport) {
+                            ssrcReport = getDefaultSSRCMetric(data.type, stat.type);
+                            ssrcReport.ssrc = data.ssrc;
+                            report[data.type][data.ssrc] = (ssrcReport);
+                        }
+                        Object.keys(data.value).forEach((key) => {
+                            ssrcReport[key] = data.value[key];
+                        });
+                    }
+                    else {
+                        Object.keys(data.value).forEach((key) => {
+                            report[data.type][key] = data.value[key];
+                        });
+                    }
+                }
+            });
+        });
+        report.timestamp = timestamp;
+        Object.keys(report[models_1.VALUE.AUDIO]).forEach((key) => {
+            const ssrcReport = report[models_1.VALUE.AUDIO][key];
+            if (ssrcReport.direction === models_1.DIRECTION.INBOUND) {
+                ssrcReport.mos_emodel_in = (0, score_1.computeEModelMOS)(report, models_1.VALUE.AUDIO, previousReport, beforeLastReport, ssrcReport.ssrc);
+                ssrcReport.mos_in = (0, score_1.computeMOS)(report, models_1.VALUE.AUDIO, previousReport, beforeLastReport, ssrcReport.ssrc);
+            }
+            else {
+                ssrcReport.mos_emodel_out = (0, score_1.computeEModelMOSForOutgoing)(report, models_1.VALUE.AUDIO, previousReport, beforeLastReport, ssrcReport.ssrc);
+                ssrcReport.mos_out = (0, score_1.computeMOSForOutgoing)(report, models_1.VALUE.AUDIO, previousReport, beforeLastReport, ssrcReport.ssrc);
+            }
+        });
+        return report;
+    }
+    takeReferenceStats() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const preWaitTime = Date.now();
+                setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        const waitTime = Date.now() - preWaitTime;
+                        const preTime = Date.now();
+                        const reports = yield this._config.pc.getStats();
+                        const referenceReport = this.analyze(reports, null, null, null);
+                        const postTime = Date.now();
+                        referenceReport.experimental.time_to_measure_ms = postTime - preTime;
+                        referenceReport.experimental.time_to_wait_ms = waitTime;
+                        this._exporter.saveReferenceReport(referenceReport);
+                        (0, log_1.debug)(this._moduleName, `got reference report for probe ${this._probeId}`);
+                        resolve();
+                    }
+                    catch (err) {
+                        reject(err);
+                    }
+                }), this._config.startAfter);
+            });
+        });
+    }
+    collectStats() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (this._state !== models_1.COLLECTOR_STATE.RUNNING || !this._config.pc) {
+                    (0, log_1.debug)(this._moduleName, `report discarded (too late) for probe ${this._probeId}`);
+                    return null;
+                }
+                // Take into account last report in case no report have been generated (eg: candidate-pair)
+                const preTime = Date.now();
+                const reports = yield this._config.pc.getStats();
+                const report = this.analyze(reports, this._exporter.getLastReport(), this._exporter.getBeforeLastReport(), this._exporter.getReferenceReport());
+                const postTime = Date.now();
+                report.experimental.time_to_measure_ms = postTime - preTime;
+                this._exporter.addReport(report);
+                (0, log_1.debug)(this._moduleName, `got report for probe ${this._probeId}#${this._exporter.getReportsNumber() + 1}`);
+                this.fireOnReport(report);
+                return report;
+            }
+            catch (err) {
+                (0, log_1.error)(this._moduleName, `got error ${err}`);
+                return null;
+            }
+        });
+    }
+    start() {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, log_1.debug)(this._moduleName, "starting");
+            this.state = models_1.COLLECTOR_STATE.RUNNING;
+            this._startedTime = this._exporter.start();
+            (0, log_1.debug)(this._moduleName, "started");
+        });
+    }
+    mute() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.state = models_1.COLLECTOR_STATE.MUTED;
+            (0, log_1.debug)(this._moduleName, "muted");
+        });
+    }
+    unmute() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.state = models_1.COLLECTOR_STATE.RUNNING;
+            (0, log_1.debug)(this._moduleName, "unmuted");
+        });
+    }
+    stop(forced) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, log_1.debug)(this._moduleName, `stopping${forced ? " by watchdog" : ""}...`);
+            this._stoppedTime = this._exporter.stop();
+            this.state = models_1.COLLECTOR_STATE.IDLE;
+            if (this._config.ticket) {
+                const { ticket } = this._exporter;
+                this.fireOnTicket(ticket);
+            }
+            this._exporter.reset();
+            (0, log_1.debug)(this._moduleName, "stopped");
+        });
+    }
+    registerCallback(name, callback, context) {
+        if (name in this._callbacks) {
+            this._callbacks[name] = {
+                callback,
+                context,
+            };
+            (0, log_1.debug)(this._moduleName, `registered callback '${name}'`);
+        }
+        else {
+            (0, log_1.error)(this._moduleName, `can't register callback for '${name}' - not found`);
+        }
+    }
+    unregisterCallback(name) {
+        if (name in this._callbacks) {
+            this._callbacks[name] = null;
+            delete this._callbacks[name];
+            (0, log_1.debug)(this._moduleName, `unregistered callback '${name}'`);
+        }
+        else {
+            (0, log_1.error)(this._moduleName, `can't unregister callback for '${name}' - not found`);
+        }
+    }
+    fireOnReport(report) {
+        if (this._callbacks.onreport) {
+            (0, helper_1.call)(this._callbacks.onreport.callback, this._callbacks.onreport.context, report);
+        }
+    }
+    fireOnTicket(ticket) {
+        if (this._callbacks.onticket) {
+            (0, helper_1.call)(this._callbacks.onticket.callback, this._callbacks.onticket.context, ticket);
+        }
+    }
+    updateConfig(config) {
+        this._config = config;
+        this._exporter.updateConfig(config);
+    }
+    get state() {
+        return this._state;
+    }
+    set state(newState) {
+        this._state = newState;
+        (0, log_1.debug)(this._moduleName, `state changed to ${newState}`);
+    }
+    addCustomEvent(at, category, name, description) {
+        this._exporter.addCustomEvent({
+            at: typeof at === "object" ? at.toJSON() : at,
+            category,
+            name,
+            description,
+        });
+    }
+    registerToPCEvents() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { pc } = this._config;
+            navigator.mediaDevices.ondevicechange = () => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const devices = yield navigator.mediaDevices.enumerateDevices();
+                    this.addCustomEvent(new Date().toJSON(), "device", `${devices.length} devices found`, "Media Devices state");
+                    // eslint-disable-next-line no-empty
+                }
+                catch (err) {
+                    (0, log_1.error)(this._moduleName, "can't get devices");
+                }
+            });
+            if (pc) {
+                pc.oniceconnectionstatechange = () => {
+                    const value = pc.iceConnectionState;
+                    if (value === models_1.ICE_CONNECTION_STATE.CONNECTED ||
+                        value === models_1.ICE_CONNECTION_STATE.COMPLETED) {
+                        this.addCustomEvent(new Date().toJSON(), "call", value, "ICE connection state");
+                    }
+                    else if (value === models_1.ICE_CONNECTION_STATE.DISCONNECTED ||
+                        value === models_1.ICE_CONNECTION_STATE.FAILED) {
+                        this.addCustomEvent(new Date().toJSON(), "call", value, "ICE connection state");
+                    }
+                    else if (value === models_1.ICE_CONNECTION_STATE.CLOSED) {
+                        this.addCustomEvent(new Date().toJSON(), "call", "ended", "ICE connection state");
+                    }
+                };
+                pc.onicegatheringstatechange = () => {
+                    const value = pc.iceGatheringState;
+                    this.addCustomEvent(new Date().toJSON(), "call", value, "ICE gathering state");
+                };
+                pc.ontrack = (e) => {
+                    this.addCustomEvent(new Date().toJSON(), "call", `${e.track.kind}track`, "MediaStreamTrack received");
+                };
+                pc.onnegotiationneeded = () => {
+                    this.addCustomEvent(new Date().toJSON(), "call", "negotiation", "Media changed");
+                };
+                const receivers = pc.getReceivers();
+                if (receivers && receivers.length > 0) {
+                    const receiver = receivers[0];
+                    const { transport } = receiver;
+                    if (transport) {
+                        const { iceTransport } = transport;
+                        if (iceTransport) {
+                            iceTransport.onselectedcandidatepairchange = () => {
+                                this.addCustomEvent(new Date().toJSON(), "call", "transport", "Candidates Pair changed");
+                            };
+                        }
+                    }
+                }
+            }
+        });
+    }
+}
+exports.default = Collector;