camstreamerlib 1.3.1 → 1.6.0

package/.github/workflows/github-ci.yml

@@ -0,0 +1,46 @@
+# This is a basic workflow to help you get started with Actions
+
+name: CI
+
+# Controls when the workflow will run
+on:
+  # Triggers the workflow on push or pull request events but only for the main branch
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+# A workflow run is made up of one or more jobs that can run sequentially or in parallel
+jobs:
+  # This workflow contains a single job called "build"
+  build:
+    # The type of runner that the job will run on
+    runs-on: ubuntu-latest
+
+    # Steps represent a sequence of tasks that will be executed as part of the job
+    steps:
+      # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
+      - uses: actions/checkout@v2
+
+      - uses: actions/setup-node@v2
+        with:
+          node-version: '16.x'
+          registry-url: 'https://registry.npmjs.org'
+
+      # Runs a single command using the runners shell
+      - name: Init
+        run: |
+          npm install --production=false
+      # Runs 
+      - name: Transpilation
+        run: npm run build
+      # Runs 
+      - name: Automatic test (using Jest library)
+        run: npm run test
+      # Runs a set of commands using the runners shell
+      - name: Prettier Check
+        run: npm run pretty:check
+      

package/jest.config.js

@@ -0,0 +1,11 @@
+/** @type {import('ts-jest/dist/types').InitialOptionsTsJest} */
+module.exports = {
+    preset: 'ts-jest',
+    testEnvironment: 'node',
+    testMatch: ['**/?(*.)+(test).[jt]s?(x)'],
+    moduleDirectories: ['node_modules', 'src', 'test'],
+    transform: {
+        '^.+\\.ts?$': 'ts-jest',
+    },
+    transformIgnorePatterns: ['/node_modules/'],
+};

package/package.json

@@ -1,18 +1,35 @@
 {
   "name": "camstreamerlib",
-  "version": "1.3.1",
+  "version": "1.6.0",
   "description": "Helper library for CamStreamer ACAP applications.",
+  "prettier": "@camstreamer/prettier-config",
   "main": "CameraVapix.js",
   "dependencies": {
     "crypto": "^1.0.1",
     "eventemitter2": "^5.0.1",
     "prettify-xml": "^1.2.0",
+    "typescript": "^4.7.4",
     "ws": "^7.4.2",
     "xml2js": "^0.4.19"
   },
-  "devDependencies": {},
+  "devDependencies": {
+    "@camstreamer/prettier-config": "^2.0.4",
+    "@types/jest": "^28.0.0",
+    "@types/node": "^18.0.6",
+    "ts-jest": "^28.0.0",
+    "ts-node": "^10.7.0",
+    "jest": "^28.1.3",
+    "npm-run-all": "^4.1.5",
+    "prettier": "^2.7.1",
+    "rimraf": "^3.0.2"
+  },
   "scripts": {
-    "test": "echo \"Error: no test specified\""
+    "clean": "rimraf dist/*",
+    "build": "npm-run-all clean tsc",
+    "tsc": "tsc",
+    "pretty": "prettier --write \"./src/*.{ts,tsx}\"",
+    "pretty:check": "prettier --check \"./src/*.{ts,tsx}\"",
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js"
   },
   "repository": {
     "type": "git",

package/src/CamOverlayAPI.ts

@@ -0,0 +1,370 @@
+import * as WebSocket from 'ws';
+import * as EventEmitter from 'events';
+
+import { Digest } from './Digest';
+import { httpRequest } from './HTTPRequest';
+
+export type CamOverlayOptions = {
+    protocol: string;
+    ip: string;
+    port: number;
+    auth: string;
+    serviceName: string;
+    serviceID: number;
+    camera: number;
+};
+
+export type Field = {
+    field_name: string;
+    text: string;
+    color?: string;
+};
+
+type Service = {
+    id: number;
+    enabled: number;
+    schedule: string;
+    name: string;
+    identifier: string;
+    camera: number;
+};
+
+type ServiceJson = {
+    services: Service[];
+};
+
+type AsyncMessage = {
+    resolve;
+    reject;
+};
+
+export class CamOverlayAPI extends EventEmitter {
+    private protocol: string;
+    private ip: string;
+    private port: number;
+    private auth: string;
+    private serviceName: string;
+    private serviceID: number;
+    private camera: number;
+    private callId: number;
+    private sendMessages: Record<number, AsyncMessage>;
+
+    private ws: WebSocket = null;
+
+    constructor(options?: CamOverlayOptions) {
+        super();
+
+        this.protocol = options?.protocol ?? 'ws';
+        this.ip = options?.ip ?? '127.0.0.1';
+        this.port = options?.port ?? this.protocol == 'ws' ? 80 : 443;
+        this.auth = options?.auth ?? '';
+        this.serviceName = options?.serviceName ?? '';
+        this.serviceID = options?.serviceID ?? -1; // If service is already created you can skip creation step by filling this parameter
+        this.camera = options?.camera ?? 0;
+
+        this.callId = 0;
+        this.sendMessages = {};
+
+        EventEmitter.call(this);
+    }
+
+    async connect() {
+        if (this.serviceID != -1) {
+            await this.openWebsocket();
+        } else {
+            try {
+                let id = await this.createService();
+                this.serviceID = id;
+                await this.openWebsocket();
+            } catch (err) {
+                this.reportErr(err);
+            }
+        }
+    }
+
+    async createService() {
+        const options = {
+            host: this.ip,
+            port: this.port,
+            path: '/local/camoverlay/api/services.cgi?action=get',
+            auth: this.auth,
+        };
+        const response = (await httpRequest(options)) as string;
+        let servicesJson: ServiceJson;
+        try {
+            servicesJson = JSON.parse(response);
+            servicesJson.services ??= [];
+        } catch {
+            servicesJson = { services: [] };
+        }
+
+        // Find service
+        let service: Service = null;
+        let maxID = -1;
+        let servicesArr = servicesJson.services;
+        for (let s of servicesArr) {
+            if (s.id > maxID) {
+                maxID = s.id;
+            }
+            if (s.identifier == this.serviceName && s.name == 'scripter') {
+                service = s;
+                break;
+            }
+        }
+
+        if (service != null) {
+            if (service.enabled == 1) {
+                // Check and update service parameters if necessary
+                if (service.camera == undefined || service.camera != this.camera) {
+                    service.camera = this.camera;
+                    await this.updateServices(servicesJson);
+                    return service.id as number;
+                } else {
+                    return service.id as number;
+                }
+            } else {
+                throw new Error('CamOverlay service is not enabled');
+            }
+        } else {
+            // Create new service
+            let newServiceID = maxID + 1;
+            service = {
+                id: newServiceID,
+                enabled: 1,
+                schedule: '',
+                name: 'scripter',
+                identifier: this.serviceName,
+                camera: this.camera,
+            };
+            servicesJson.services.push(service);
+            await this.updateServices(servicesJson);
+            return newServiceID;
+        }
+    }
+
+    async updateServices(servicesJson: ServiceJson) {
+        const options = {
+            method: 'POST',
+            host: this.ip,
+            port: this.port,
+            path: '/local/camoverlay/api/services.cgi?action=set',
+            auth: this.auth,
+        };
+        await httpRequest(options, JSON.stringify(servicesJson));
+    }
+
+    openWebsocket(digestHeader?: string) {
+        let promise = new Promise<void>((resolve, reject) => {
+            let userPass = this.auth.split(':');
+            let addr = `${this.protocol}://${this.ip}:${this.port}/local/camoverlay/ws`;
+
+            let options = {
+                auth: this.auth,
+                headers: {},
+            };
+            if (digestHeader != undefined) {
+                options.headers['Authorization'] = Digest.getAuthHeader(
+                    userPass[0],
+                    userPass[1],
+                    'GET',
+                    '/local/camoverlay/ws',
+                    digestHeader
+                );
+            }
+
+            this.ws = new WebSocket(addr, 'cairo-api', options);
+            this.ws.on('open', () => {
+                this.reportMsg('Websocket opened');
+                resolve();
+            });
+
+            this.ws.on('message', (data: string) => {
+                let dataJSON = JSON.parse(data);
+                if (dataJSON.hasOwnProperty('call_id') && dataJSON['call_id'] in this.sendMessages) {
+                    this.sendMessages[dataJSON['call_id']].resolve(dataJSON);
+                    delete this.sendMessages[dataJSON['call_id']];
+                }
+
+                if (dataJSON.hasOwnProperty('error')) {
+                    let error = new Error(JSON.stringify(data));
+                    this.reportErr(error);
+                } else {
+                    this.reportMsg(data);
+                }
+            });
+
+            this.ws.on('unexpected-response', async (req, res) => {
+                if (res.statusCode == 401 && res.headers['www-authenticate'] != undefined)
+                    this.openWebsocket(res.headers['www-authenticate']).then(resolve, reject);
+                else {
+                    reject('Error: status code: ' + res.statusCode + ', ' + res.data);
+                }
+            });
+
+            this.ws.on('error', (error: Error) => {
+                this.reportErr(error);
+                reject(error);
+            });
+
+            this.ws.on('close', () => {
+                this.reportClose();
+            });
+        });
+        return promise;
+    }
+
+    cairo(command: string, ...params) {
+        return this.sendMessage({ command: command, params: params });
+    }
+
+    writeText(...params) {
+        return this.sendMessage({ command: 'write_text', params: params });
+    }
+
+    uploadImageData(imgBuffer: Buffer) {
+        return this.sendMessage({ command: 'upload_image_data', params: [imgBuffer.toString('base64')] });
+    }
+
+    uploadFontData(fontBuffer: Buffer) {
+        return this.sendMessage({ command: 'upload_font_data', params: [fontBuffer.toString('base64')] });
+    }
+
+    showCairoImage(cairoImage, posX: number, posY: number) {
+        return this.sendMessage({ command: 'show_cairo_image', params: [this.serviceID, cairoImage, posX, posY] });
+    }
+
+    removeImage() {
+        return this.sendMessage({ command: 'remove_image', params: [this.serviceID] });
+    }
+
+    showCairoImageAbsolute(cairoImage, posX: number, posY: number, width: number, height: number) {
+        return this.sendMessage({
+            command: 'show_cairo_image',
+            params: [this.serviceID, cairoImage, -1.0 + (2.0 / width) * posX, -1.0 + (2.0 / height) * posY],
+        });
+    }
+
+    sendMessage(msgJson) {
+        let promise = new Promise((resolve, reject) => {
+            try {
+                this.sendMessages[this.callId] = { resolve, reject };
+                msgJson['call_id'] = this.callId++;
+                this.ws.send(JSON.stringify(msgJson));
+            } catch (err) {
+                this.reportErr(new Error(`Send message error: ${err}`));
+            }
+        });
+        return promise;
+    }
+
+    reportMsg(msg: string) {
+        this.emit('msg', msg);
+    }
+
+    reportErr(err: Error) {
+        this.ws?.terminate();
+        this.emit('error', err);
+    }
+
+    reportClose() {
+        this.emit('close');
+    }
+
+    updateCGText(fields: Field[]) {
+        let field_specs = '';
+
+        for (let field of fields) {
+            const name = field.field_name;
+            field_specs += `&${name}=${field.text}`;
+            if (field.color != undefined) {
+                field_specs += `&${name}_color=${field.color}`;
+            }
+        }
+
+        return this.promiseCGUpdate('update_text', field_specs);
+    }
+
+    /*
+    coorinates =
+        left
+        right
+        top
+        bottom
+        top_left
+        center
+        ...
+    */
+    private formCoordinates(coordinates: string, x: number, y: number) {
+        return coordinates != '' ? `&coord_system=${coordinates}&pos_x=${x}&pos_y=${y}` : '';
+    }
+
+    updateCGImage(path: string, coordinates = '', x = 0, y = 0) {
+        const coord = this.formCoordinates(coordinates, x, y);
+        const update = `&image=${path}`;
+        return this.promiseCGUpdate('update_image', update + coord);
+    }
+
+    updateCGImagePos(coordinates = '', x = 0, y = 0) {
+        const coord = this.formCoordinates(coordinates, x, y);
+        return this.promiseCGUpdate('update_image', coord);
+    }
+
+    async promiseCGUpdate(action: string, params: string) {
+        const path = encodeURI(
+            `/local/camoverlay/api/customGraphics.cgi?action=${action}&service_id=${this.serviceID}${params}`
+        );
+        const options = {
+            method: 'POST',
+            host: this.ip,
+            port: this.port,
+            path: path,
+            auth: this.auth,
+        };
+        await httpRequest(options, '');
+    }
+
+    async updateInfoticker(text: string) {
+        const path = `/local/camoverlay/api/infoticker.cgi?service_id=${this.serviceID}&text=${text}`;
+
+        const options = {
+            method: 'GET',
+            host: this.ip,
+            port: this.port,
+            path: path,
+            auth: this.auth,
+        };
+        await httpRequest(options, '');
+    }
+
+    async setEnabled(enabled: boolean) {
+        const value = enabled ? 1 : 0;
+        const path = encodeURI(`/local/camoverlay/api/enabled.cgi?id${this.serviceID}=${value}`);
+        const options = {
+            method: 'POST',
+            host: this.ip,
+            port: this.port,
+            path: path,
+            auth: this.auth,
+        };
+        await httpRequest(options, '');
+    }
+
+    async isEnabled() {
+        const options = {
+            method: 'GET',
+            host: this.ip,
+            port: this.port,
+            path: '/local/camoverlay/api/services.cgi?action=get',
+            auth: this.auth,
+        };
+        const response = (await httpRequest(options, '')) as string;
+        const data: ServiceJson = JSON.parse(response);
+
+        for (let service of data.services) {
+            if (service.id == this.serviceID) {
+                return service.enabled == 1;
+            }
+        }
+        throw new Error('Service not found.');
+    }
+}

package/src/CamStreamerAPI.ts

@@ -0,0 +1,58 @@
+import { httpRequest } from './HTTPRequest';
+import { HttpRequestOptions } from './HTTPRequest';
+
+export type CamStreamerAPIOptions = {
+    protocol: string;
+    ip: string;
+    port: number;
+    auth: string;
+};
+
+export class CamStreamerAPI {
+    private protocol: string;
+    private ip: string;
+    private port: number;
+    private auth: string;
+
+    constructor(options?: CamStreamerAPIOptions) {
+        this.protocol = options?.protocol ?? 'http';
+        this.ip = options?.ip ?? '127.0.0.1';
+        this.port = options?.port ?? this.protocol == 'http' ? 80 : 443;
+        this.auth = options?.auth ?? '';
+    }
+
+    async getStreamList() {
+        const streamListRes = await this.get('/local/camstreamer/stream/list.cgi');
+        return streamListRes.data;
+    }
+
+    async getStreamParameter(streamID: string, paramName: string) {
+        const stream = await this.get(`/local/camstreamer/stream/get.cgi?stream_id=${streamID}`);
+        return stream.data[paramName];
+    }
+
+    async setStreamParameter(streamID: string, paramName: string, value: string) {
+        return await this.get(`/local/camstreamer/stream/set.cgi?stream_id=${streamID}&${paramName}=${value}`);
+    }
+
+    async isStreaming(streamID: string) {
+        const response = await this.get(`/local/camstreamer/get_streamstat.cgi?stream_id=${streamID}`);
+        return response.data.is_streaming;
+    }
+
+    async get(path: string) {
+        const options = this.getBaseConnectionParams();
+        options.path = encodeURI(path);
+        const data = (await httpRequest(options)) as string;
+        return JSON.parse(data);
+    }
+
+    private getBaseConnectionParams(): HttpRequestOptions {
+        return {
+            protocol: this.protocol + ':',
+            host: this.ip,
+            port: this.port,
+            auth: this.auth,
+        };
+    }
+}

package/src/CamSwitcherAPI.ts

@@ -0,0 +1,130 @@
+import * as WebSocket from 'ws';
+import * as EventEmitter from 'events';
+
+import { httpRequest } from './HTTPRequest';
+import { HttpRequestOptions } from './HTTPRequest';
+
+export type CamSwitcherAPIOptions = {
+    ip?: string;
+    port?: number;
+    auth?: string;
+};
+
+export class CamSwitcherAPI extends EventEmitter {
+    private ip: string;
+    private port: number;
+    private auth: string;
+
+    private ws: WebSocket;
+    private pingTimer: NodeJS.Timer;
+
+    constructor(options: CamSwitcherAPIOptions) {
+        super();
+        this.ip = options?.ip ?? '127.0.0.1';
+        this.port = options?.port ?? 80;
+        this.auth = options?.auth ?? '';
+        EventEmitter.call(this);
+    }
+
+    // Connect for Websocket events
+    async connect() {
+        try {
+            const token = await this.get('/local/camswitcher/ws_authorization.cgi');
+            this.ws = new WebSocket(`ws://${this.ip}:${this.port}/local/camswitcher/events`, 'events');
+            this.pingTimer = null;
+
+            this.ws.on('open', () => {
+                this.ws.send(JSON.stringify({ authorization: token }));
+                this.ws.isAlive = true;
+                this.pingTimer = setInterval(() => {
+                    if (this.ws.isAlive === false) {
+                        return this.ws.terminate();
+                    }
+                    this.ws.isAlive = false;
+                    this.ws.ping();
+                }, 30000);
+            });
+
+            this.ws.on('pong', () => {
+                this.ws.isAlive = true;
+            });
+
+            this.ws.on('message', (data: string) => {
+                try {
+                    const parsedData: object = JSON.parse(data);
+                    this.emit('event', parsedData);
+                } catch (err) {
+                    console.log(err);
+                }
+            });
+
+            this.ws.on('close', () => {
+                clearInterval(this.pingTimer);
+                this.emit('event_connection_close');
+            });
+
+            this.ws.on('error', (err: Error) => {
+                this.emit('event_connection_error', err);
+            });
+        } catch (err) {
+            this.emit('event_connection_error', err as Error);
+        }
+    }
+
+    getPlaylistList() {
+        return this.get('/local/camswitcher/playlists.cgi?action=get');
+    }
+
+    getClipList() {
+        return this.get('/local/camswitcher/clips.cgi?action=get');
+    }
+
+    playlistSwitch(playlistName: string) {
+        return this.get(`/local/camswitcher/playlist_switch.cgi?playlist_name=${playlistName}`);
+    }
+
+    playlistQueueList() {
+        return this.get('/local/camswitcher/playlist_queue_list.cgi');
+    }
+
+    playlistQueueClear() {
+        return this.get('/local/camswitcher/playlist_queue_clear.cgi');
+    }
+
+    playlistQueuePush(playlistName: string) {
+        return this.get(`/local/camswitcher/playlist_queue_push.cgi?playlist_name=${playlistName}`);
+    }
+
+    playlistQueuePlayNext() {
+        return this.get('/local/camswitcher/playlist_queue_play_next.cgi');
+    }
+
+    getOutputInfo() {
+        return this.get('/local/camswitcher/output_info.cgi');
+    }
+
+    async get(path: string) {
+        const options = this.getBaseConnectionParams();
+        options.path = encodeURI(path);
+        const data = (await httpRequest(options)) as string;
+        try {
+            const response = JSON.parse(data);
+            if (response.status == 200) {
+                return response.data as object;
+            } else {
+                throw new Error(`Request (${path}) error, response: ${JSON.stringify(response)}`);
+            }
+        } catch (err) {
+            throw new Error(`Request (${path}) error: ${err}, msg: ${data}`);
+        }
+    }
+
+    private getBaseConnectionParams(): HttpRequestOptions {
+        return {
+            protocol: 'http:',
+            host: this.ip,
+            port: this.port,
+            auth: this.auth,
+        };
+    }
+}