camstreamerlib 4.0.0-beta.2 → 4.0.0-beta.4

package/cjs/CamOverlayAPI.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CamOverlayAPI = void 0;
+const common_1 = require("./internal/common");
+const DefaultClient_1 = require("./node/DefaultClient");
+const CamOverlayAPI_1 = require("./types/CamOverlayAPI");
+const errors_1 = require("./errors/errors");
+const common_2 = require("./types/common");
+class CamOverlayAPI {
+    client;
+    constructor(options = {}) {
+        if ((0, common_1.isClient)(options)) {
+            this.client = options;
+        }
+        else {
+            this.client = new DefaultClient_1.DefaultClient(options);
+        }
+    }
+    async checkCameraTime() {
+        const cameraTime = await this.get('/local/camoverlay/api/camera_time.cgi');
+        return cameraTime.state;
+    }
+    async getNetworkCameraList() {
+        const response = await this.get('/local/camoverlay/api/network_camera_list.cgi');
+        return common_2.networkCameraListSchema.parse(response.camera_list);
+    }
+    async wsAutoratization() {
+        const response = await this.get(`/local/camoverlay/api/ws_authorization.cgi`);
+        return response.data;
+    }
+    async getMjpegStreamImage(mjpegUrl) {
+        const res = await this.get(`/local/camoverlay/api/fetch_mjpeg_image.cgi?mjpeg_url=${encodeURIComponent(decodeURIComponent(mjpegUrl))}`);
+        return await this.parseBlobResponse(res);
+    }
+    async listFiles(fileType) {
+        const files = await this.get(`/local/camoverlay/api/upload_${fileType}.cgi?action=list`);
+        return CamOverlayAPI_1.fileListSchema.parse(files.list);
+    }
+    async uploadFile(fileType, file, fileName) {
+        const formData = new FormData();
+        formData.append('target', 'SD0');
+        formData.append('uploadedFile[]', file, fileName);
+        const path = `/local/camoverlay/api/upload_${fileType}.cgi?action=upload`;
+        await this.post(path, formData);
+    }
+    async removeFile(fileType, file) {
+        const path = `/local/camoverlay/api/upload_${fileType}.cgi?action=remove`;
+        await this.post(path, JSON.stringify(file));
+    }
+    async getFileStorage(fileType) {
+        const data = await this.get(`/local/camoverlay/api/upload_${fileType}.cgi?action=get_storage`);
+        return CamOverlayAPI_1.storageSchema.parse(data);
+    }
+    async updateInfoticker(serviceID, text) {
+        await this.get(`/local/camoverlay/api/infoticker.cgi?service_id=${serviceID}&text=${text}`);
+    }
+    async setEnabled(serviceID, enabled) {
+        await this.post(`/local/camoverlay/api/enabled.cgi?id_${serviceID}=${enabled ? 1 : 0}`, '');
+    }
+    async isEnabled(serviceID) {
+        const res = await this.client.get('/local/camoverlay/api/services.cgi?action=get');
+        if (res.ok) {
+            const data = JSON.parse(await res.text());
+            for (const service of data.services) {
+                if (service.id === serviceID) {
+                    return service.enabled === 1;
+                }
+            }
+            throw new errors_1.ServiceNotFoundError();
+        }
+        else {
+            throw new Error(await (0, common_1.responseStringify)(res));
+        }
+    }
+    async getSingleService(serviceId) {
+        const data = await this.get('/local/camoverlay/api/services.cgi', {
+            action: 'get',
+            service_id: serviceId.toString(),
+        });
+        return CamOverlayAPI_1.serviceSchema.parse(data);
+    }
+    async getServices() {
+        const serviceList = await this.get('/local/camoverlay/api/services.cgi?action=get');
+        return CamOverlayAPI_1.serviceSchema.parse(serviceList).services;
+    }
+    async updateSingleService(serviceId, serviceJson) {
+        const path = '/local/camoverlay/api/services.cgi';
+        await this.post(path, JSON.stringify(serviceJson), {
+            action: 'set',
+            service_id: serviceId.toString(),
+        });
+    }
+    async updateServices(servicesJson) {
+        const path = '/local/camoverlay/api/services.cgi?action=set';
+        await this.post(path, JSON.stringify(servicesJson));
+    }
+    updateCGText(serviceID, fields) {
+        const params = {};
+        for (const field of fields) {
+            const name = field.field_name;
+            params[name] = field.text;
+            if (field.color !== undefined) {
+                params[`${name}_color`] = field.color;
+            }
+        }
+        return this.promiseCGUpdate(serviceID, 'update_text', params);
+    }
+    updateCGImagePos(serviceID, coordinates = '', x = 0, y = 0) {
+        const params = {
+            coord_system: coordinates,
+            pos_x: x,
+            pos_y: y,
+        };
+        return this.promiseCGUpdate(serviceID, 'update_image', params);
+    }
+    updateCGImage(serviceID, path, coordinates = '', x = 0, y = 0) {
+        const params = {
+            coord_system: coordinates,
+            pos_x: x,
+            pos_y: y,
+            image: path,
+        };
+        return this.promiseCGUpdate(serviceID, 'update_image', params);
+    }
+    updateCGImageFromData(serviceID, imageType, imageData, coordinates = '', x = 0, y = 0) {
+        const contentType = imageType === CamOverlayAPI_1.ImageType.PNG ? 'image/png' : 'image/jpeg';
+        const params = {
+            coord_system: coordinates,
+            pos_x: x,
+            pos_y: y,
+        };
+        return this.promiseCGUpdate(serviceID, 'update_image', params, contentType, imageData);
+    }
+    async promiseCGUpdate(serviceID, action, params = {}, contentType, data) {
+        const path = `/local/camoverlay/api/customGraphics.cgi`;
+        let headers = {};
+        if (contentType !== undefined && data) {
+            headers = { 'Content-Type': contentType };
+        }
+        const res = await this.client.post(path, data ?? '', {
+            action: action,
+            service_id: serviceID.toString(),
+            ...params,
+        }, headers);
+        if (!res.ok) {
+            throw new Error(await (0, common_1.responseStringify)(res));
+        }
+    }
+    async get(path, params) {
+        const res = await this.client.get(path, params);
+        if (res.ok) {
+            return await res.json();
+        }
+        else {
+            throw new Error(await (0, common_1.responseStringify)(res));
+        }
+    }
+    async post(path, data, params) {
+        const res = await this.client.post(path, data, params);
+        if (res.ok) {
+            return await res.json();
+        }
+        else {
+            throw new Error(await (0, common_1.responseStringify)(res));
+        }
+    }
+    async parseBlobResponse(response) {
+        try {
+            return await response.blob();
+        }
+        catch (err) {
+            throw new errors_1.ParsingBlobError(err);
+        }
+    }
+}
+exports.CamOverlayAPI = CamOverlayAPI;

package/cjs/CamOverlayDrawingAPI.js

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CamOverlayDrawingAPI = void 0;
+const EventEmitter = require("events");
+const WsClient_1 = require("./node/WsClient");
+class CamOverlayDrawingAPI extends EventEmitter {
+    tls;
+    tlsInsecure;
+    ip;
+    port;
+    user;
+    pass;
+    cameraList;
+    zIndex;
+    callId;
+    sendMessages;
+    timeoutCheckTimer;
+    wsConnected;
+    ws;
+    constructor(options) {
+        super();
+        this.tls = options?.tls ?? false;
+        this.tlsInsecure = options?.tlsInsecure ?? false;
+        this.ip = options?.ip ?? '127.0.0.1';
+        this.port = options?.port ?? (this.tls ? 443 : 80);
+        this.user = options?.user ?? '';
+        this.pass = options?.pass ?? '';
+        this.zIndex = options?.zIndex ?? 0;
+        this.cameraList = [0];
+        if (options && Array.isArray(options.camera)) {
+            this.cameraList = options.camera;
+        }
+        else if (typeof options?.camera === 'number') {
+            this.cameraList = [options.camera];
+        }
+        this.callId = 0;
+        this.sendMessages = {};
+        this.wsConnected = false;
+        this.createWsClient();
+        EventEmitter.call(this);
+    }
+    connect() {
+        this.ws.open();
+        this.startMsgsTimeoutCheck();
+    }
+    disconnect() {
+        this.ws.close();
+        this.stopMsgsTimeoutCheck();
+    }
+    isConnected() {
+        return this.wsConnected;
+    }
+    cairo(command, ...params) {
+        return this.sendMessage({ command: command, params: params });
+    }
+    writeText(...params) {
+        return this.sendMessage({ command: 'write_text', params: params });
+    }
+    uploadImageData(imgBuffer) {
+        return this.sendBinaryMessage({
+            command: 'upload_image_data',
+            params: [],
+        }, imgBuffer);
+    }
+    uploadFontData(fontBuffer) {
+        return this.sendBinaryMessage({
+            command: 'upload_font_data',
+            params: [fontBuffer.toString('base64')],
+        }, fontBuffer);
+    }
+    showCairoImage(cairoImage, posX, posY) {
+        return this.sendMessage({
+            command: 'show_cairo_image_v2',
+            params: [cairoImage, posX, posY, this.cameraList, this.zIndex],
+        });
+    }
+    showCairoImageAbsolute(cairoImage, posX, posY, width, height) {
+        return this.sendMessage({
+            command: 'show_cairo_image_v2',
+            params: [
+                cairoImage,
+                -1.0 + (2.0 / width) * posX,
+                -1.0 + (2.0 / height) * posY,
+                this.cameraList,
+                this.zIndex,
+            ],
+        });
+    }
+    removeImage() {
+        return this.sendMessage({ command: 'remove_image_v2', params: [] });
+    }
+    createWsClient() {
+        const options = {
+            ip: this.ip,
+            port: this.port,
+            address: '/local/camoverlay/ws',
+            protocol: 'cairo-api',
+            user: this.user,
+            pass: this.pass,
+            tls: this.tls,
+            tlsInsecure: this.tlsInsecure,
+        };
+        this.ws = new WsClient_1.WsClient(options);
+        this.ws.on('open', () => {
+            console.log('CamOverlay connection opened');
+            this.wsConnected = true;
+            this.emit('open');
+        });
+        this.ws.on('message', (msgData) => this.incomingWsMessageHandler(msgData));
+        this.ws.on('error', (error) => {
+            this.reportError(error);
+        });
+        this.ws.on('close', () => {
+            console.log('CamOverlay connection closed');
+            this.wsConnected = false;
+            this.reportClose();
+        });
+    }
+    incomingWsMessageHandler(msgData) {
+        const dataJSON = JSON.parse(msgData.toString());
+        let errorResponse;
+        if ('error' in dataJSON) {
+            errorResponse = dataJSON;
+        }
+        if (dataJSON.call_id !== undefined) {
+            if (errorResponse !== undefined) {
+                this.sendMessages[dataJSON.call_id]?.reject(new Error(errorResponse.error));
+            }
+            else {
+                this.sendMessages[dataJSON.call_id]?.resolve(dataJSON);
+            }
+            delete this.sendMessages[dataJSON.call_id];
+        }
+        if (errorResponse !== undefined) {
+            this.reconnectWithError(new Error(errorResponse.error));
+        }
+        else {
+            this.reportMessage(msgData.toString());
+        }
+    }
+    sendMessage(msgJson) {
+        return new Promise((resolve, reject) => {
+            try {
+                if (!this.wsConnected) {
+                    throw new Error('No CamOverlay connection');
+                }
+                msgJson.call_id = ++this.callId;
+                this.ws.send(JSON.stringify(msgJson));
+                this.sendMessages[this.callId] = { resolve, reject, sentTimestamp: Date.now() };
+            }
+            catch (err) {
+                const errorMessage = err instanceof Error ? err.message : 'Unknown error';
+                const error = new Error(`Send message error: ${errorMessage}`);
+                reject(error);
+                if (!this.wsConnected) {
+                    this.reportError(error);
+                }
+                else {
+                    this.reconnectWithError(error);
+                }
+            }
+        });
+    }
+    sendBinaryMessage(msgJson, data) {
+        return new Promise((resolve, reject) => {
+            try {
+                if (!this.wsConnected) {
+                    throw new Error('No CamOverlay connection');
+                }
+                msgJson.call_id = ++this.callId;
+                const jsonBuffer = Buffer.from(JSON.stringify(msgJson));
+                const header = new ArrayBuffer(5);
+                const headerView = new DataView(header);
+                headerView.setInt8(0, 1);
+                headerView.setInt32(1, jsonBuffer.byteLength);
+                const msgBuffer = Buffer.concat([Buffer.from(header), jsonBuffer, data]);
+                this.ws.send(msgBuffer);
+                this.sendMessages[this.callId] = { resolve, reject, sentTimestamp: Date.now() };
+            }
+            catch (err) {
+                const errorMessage = err instanceof Error ? err.message : 'Unknown error';
+                const error = new Error(`Send binary message error: ${errorMessage}`);
+                reject(error);
+                if (!this.wsConnected) {
+                    this.reportError(error);
+                }
+                else {
+                    this.reconnectWithError(error);
+                }
+            }
+        });
+    }
+    startMsgsTimeoutCheck() {
+        clearInterval(this.timeoutCheckTimer);
+        this.timeoutCheckTimer = setInterval(() => {
+            let reconnect = false;
+            const now = Date.now();
+            for (const callId in this.sendMessages) {
+                const msg = this.sendMessages[callId];
+                if (!msg) {
+                    continue;
+                }
+                if (now - msg.sentTimestamp > 10000) {
+                    reconnect = true;
+                    msg.reject(new Error('Message timeout'));
+                    delete this.sendMessages[callId];
+                }
+            }
+            if (reconnect) {
+                this.reconnectWithError(new Error('Message timeout'));
+            }
+        }, 5000);
+    }
+    stopMsgsTimeoutCheck() {
+        clearInterval(this.timeoutCheckTimer);
+    }
+    reconnectWithError(err) {
+        this.reportError(err);
+        this.ws.reconnect();
+    }
+    reportMessage(msg) {
+        this.emit('message', msg);
+    }
+    reportError(err) {
+        this.emit('error', err);
+    }
+    reportClose() {
+        for (const callId in this.sendMessages) {
+            this.sendMessages[callId]?.reject(new Error('Connection lost'));
+        }
+        this.sendMessages = {};
+        this.emit('close');
+    }
+}
+exports.CamOverlayDrawingAPI = CamOverlayDrawingAPI;