@jibb-open/jssdk 3.5.5

package/src/ws/eventbus.js

@@ -0,0 +1,363 @@
+import {Config} from "../config.js";
+import {logger} from "../utils/logger/index.js"
+import {InvalidArgumentError} from '../types/exceptions.js';
+import {RetryConnection} from "./retry_connection.js";
+import {ConnectionStatus} from "./connection_base.js";
+import {UserClaims} from "../types/types.js";
+import {types, cilix} from "../types/proto.js"
+import {Auth} from "../api/auth.js";
+
+const ClientType = types.ClientType
+const ErrorCode = types.Code
+const BusMessage = cilix.BusMessage
+
+
+function getClientNameByType(clientType) {
+    let found = Object.entries(ClientType).find(([k, v]) => {
+        return v == clientType
+    });
+    if (!found)
+        throw new InvalidArgumentError(`Invalid client type: ${clientType}`)
+    let name = found[0].toLowerCase()
+    return name
+}
+
+class WSConnection extends RetryConnection {
+    #expiryTimer
+
+    constructor(clientType, name) {
+        let clientName = getClientNameByType(clientType).toLowerCase()
+        super(`eventbus-${clientName}`)
+        this.clientType = clientType
+        this.socket = null
+        this.userToken = null
+        this.clientName = clientName
+        this.name = name
+        this.#expiryTimer = null
+    }
+
+    async start() {
+        this.userToken = await Auth.getUserToken()
+        this.userClaims = new UserClaims(this.userToken)
+        let seconds = this.userClaims.getSecondsUntilExpiry()
+        if (seconds <= 0) {
+            this.onErrorMessage(ErrorCode.ERR_TIMEOUT, "token expired");
+            return
+        }
+        this.#expiryTimer = setTimeout(() => {
+            this.stop()
+            this.onErrorMessage(ErrorCode.ERR_TIMEOUT, "token expired");
+        }, seconds)
+        super.start()
+    }
+
+    async stop() {
+        clearTimeout(this.#expiryTimer)
+        super.stop()
+    }
+
+    disconnect() {
+        if (this.socket != null) {
+            this.socket.close();
+            this.socket = null;
+            //this.fireOnError(ErrorLevel.WARNING, ErrorCode.ERR_CLOSED, "closed") //this one fired after diconnection error causes multiple connection (it call retray connection again)
+            logger.info("eventbus disconnect ", this.clientName);
+        }
+
+        super.disconnect()
+    }
+
+    async write(msg) {
+        await super.waitForConnection()
+        logger.debug(`${this.getName()}.write: `, BusMessage.toObject(msg))
+        let data = BusMessage.encode(msg).finish();
+        this.socket.send(data)
+    }
+
+    writeObject(msg) {
+        let err = BusMessage.verify(msg)
+        if (err)
+            throw new Error(err)
+
+        let request = BusMessage.fromObject(msg)
+        return this.write(request)
+    }
+
+    async connect() {
+        if (this.getConnectionStatus() != ConnectionStatus.DISCONNECTED)
+            return
+
+        super.connect()
+        let self = this;
+
+        try {
+            let c = new UserClaims(this.userToken)
+            if (c.isExpired()) {
+                self.onErrorMessage(ErrorCode.ERR_TIMEOUT, "token expired");
+                return
+            }
+        } catch (err) {
+            logger.error(e)
+            self.onErrorMessage(ErrorCode.ERR_UNAUTHORIZED, "unauthorized");
+            return
+        }
+
+        let base = new URL(Config.apiBaseURL)
+        let uri = `wss://${base.hostname}/ws/eventbus/${this.clientName}?user_token=${this.userToken}&name=${this.name}`;
+
+        this.socket = new WebSocket(uri);
+        this.socket.binaryType = "arraybuffer"
+        this.socket.addEventListener("open", () => {
+            self.onConnected()
+        });
+        this.socket.addEventListener("close", () => {
+            self.onDisconnected()
+        });
+        this.socket.addEventListener("message", (event) => {
+            self.#handleMessage(event.data)
+        });
+        this.socket.addEventListener("error", (err) => {
+            self.onWarningMessage(ErrorCode.ERR_IO, err);
+        });
+    }
+
+    async #handleMessage(msg) {
+        try {
+            if (msg instanceof ArrayBuffer) {
+                let buffer = new Uint8Array(msg)
+                let response = BusMessage.decode(buffer)
+                buffer = null
+                logger.debug(`${this.getName()}.read: `, response)
+                this.onMessage(response)
+                return
+            }
+        } catch (err) {
+            logger.error(err)
+        }
+
+        try {
+            let Error = JSON.parse(msg);
+            switch (Error.code) {
+                case ErrorCode.ERR_TOO_MANY_CONNECTIONS:
+                case ErrorCode.ERR_UNAUTHORIZED:
+                case ErrorCode.ERR_BAD_REQUEST:
+                case ErrorCode.ERR_TIMEOUT:
+                    this.onErrorMessage(Error.code, Error.reason)
+                    break
+                default:
+                    this.onInfoMessage(Error.code, Error.reason)
+                    break
+            }
+        } catch (e) {
+            this.onWarningMessage(ErrorCode.ERR_IO, e)
+        }
+    }
+
+
+
+    onMessage(response) {
+        logger.debug(response)
+    }
+}
+
+class EventBusConnection extends WSConnection {
+    static instances = new Map()
+
+    static getInstance(clientType = ClientType.WEBAPP, name = "") {
+        let c = EventBusConnection.instances.get(clientType)
+        if (!c) {
+            c = new EventBusConnection(clientType, name)
+            EventBusConnection.instances.set(clientType, c)
+        }
+        return c
+    }
+
+    constructor(clientType = ClientType.WEBAPP, name = "") {
+        super(clientType, name)
+    }
+
+    async onMessage(msg) {
+        if (!msg || typeof msg !== 'object')
+            return
+
+        try {
+            msg.clientConnected && this.#onClientConnected(msg)
+            msg.clientDisconnected && this.#onClientDisconnected(msg)
+            msg.cameraListRequest && this.#onCameraListRequest(msg)
+            msg.cameraListResponse && this.#onCameraListResponse(msg)
+            msg.runtimeConfigRequest && this.#onRuntimeConfigRequest(msg)
+            msg.startRequest && this.#onStartRequest(msg)
+            msg.stopRequest && this.#onStopRequest(msg)
+            msg.previewRequest && this.#onPreviewRequest(msg)
+            msg.previewResponse && this.#onPreviewResponse(msg)
+            msg.ipsaResponse && this.#onIPSAResponse(msg)
+            msg.tooManyPublishers && this.#onTooManyPublishers(msg)
+            msg.recordingStarted && this.#onRecordingStarted(msg)
+            msg.recordingStopped && this.#onRecordingStopped(msg)
+        } catch (e) {
+            logger.error(e);
+        }
+    }
+
+    stopStream(clientId) {
+        return this.writeObject({
+            stopRequest: {
+            },
+            dst: {
+                id: clientId,
+            }
+        })
+    }
+
+    startStream({
+        appConfig,
+        config,
+        runtimeConfig,
+        camera,
+        sipUri,
+        clientId
+    }) {
+        return this.writeObject({
+            startRequest: {
+                config,
+                appConfig,
+                runtimeConfig,
+                camera,
+                sipUri,
+            },
+            dst: {
+                id: clientId,
+            }
+        })
+    }
+
+    requestCameraPreview(clientId, sourceId) {
+        return this.writeObject({
+            previewRequest: {
+                source: {id: sourceId, }
+            },
+            dst: {
+                id: clientId,
+            }
+        });
+    }
+
+    setRuntimeConfig(clientId, cfg) {
+        return this.writeObject({
+            runtimeConfigRequest: cfg,
+            dst: {
+                id: clientId,
+            }
+        });
+    }
+
+    getCameraList(clientId) {
+        let request = {
+            cameraListRequest: {
+            },
+            dst: {
+                id: clientId
+            }
+        }
+        return this.write(request);
+    }
+
+    sendCameraList(camList, src, dst) {
+        let response = {
+            cameraListResponse: {
+                items: camList
+            },
+            src: src,
+            dst: dst
+        };
+        return this.writeObject(response);
+    }
+
+    getClientStatusList() {
+        let request = {
+            clientStatusRequest: {
+            }
+        }
+
+        return this.writeObject(request);
+    }
+
+    #sendPreview(image, dst) {
+        let response = {
+            previewResponse: {
+                image: image
+            },
+            dst: dst,
+        };
+        return this.write(response);
+    }
+
+    async #onCameraListRequest(msg) {
+        let response = await this.callSubscribers('onCameraListRequest', msg.cameraListRequest)
+        this.sendCameraList(response, msg.dst, msg.src);
+    }
+
+    #onCameraListResponse(msg) {
+        this.notify('onCameraListResponse', msg.cameraListResponse)
+    }
+
+    #onClientConnected(msg) {
+        logger.info(`${this.getName()}: client connected: `, msg.src)
+        this.notify('onClientConnected', msg.src)
+    }
+
+    #onClientDisconnected(msg) {
+        logger.warn(`${this.getName()}: client disconnected: `, msg.src)
+        this.notify('onClientDisconnected', msg.src)
+    }
+
+    #onRuntimeConfigRequest(msg) {
+        this.notify('onRuntimeConfigRequest', msg.runtimeConfigRequest)
+    }
+
+    #onStopRequest(msg) {
+        this.notify('onStopRequest', msg.stopRequest)
+    }
+
+    async #onPreviewRequest(msg) {
+        let response = await this.callSubscribers('onPreviewRequest', msg.previewRequest)
+        this.#sendPreview(response, msg.src);
+    }
+
+    #onPreviewResponse(msg) {
+        this.notify('onPreviewResponse', msg.previewResponse)
+    }
+
+    #onStartRequest(msg) {
+        let req = msg.startRequest
+        if (!req?.camera?.id && !req?.sipUri && req?.inputSource?.id) {
+            req.camera = {
+                id: req.inputSource.id
+            };
+        }
+        this.notify('onStartRequest', req)
+    }
+
+    #onCornersReceived(msg) {
+        this.notify('onCornersReceived', msg.corners.corners)
+    }
+
+
+    #onIPSAResponse(msg) {
+        msg && this.notify('onIPSAResponse', msg.ipsaResponse)
+    }
+
+    #onTooManyPublishers(msg) {
+        this.notify('onTooManyPublishers', msg.tooManyPublishers)
+    }
+
+    #onRecordingStarted(msg) {
+        this.notify('onRecordingStarted', msg.recordingStarted)
+    }
+
+    #onRecordingStopped(msg) {
+        this.notify('onRecordingStopped', msg.recordingStopped)
+    }
+}
+
+export {EventBusConnection}

package/src/ws/index.js

@@ -0,0 +1,15 @@
+import {EventBusConnection} from "./eventbus.js";
+import {IPSA} from "./ipsa.js";
+import {MeetingConnection} from "./meeting.js";
+
+if (globalThis?.WebSocket == undefined) {
+	import("isomorphic-ws").then((webSocket) => {
+		globalThis.WebSocket = webSocket.default;
+	});
+}
+
+export {
+	MeetingConnection,
+	EventBusConnection,
+	IPSA,
+}

package/src/ws/ipsa.js

@@ -0,0 +1,238 @@
+import {Config as SDKConfig} from "../config.js";
+import {logger} from "../utils/logger/index.js"
+import {RetryConnection} from "./retry_connection.js";
+import {ConnectionStatus} from "./connection_base.js";
+import {UserClaims, MeetingClaims} from "../types/types.js";
+import {ipsa, types} from "../types/proto.js"
+const ErrorCode = types.Code
+
+class IPSAClass extends RetryConnection {
+    #expiryTimer
+
+    constructor() {
+        super('ipsa')
+        this.socket = null
+        this.onInputImage = null
+        this.onError = null
+        this.onResponse = null
+        this.userToken = null
+        this.#expiryTimer = null
+        this.#clear()
+    }
+
+    start({userToken, request, onInputImage, onError, onResponse}) {
+        if (!this.isStarted()) {
+            this.setRuntimeConfig(request.runtimeConfig)
+            this.setAppConfig(request.appConfig)
+            this.#setConfig(request.config)
+            this.onInputImage = onInputImage
+            this.onError = onError
+            this.onResponse = onResponse
+            this.userToken = userToken
+
+            let meetingClaims = new MeetingClaims(this.appConfigRequest.appConfig.meetingToken)
+            let userClaims = new UserClaims(this.userToken)
+            let seconds = Math.min(userClaims.getSecondsUntilExpiry(), meetingClaims.getSecondsUntilExpiry())
+            if (seconds <= 0) {
+                this.onErrorMessage(ErrorCode.ERR_TIMEOUT, "token expired");
+                return
+            } else {
+                this.#expiryTimer = setTimeout(() => {
+                    this.stop()
+                    this.onErrorMessage(ErrorCode.ERR_TIMEOUT, "token expired");
+                }, seconds)
+            }
+        }
+        super.start()
+    }
+
+    stop() {
+        clearTimeout(this.#expiryTimer)
+        this.#clear()
+        super.stop()
+    }
+
+    #clear() {
+        this.appConfigRequest = null
+        this.configRequest = null
+        this.runtimeConfigRequest = null
+        this.requestTimes = new Array(8)
+        this.responseTimes = new Array(8)
+        this.responseTimes.fill(1000)
+        this.requestId = 0
+    }
+
+    disconnect() {
+        super.disconnect()
+        if (this.socket != null) {
+            this.socket.close();
+            this.socket = null;
+            //  this.fireOnError(ErrorLevel.ERROR, ErrorCode.ERR_CLOSED, "closed") //this one fired after diconnection error causes multiple connection (it call retray connection again)
+        }
+    }
+
+    async #write(msg) {
+        let err = ipsa.Request.verify(msg)
+        if (err)
+            throw new Error("invalid message: " + err)
+
+        if (msg) {
+            let data = ipsa.Request.encode(msg).finish()
+            this.socket.send(data)
+        }
+    }
+
+    async connect() {
+        if (this.getConnectionStatus() != ConnectionStatus.DISCONNECTED)
+            return
+
+        super.connect()
+
+        let meetingId = this.appConfigRequest.appConfig.meetingId
+        let meetingToken = this.appConfigRequest.appConfig.meetingToken
+
+        try {
+            let c = new UserClaims(this.userToken)
+            if (c.isExpired()) {
+                this.onErrorMessage(ErrorCode.ERR_TIMEOUT, "token expired");
+                return
+            }
+        } catch (err) {
+            this.onErrorMessage(ErrorCode.ERR_UNAUTHORIZED, "unauthorized");
+            return
+        }
+
+        logger.info(`Connecting IPSA to meeting ${meetingId}...`);
+        let base = new URL(SDKConfig.apiBaseURL)
+        let uri = `wss://${base.hostname}/ws/ipsa/${meetingId}?user_token=${this.userToken}&meeting_token=${meetingToken}`;
+
+        this.socket = new WebSocket(uri);
+        this.socket.binaryType = "arraybuffer"
+        this.socket.addEventListener("open", async () => {
+            try {
+                await this.#write(this.configRequest)
+                await this.#write(this.runtimeConfigRequest)
+                await this.#write(this.appConfigRequest)
+                this.onConnected()
+            } catch (err) {
+                this.onWarningMessage(ErrorCode.ERR_IO, err)
+                this.disconnect()
+                return
+            }
+
+            let loopFunction = () => {
+                if (!this.isConnected() || !this.isStarted())
+                    return
+
+                let wait = Math.max(500, this.getAverageResponseTime())
+                logger.debug("Next IPSA request: ", wait)
+                setTimeout(loopFunction, wait)
+
+                this.#writeInputImage().catch(err => logger.error(err))
+            }
+
+            loopFunction()
+        });
+        this.socket.addEventListener("close", () => {
+            this.onDisconnected()
+        });
+        this.socket.addEventListener("message", (event) => {
+            this.#handleMessage(event.data);
+        });
+        this.socket.addEventListener("error", (err) => {
+            this.onWarningMessage(ErrorCode.ERR_IO, err);
+        });
+    }
+
+    getAverageResponseTime() {
+        let sum = this.responseTimes.reduce((a, b) => {return a + b})
+        return sum / this.responseTimes.length
+    }
+
+    async #handleMessage(msg) {
+        try {
+            if (msg instanceof ArrayBuffer) {
+                let buffer = new Uint8Array(msg)
+                let response = ipsa.Response.decode(buffer)
+                this.#onResponse(response);
+                return
+            }
+        } catch (err) {
+            logger.error(err)
+        }
+
+        try {
+            msg = JSON.parse(msg);
+
+            switch (msg.code) {
+                case ErrorCode.ERR_TOO_MANY_CONNECTIONS:
+                case ErrorCode.ERR_UNAUTHORIZED:
+                case ErrorCode.ERR_BAD_REQUEST:
+                    this.onErrorMessage(msg?.code, msg?.reason)
+                    this.stop()
+                    break
+                default:
+                    this.onInfoMessage(msg?.code, msg?.reason)
+                    break
+            }
+        } catch (e) {
+            this.onWarningMessage(ErrorCode.ERR_IO, e)
+        }
+    }
+
+    #onResponse(response) {
+        if (response.id > 100) {
+            let id = response.id - 100
+            this.responseTimes[id] = performance.now() - this.requestTimes[id]
+        }
+
+        if (this.onResponse) {
+            this.onResponse(response)
+        }
+    }
+
+    async #writeInputImage() {
+        let img = await this.onInputImage()
+        this.requestId = (this.requestId + 1) % this.requestTimes.length
+        this.requestTimes[this.requestId] = performance.now()
+
+        if (this.socket.bufferedAmount > 2 * img.length) {
+            logger.warn("ipsa: low internet speed connection")
+            return
+        }
+
+        let request = ipsa.Request.create({
+            id: this.requestId + 100,
+            ipsa: {
+                data: img,
+            }
+        })
+        this.#write(request)
+    }
+
+
+    #setConfig(cfg) {
+        let request = ipsa.Request.create({config: cfg})
+        this.configRequest = request
+        if (this.isConnected())
+            this.#write(request)
+    }
+
+    setRuntimeConfig(cfg) {
+        let request = ipsa.Request.create({runtimeConfig: cfg})
+        this.runtimeConfigRequest = request
+        if (this.isConnected())
+            this.#write(request)
+    }
+
+    setAppConfig(cfg) {
+        let request = ipsa.Request.create({appConfig: cfg})
+        this.appConfigRequest = request
+        if (this.isConnected())
+            this.#write(request)
+    }
+}
+
+
+export let IPSA = new IPSAClass()
+