camstreamerlib 4.0.0-beta.1 → 4.0.0-beta.3

package/README.md

@@ -2,6 +2,8 @@
 
 **This is beta version of CamStreamerLib v4, dont use it on production. Is going to be changed significantly.**
 
+**The documentation is in progress**
+
 Node.js helper library for CamStreamer ACAP applications.
 
 The library is primarily developed for the CamScripter ACAP application running directly in Axis cameras.
@@ -17,7 +19,7 @@ npm install camstreamerlib
 
 -   [HttpServer](doc/HttpServer.md) is a module for processing HTTP requests in your scripts. It also automatically serves up the content from html directory or you can register paths which you can process by your own (e.g. http://$CAMERA_IP/local/camscripter/proxy/$MY_PACKAGE_NAME/control.cgi).
 
--   [CameraVapix](doc/CameraVapix.md) is a module to access Axis camera VAPIX interface.
+-   [VapixAPI](doc/VapixAPI.md) is a module to access Axis camera VAPIX interface.
 
 -   [CamStreamerAPI](doc/CamStreamerAPI.md) is a module for easy control of video streaming in the CamStreamer ACAP application (RTMP, HLS, SRT and MPEG-TS protocols).
 

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,232 @@
+"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 (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;