@jibb-open/jssdk 3.5.5

package/src/ws/meeting.js

@@ -0,0 +1,170 @@
+import {Auth} from '../api/auth.js';
+import {Config} from "../config.js";
+import {logger} from "../utils/logger/index.js"
+import {RetryConnection} from "./retry_connection.js";
+import {ConnectionStatus} from "./connection_base.js";
+import {MeetingClaims} from "../types/types.js";
+
+import {meeting, types} from "../types/proto.js"
+let Message = meeting.Message
+let ErrorCode = types.Code
+
+if (globalThis?.WebSocket == undefined) {
+	import("isomorphic-ws").then((webSocket) => {
+		globalThis.WebSocket = webSocket.default;
+	});
+}
+
+class MeetingConnectionImp extends RetryConnection {
+	#expiryTimer
+	constructor() {
+		super('meeting')
+		this.meetingId = null
+		this.meetingToken = null
+		this.#expiryTimer = null
+	}
+
+	getName() {
+		return `${super.getName()}-${this.meetingId}`
+	}
+
+	async start(meetingToken) {
+		this.meetingToken = meetingToken
+		this.meetingClaims = new MeetingClaims(meetingToken)
+		this.meetingId = this.meetingClaims.meetindId
+		let seconds = this.meetingClaims.getSecondsUntilExpiry()
+		if (seconds <= 0) {
+			this.onErrorMessage(ErrorCode.ERR_TIMEOUT, "meeting token expired");
+			return
+		}
+		this.#expiryTimer = setTimeout(() => {
+			this.stop()
+			this.onErrorMessage(ErrorCode.ERR_TIMEOUT, "meeting 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.ERROR, ErrorCode.ERR_CLOSED, "closed") //this one fired after diconnection error causes multiple connection (it call retray connection again)
+			logger.info("meeting disconnect ", this.meetingId);
+		}
+
+		super.disconnect()
+	}
+
+	async connect() {
+		if (this.getConnectionStatus() != ConnectionStatus.DISCONNECTED)
+			return
+
+		super.connect()
+		let self = this;
+
+		try {
+			if (this.meetingClaims.isExpired()) {
+				self.onErrorMessage(ErrorCode.ERR_TIMEOUT, "meeting token expired");
+				return;
+			}
+		} catch (e) {
+			self.onErrorMessage(ErrorCode.ERR_BAD_REQUEST, "invalid meeting token");
+			return
+		}
+
+		let base = new URL(Config.apiBaseURL)
+		let uri = "wss://" + base.hostname + "/ws/meetings/" + this.meetingId + "?meeting_token=" + this.meetingToken;
+
+		this.socket = new WebSocket(uri);
+		this.socket.binaryType = "arraybuffer"
+		this.socket.addEventListener("open", function () {
+			self.onConnected()
+		});
+		this.socket.addEventListener("close", function () {
+			self.onDisconnected()
+		});
+		this.socket.addEventListener("message", function (event) {
+			self.#handleMessage(event.data)
+		});
+		this.socket.addEventListener("error", function (err) {
+			self.onWarningMessage(ErrorCode.ERR_IO, err);
+		});
+	}
+
+	async #handleMessage(msg) {
+		try {
+			if (msg instanceof ArrayBuffer) {
+				let buffer = new Uint8Array(msg)
+				let event = Message.decode(buffer);
+
+				if (event?.update)
+					this.notify('onMeetingUpdate', event.update)
+				if (event?.drawing)
+					this.notify('onDrawing', event.drawing)
+				if (event?.pointer)
+					this.notify('onPointer', event)
+				else if (event?.join)
+					this.notify('onMeetingJoin', event.join)
+				else if (event?.leave)
+					this.notify('onMeetingLeave', event.leave)
+				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) {
+			logger.error(e)
+			this.onWarningMessage(ErrorCode.ERR_IO, msg)
+		}
+	}
+
+	async sendPointer(x, y) {
+		await super.waitForConnection()
+		let claims = await Auth.getUserClaims()
+		let msg = Message.fromObject({
+			pointer: {
+				email: claims.email,
+				x: x,
+				y: y,
+			}
+		})
+
+		let buf = Message.encode(msg).finish();
+		this.socket.send(buf)
+	}
+
+	async sendDrawing({email, data}) {
+		await super.waitForConnection()
+		let msg = Message.fromObject({
+			drawing: {
+				email: email,
+				data: data,
+			}
+		})
+		logger.debug(`${this.getName()}.Drawing: `, Message.toObject(msg))
+
+		let buf = Message.encode(msg).finish();
+		this.socket.send(buf)
+	}
+}
+
+export let MeetingConnection = new MeetingConnectionImp()

package/src/ws/observable_connection.js

@@ -0,0 +1,84 @@
+import {logger} from "../utils/logger/index.js"
+import {ConnectionBase} from "./connection_base.js"
+
+export class ObservableConnection extends ConnectionBase {
+	constructor(connectionName) {
+		super(connectionName)
+		this.observers = new Map()
+	}
+
+	subscribe(id, observer) {
+		this.observers.set(id, observer)
+	}
+
+	unsubscribeAll() {
+		this.observers = new Map()
+	}
+
+	unsubscribe(id) {
+		try {
+			this.observers.delete(id)
+		} catch (err) {
+			logger.error(err)
+		}
+	}
+
+	notify(eventName, ...args) {
+		this.observers.forEach((o) => {
+			try {
+				let fn = o[eventName]
+				if (fn !== undefined) fn(...args)
+			} catch (err) {
+				logger.error(`Error occured notifying event ${eventName}`, err)
+			}
+		})
+	}
+
+	callSubscribers(functionName, ...args) {
+		let promises = []
+
+		this.observers.forEach((o) => {
+			try {
+				let fn = o[functionName]
+				if (fn !== undefined) {
+					let res = fn(...args)
+					promises.push(res)
+				}
+			} catch (error) {
+				logger.error(error)
+			}
+		})
+
+		return Promise.any(promises)
+	}
+
+	onDisconnected() {
+		super.onDisconnected()
+		this.notify("onDisconnected")
+	}
+
+	onConnected() {
+		super.onConnected()
+		this.notify("onConnected")
+	}
+
+	onStopped() {
+		super.onStopped()
+		this.notify("onStopped")
+	}
+
+	onErrorMessage(code, reason) {
+		super.onErrorMessage(code, reason)
+		this.notify("onErrorMessage", code, reason)
+	}
+
+	onWarningMessage(code, reason) {
+		super.onWarningMessage(code, reason)
+		this.notify("onWarningMessage", code, reason)
+	}
+
+	onInfoMessage(code, reason) {
+		super.onInfoMessage(code, reason)
+		this.notify("onInfoMessage", code, reason)
+	}
+}

package/src/ws/retry_connection.js

@@ -0,0 +1,82 @@
+import { logger } from "../utils/logger/index.js"
+import { ObservableConnection } from "./observable_connection.js"
+
+export class RetryConnection extends ObservableConnection {
+	#started
+
+	constructor(connectionName, maxRetryCount = 10, minRetryIntervalMs = 500, maxRetryIntervalMs = 32000) {
+		super(connectionName)
+
+		this.maxRetryCount = maxRetryCount
+		this.minRetryIntervalMs = minRetryIntervalMs
+		this.maxRetryIntervalMs = maxRetryIntervalMs
+		this.retryCount = 0
+		this.retryIntervalMs = minRetryIntervalMs
+		this.lastConnectionTime = Date.now() - maxRetryIntervalMs
+		this.retryTimer = null
+		this.#started = false
+	}
+
+	start() {
+		if (!this.isStarted()) {
+			logger.info(`${this.getName()}: starting...`)
+			this.#started = true
+			this.connect()
+		}
+	}
+
+	stop() {
+		logger.info(`${this.getName()}: stopping...`)
+		this.#started = false
+		this.disconnect()
+	}
+
+	isStarted() {
+		return this.#started
+	}
+
+	onDisconnected() {
+		super.onDisconnected()
+		if (this.isStarted()) this.#reconnect()
+	}
+
+	connect() {
+		if (this.isStarted()) super.connect()
+	}
+
+	disconnect() {
+		if (this.retryTimer) {
+			clearTimeout(this.retryTimer)
+			this.retryTimer = null
+		}
+		super.disconnect()
+	}
+
+	#reconnect() {
+		let self = this
+
+		if (Date.now() - this.lastConnectionTime < this.retryIntervalMs) {
+			this.retryIntervalMs = Math.min(this.retryIntervalMs * 2, this.maxRetryIntervalMs)
+			this.retryCount = this.retryCount + 1
+		} else {
+			this.retryCount = 1
+			this.retryIntervalMs = this.minRetryIntervalMs
+		}
+
+		if (this.retryCount >= this.maxRetryCount) {
+			this.stop()
+			return
+		}
+
+		this.retryTimer = setTimeout(() => {
+			logger.info(`${this.getName()}: retrying connection... [interval: ${this.retryIntervalMs}ms]`)
+			self.lastConnectionTime = Date.now() + 4000
+			self.connect()
+		}, this.retryIntervalMs)
+	}
+
+	onErrorMessage(code, reason) {
+		super.onErrorMessage(code, reason)
+		this.stop()
+	}
+}

package/webpack.config.cjs

@@ -0,0 +1,144 @@
+const path = require('path');
+const webpack = require("webpack")
+
+var BundleAnalyzerPlugin = require("webpack-bundle-analyzer").BundleAnalyzerPlugin
+
+const webConfig = {
+	mode: "production",
+	target: "web",
+	entry: "./src/api/index.js",
+	output: {
+		filename: "jibb.js",
+		path: path.resolve(__dirname, "dist/web"),
+		globalObject: "globalThis",
+		library: {
+			name: "JIBB",
+			type: "umd",
+			export: "default",
+		},
+	},
+	module: {
+		rules: [
+			{
+				test: /\.js$/,
+				exclude: ["/(node_modules)/"],
+				use: {
+					loader: "babel-loader",
+					options: {
+						presets: ["@babel/preset-env"],
+						plugins: [
+							[
+								"babel-plugin-transform-import-ignore",
+								{
+									patterns: ["*xapi*", "**/*.webex-devices.js"],
+								},
+							],
+						],
+					},
+				},
+			},
+		],
+	},
+	plugins: [
+		//	new BundleAnalyzerPlugin(),
+		new webpack.EnvironmentPlugin({
+			API_BASE_URL: "https://api.jibb.ai",
+		}),
+	],
+	externals: { xapi: "xapi" },
+}
+
+const nodeConfig = {
+	target: "node",
+	entry: ["./src/api/index.js"],
+	output: {
+		filename: "jibb.cjs",
+		path: path.resolve(__dirname, "dist/node"),
+		globalObject: "globalThis",
+		library: {
+			name: "JIBB",
+			type: "commonjs",
+			export: "default",
+		},
+	},
+	module: {
+		rules: [
+			{
+				test: /\.js$/,
+				exclude: ["/(node_modules)/", "/utils/http/http.xapi.js"],
+				use: {
+					loader: "babel-loader",
+					options: {
+						presets: ["@babel/preset-env"],
+						plugins: [
+							[
+								"babel-plugin-transform-import-ignore",
+								{
+									patterns: [".webex-devices.js", "*xapi*"],
+								},
+							],
+						],
+					},
+				},
+			},
+		],
+	},
+	externals: { xapi: "xapi" },
+}
+
+const webeXapiConfig = {
+	mode: "production",
+	target: "node",
+	entry: ["./src/index.webex-devices.js"],
+	resolve: {
+		alias: {
+			//	"@jibb/jibbapis/bundle.js": path.resolve(__dirname, `webex_device_specific/jibbapis_replacment.js`),
+		},
+	},
+	output: {
+		filename: "jibb_WebexXapi.js",
+		path: path.resolve(__dirname, "dist/webex"),
+		globalObject: "global",
+		library: {
+			name: "JIBB",
+			type: "umd",
+			export: "default",
+		},
+	},
+	externals: { xapi: "xapi" },
+	externalsPresets: {
+		node: true, // in order to ignore built-in modules like path, fs, etc.
+	},
+	module: {
+		rules: [
+			{
+				test: /\.js$/,
+				exclude: /(node_modules)/,
+				use: {
+					loader: "babel-loader",
+					options: {
+						presets: ["@babel/preset-env"],
+						plugins: [
+							[
+								"babel-plugin-transform-import-ignore",
+								{
+									patterns: ["*axios*"],
+								},
+							],
+						],
+					},
+				},
+			},
+		],
+	},
+
+	plugins: [
+		//	new BundleAnalyzerPlugin(),
+		new webpack.EnvironmentPlugin({
+			API_BASE_URL: "https://api.jibb.ai", // use 'development' unless process.env.NODE_ENV is defined
+		}),
+	],
+}
+
+module.exports = [webConfig, webeXapiConfig, nodeConfig]
+