vani-meeting-client 0.0.1-beta

package/README.md

@@ -0,0 +1,153 @@
+
+# Vani Meeting SDK
+Next generation video and audio API and SDK solutions to enhance your online experience. Engage with your audience in real-time, on any platform, from anywhere, through the addition of video and voice with Vani Meetings’s API and SDK solutions.
+
+
+
+
+
+## Getting Started
+
+
+## Installation
+
+Install vani-meeting.demo with npm
+
+```bash
+  npm install com.vanimeeting.demo
+                
+  yarn add com.vanimeeting.demo
+```
+    
+## Usage/Examples
+
+```bash
+    import * as MeetingHandler from "com.vanimeeting.demo";
+    import * as EventEmitter from "events";
+
+    class WebrtcCallHandler {
+    constructor() {
+    this.roomid = null;
+    this.meetingRequest = null;
+    this.evenetEmitter = new EventEmitter();
+    }
+
+    static instance = new WebrtcCallHandler();
+    static getInstance() {
+        if (WebrtcCallHandler.instance === null) {
+            WebrtcCallHandler.instance = new WebrtcCallHandler();
+         } else {
+        return WebrtcCallHandler.instance;
+        }
+    }
+    setup(roomid, userid, appName, userData) {
+        if (this.meetingRequest === null) {
+            const locaUserid =
+            new Date().getTime() + "_" + Math.floor(Math.random() * 20);
+            this.meetingRequest = MeetingHandler.meetingStartRequestObject(
+                roomid,
+                userid || locaUserid,
+                "demo" || appName
+            );
+            this.meetingRequest.numberOfUsers = 2;
+            this.meetingRequest.userData = userData;
+            }
+            return this.meetingRequest;
+        }
+    }
+
+    export default WebrtcCallHandler;
+
+```
+
+First we have to import SDK.
+```
+    import * as MeetingHandler from "com.vanimeeting.demo";
+    import * as EventEmitter from "events";
+```
+
+Then we have to call meetingStartRequestObject which returns meetingStartRequestObject modal and accepts `roomId`, `userId`, `appId`, and `userData` as its params where:
+
+* `roomId` : is always unique string to join a meeting.
+* `userId` :  is always unique string respective to user.
+* `appId` :   can be any manual id given by user.
+* `userData` :    any extra data.
+```
+    setup(roomid, userid, appName, userData) {
+        if (this.meetingRequest === null) {
+            const locaUserid =
+            new Date().getTime() + "_" + Math.floor(Math.random() * 20);
+            this.meetingRequest = MeetingHandler.meetingStartRequestObject(
+                roomid,
+                userid || locaUserid,
+                "demo" || appName
+            );
+            this.meetingRequest.numberOfUsers = 2;
+            this.meetingRequest.userData = userData;
+            }
+            return this.meetingRequest;
+        }
+    }
+```
+
+Then we will initialize the meeting and establish the connection by calling init method.
+
+```
+    MeetingHandler.init();
+```
+
+Then we will call startLocalStream method of MeetingHandler which will ask for camera and mic permission, once given returns the localStream of the user itself.
+It accepts `isVideoRequired` and `isAudioRequired` as its params.
+
+ * `isVideoRequired` : boolean
+ * `isAudioRequired` : boolean
+
+```
+    MeetingHandler.startLocalStream();
+```
+
+Then we will call checkSocket method of MeetingHandler to establish a connection with web socket.
+
+```
+    MeetingHandler.checkSocket();
+```
+
+After the connection is established with the websocket we will recieve an `onConnected` event and pass event name "onConnected" as first params and pass callback function `onConnected` as second parameter which will call `startMeeting` method of MeetingHandler to start the meeting.
+
+```
+    MeetingHandler.eventEmitter.on("onConnected", this.onConnected);
+    onConnected = () => {
+    MeetingHandler.startMeeting();
+    };
+```
+
+After the initiation of meeting we will recieve an `onTrack` event and pass that event as event name "onTrack" as first params and pass callback function `onTrack` as second parameter which will recieve track as a parameter which will be passed as a `MediaStream` to `video` tag.
+
+```
+    MeetingHandler.eventEmitter.on("onTrack", this.onTrack);
+    MeetingHandler.eventEmitter.on("refreshTrack", this.onTrack);*
+    onTrack(track) {
+        if (
+            track.track !== null &&
+            track &&
+            track.kind === "video" &&
+            track.isLocalTrack
+        ) {
+            this.localVideoRef.current.srcObject = new MediaStream([track.track]);
+            this.localVideoRef.current.play();
+        } else if (track && track.track !== null && !track.isLocalTrack) {
+        if (track.kind === "video" && track) {
+            this.remoteVideoRef.current.srcObject = new MediaStream([track.track]);
+            this.remoteVideoRef.current.play();
+        } else {
+        if (track && track.track !== null) {
+          this.remoteAudioRef.current.srcObject = new MediaStream([
+            track.track,
+          ]);
+            this.remoteAudioRef.current.play();
+            }
+        }
+        }
+    }
+```
+

package/lib/MeetingHandler.d.ts

@@ -0,0 +1,45 @@
+import { MeetingStartRequest, VaniEventListener, Device, MessagePayload } from ".";
+import { GetDevicesType } from "./user-media-handler/UserMediaHandler";
+import { Track } from "./model/Track";
+import { TaskResponse } from "./model/TaskResponse";
+import { Participant } from "./model/Participant";
+export declare class MeetingHandler {
+    private meetingStartRequest?;
+    private videoCallHandler?;
+    private reactNativeWebrtcPlugin?;
+    private websocketCallHandler?;
+    private communicationHandler?;
+    private userMediaHandler?;
+    meetingStartRequestObject(roomId: string, userId: string, appId: string, wssUrl: string): MeetingStartRequest;
+    endAndDestory(): void;
+    init(): Promise<void>;
+    switchCamera(): void;
+    startLocalStream(isVideoRequired: boolean, isAudioRequired: boolean, shouldAddTrackImmediately?: boolean, userMediaPayload?: any): Promise<void>;
+    startScreenShare(isAudioRequired?: boolean, shouldAddTrackImmediately?: boolean, screensharePayload?: any): Promise<void>;
+    stopScreenSharing(): Promise<void>;
+    getDevices(deviceType: GetDevicesType): Promise<Device[] | undefined>;
+    pauseCamera(userId?: string): Promise<TaskResponse>;
+    muteUser(userId?: string): Promise<TaskResponse>;
+    resumeCamera(userId?: string): Promise<TaskResponse>;
+    unmute(userId?: string): Promise<TaskResponse>;
+    stopTrack(track: Track): void;
+    addCustomTrack(track: Track): void;
+    pauseIncomingTrack(track: Track): void;
+    resumeIncomingTrack(track: Track): void;
+    participantByUserId(userId: string): Participant | undefined;
+    updateParticipantData(participant: Participant): Participant | undefined;
+    getUpdatedParticipantsListFromServer(): void;
+    getAllParticipants(): Participant[];
+    getAllTracks(): Track[];
+    getTracksByParticipantId(participantId: string): Track[];
+    sendMessage(message: MessagePayload): TaskResponse;
+    getOldMessages(): Promise<void>;
+    onOldMessages(data: any): Promise<void>;
+    checkSocket(): Promise<void>;
+    startMeeting(): Promise<void>;
+    getMeetingStartTime(): Promise<void>;
+    getEventEmitter(): VaniEventListener | undefined;
+    private emitMessageToSource;
+    private cleanup;
+    private handleGA;
+}

package/lib/MeetingHandler.js

@@ -0,0 +1,410 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { VaniEvent, MeetingStartRequest } from ".";
+import { DynamicLibHelper } from "./utility/DynamicLibHelper";
+import * as log from 'loglevel';
+import { WebSocketBasicEvents, WebsocketHandler } from "./websocket-handler/WebsocketHandler";
+import { CommunicationHandler } from "./inter-communication-handler/CommunicationHandler";
+import { UserMediaHandler } from "./user-media-handler/UserMediaHandler";
+var MeetingHandler = /** @class */ (function () {
+    function MeetingHandler() {
+        this.communicationHandler = new CommunicationHandler(this);
+    }
+    MeetingHandler.prototype.meetingStartRequestObject = function (roomId, userId, appId, wssUrl) {
+        if (!this.meetingStartRequest) {
+            if (roomId === userId) {
+                roomId = roomId + "-r";
+            }
+            this.meetingStartRequest = new MeetingStartRequest(roomId, userId, appId, wssUrl);
+        }
+        return this.meetingStartRequest;
+    };
+    MeetingHandler.prototype.endAndDestory = function () {
+        this.cleanup();
+    };
+    MeetingHandler.prototype.init = function () {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function () {
+            var _d, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        if (!this.meetingStartRequest) {
+                            log.error("meetingStartRequestObject not found");
+                            return [2 /*return*/];
+                        }
+                        log.setLevel("trace");
+                        (_a = this.communicationHandler) === null || _a === void 0 ? void 0 : _a.setMeetingStartRequest(this.meetingStartRequest);
+                        if (!((_b = this.meetingStartRequest) === null || _b === void 0 ? void 0 : _b.isMobileApp)) return [3 /*break*/, 2];
+                        _d = this;
+                        return [4 /*yield*/, new DynamicLibHelper().getReactNativeWebrtcPlugin(this.meetingStartRequest)];
+                    case 1:
+                        _d.reactNativeWebrtcPlugin = _f.sent();
+                        this.reactNativeWebrtcPlugin.registerGlobals();
+                        _f.label = 2;
+                    case 2:
+                        _e = this;
+                        return [4 /*yield*/, new DynamicLibHelper().getVideoCallClassHandler((_c = this.meetingStartRequest) === null || _c === void 0 ? void 0 : _c.meetingType, this.meetingStartRequest, this.communicationHandler)];
+                    case 3:
+                        _e.videoCallHandler = _f.sent();
+                        this.websocketCallHandler = new WebsocketHandler(this.meetingStartRequest, this.communicationHandler);
+                        this.handleGA();
+                        this.emitMessageToSource(VaniEvent.OnInitDone, {});
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    MeetingHandler.prototype.switchCamera = function () {
+        var _a;
+        (_a = this.userMediaHandler) === null || _a === void 0 ? void 0 : _a.switchCamera();
+    };
+    MeetingHandler.prototype.startLocalStream = function (isVideoRequired, isAudioRequired, shouldAddTrackImmediately, userMediaPayload) {
+        var _a, _b;
+        if (shouldAddTrackImmediately === void 0) { shouldAddTrackImmediately = true; }
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_c) {
+                if (!this.meetingStartRequest) {
+                    log.error("meetingStartRequestObject not found");
+                    return [2 /*return*/];
+                }
+                if ((((_a = this.meetingStartRequest) === null || _a === void 0 ? void 0 : _a.isMobileApp) && !this.reactNativeWebrtcPlugin) || ((_b = this.communicationHandler) === null || _b === void 0 ? void 0 : _b.isReady()) === false) {
+                    log.error("Init method not called");
+                    return [2 /*return*/];
+                }
+                if (isVideoRequired === false && isAudioRequired === false) {
+                    return [2 /*return*/];
+                }
+                if (!this.userMediaHandler) {
+                    this.userMediaHandler = new UserMediaHandler(this.meetingStartRequest, this.communicationHandler);
+                }
+                this.userMediaHandler.startLocalStream(isVideoRequired, isAudioRequired, shouldAddTrackImmediately, userMediaPayload);
+                return [2 /*return*/];
+            });
+        });
+    };
+    MeetingHandler.prototype.startScreenShare = function (isAudioRequired, shouldAddTrackImmediately, screensharePayload) {
+        var _a, _b;
+        if (isAudioRequired === void 0) { isAudioRequired = false; }
+        if (shouldAddTrackImmediately === void 0) { shouldAddTrackImmediately = true; }
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_c) {
+                if (!this.meetingStartRequest) {
+                    log.error("meetingStartRequestObject not found");
+                    return [2 /*return*/];
+                }
+                if ((((_a = this.meetingStartRequest) === null || _a === void 0 ? void 0 : _a.isMobileApp) && !this.reactNativeWebrtcPlugin) || ((_b = this.communicationHandler) === null || _b === void 0 ? void 0 : _b.isReady()) === false) {
+                    log.error("Init method not called");
+                    return [2 /*return*/];
+                }
+                if (!this.userMediaHandler) {
+                    this.userMediaHandler = new UserMediaHandler(this.meetingStartRequest, this.communicationHandler);
+                }
+                this.userMediaHandler.startScreenShare(isAudioRequired, shouldAddTrackImmediately, screensharePayload);
+                return [2 /*return*/];
+            });
+        });
+    };
+    MeetingHandler.prototype.stopScreenSharing = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (this.userMediaHandler) {
+                    this.userMediaHandler.stopScreenSharing();
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    MeetingHandler.prototype.getDevices = function (deviceType) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_b) {
+                return [2 /*return*/, (_a = this.userMediaHandler) === null || _a === void 0 ? void 0 : _a.getDevice(deviceType)];
+            });
+        });
+    };
+    MeetingHandler.prototype.pauseCamera = function (userId) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_b) {
+                if (this.userMediaHandler) {
+                    return [2 /*return*/, (_a = this.userMediaHandler) === null || _a === void 0 ? void 0 : _a.pauseCamera(userId)];
+                }
+                return [2 /*return*/, new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+                        return __generator(this, function (_a) {
+                            resolve({ message: "User Media Handler not found", error: 'InvalidMeetingRequest', isSuccess: false });
+                            return [2 /*return*/];
+                        });
+                    }); })];
+            });
+        });
+    };
+    MeetingHandler.prototype.muteUser = function (userId) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_b) {
+                if (this.userMediaHandler) {
+                    return [2 /*return*/, (_a = this.userMediaHandler) === null || _a === void 0 ? void 0 : _a.muteUser(userId)];
+                }
+                return [2 /*return*/, new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+                        return __generator(this, function (_a) {
+                            resolve({ message: "User Media Handler not found", error: 'InvalidMeetingRequest', isSuccess: false });
+                            return [2 /*return*/];
+                        });
+                    }); })];
+            });
+        });
+    };
+    MeetingHandler.prototype.resumeCamera = function (userId) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_b) {
+                if (this.userMediaHandler) {
+                    return [2 /*return*/, (_a = this.userMediaHandler) === null || _a === void 0 ? void 0 : _a.resumeCamera(userId)];
+                }
+                return [2 /*return*/, new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+                        return __generator(this, function (_a) {
+                            resolve({ message: "User Media Handler not found", error: 'InvalidMeetingRequest', isSuccess: false });
+                            return [2 /*return*/];
+                        });
+                    }); })];
+            });
+        });
+    };
+    MeetingHandler.prototype.unmute = function (userId) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_b) {
+                if (this.userMediaHandler) {
+                    return [2 /*return*/, (_a = this.userMediaHandler) === null || _a === void 0 ? void 0 : _a.unmute(userId)];
+                }
+                return [2 /*return*/, new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+                        return __generator(this, function (_a) {
+                            resolve({ message: "User Media Handler not found", error: 'InvalidMeetingRequest', isSuccess: false });
+                            return [2 /*return*/];
+                        });
+                    }); })];
+            });
+        });
+    };
+    MeetingHandler.prototype.stopTrack = function (track) {
+        var _a;
+        (_a = this.communicationHandler) === null || _a === void 0 ? void 0 : _a.removeTrack(track);
+    };
+    MeetingHandler.prototype.addCustomTrack = function (track) {
+        var _a;
+        (_a = this.communicationHandler) === null || _a === void 0 ? void 0 : _a.addUpdateLocalTrack(track);
+    };
+    MeetingHandler.prototype.pauseIncomingTrack = function (track) {
+        var _a;
+        (_a = this.videoCallHandler) === null || _a === void 0 ? void 0 : _a.pauseIncomingTrack(track);
+    };
+    MeetingHandler.prototype.resumeIncomingTrack = function (track) {
+        var _a;
+        (_a = this.videoCallHandler) === null || _a === void 0 ? void 0 : _a.resumeIncomingTrack(track);
+    };
+    //Participant
+    MeetingHandler.prototype.participantByUserId = function (userId) {
+        var _a, _b, _c;
+        if (this.meetingStartRequest) {
+            if (userId === ((_a = this.meetingStartRequest) === null || _a === void 0 ? void 0 : _a.userId)) {
+                return (_b = this.communicationHandler) === null || _b === void 0 ? void 0 : _b.getSelfParticipant();
+            }
+            return (_c = this.communicationHandler) === null || _c === void 0 ? void 0 : _c.participantByUserId(userId);
+        }
+        return undefined;
+    };
+    MeetingHandler.prototype.updateParticipantData = function (participant) {
+        var _a;
+        var oldParticipant = this.participantByUserId(participant.userId);
+        if (oldParticipant) {
+            Object.assign(oldParticipant, participant);
+            (_a = this.websocketCallHandler) === null || _a === void 0 ? void 0 : _a.sendSocketMessage(WebSocketBasicEvents.UpdateParticipant, oldParticipant);
+        }
+        return oldParticipant;
+    };
+    MeetingHandler.prototype.getUpdatedParticipantsListFromServer = function () {
+        var _a;
+        (_a = this.communicationHandler) === null || _a === void 0 ? void 0 : _a.downloadParticipantsData();
+    };
+    MeetingHandler.prototype.getAllParticipants = function () {
+        if (this.communicationHandler) {
+            return this.communicationHandler.getAllParticipants();
+        }
+        else {
+            return [];
+        }
+    };
+    MeetingHandler.prototype.getAllTracks = function () {
+        if (this.communicationHandler) {
+            return this.communicationHandler.getAllTracks();
+        }
+        else {
+            return [];
+        }
+    };
+    MeetingHandler.prototype.getTracksByParticipantId = function (participantId) {
+        var participant = this.participantByUserId(participantId);
+        if (participant) {
+            if (this.communicationHandler) {
+                return this.communicationHandler.getAllTracksForParticipant(participant);
+            }
+        }
+        return [];
+    };
+    ///Messages
+    MeetingHandler.prototype.sendMessage = function (message) {
+        var _a, _b;
+        if (!message.sender) {
+            message.sender = (_a = this.communicationHandler) === null || _a === void 0 ? void 0 : _a.getSelfParticipant();
+        }
+        if (!message.sender || !this.meetingStartRequest) {
+            return { message: "Invalid Meeting Request", error: 'InvalidMeetingRequest', isSuccess: false };
+        }
+        message.senderUserId = message.sender.userId;
+        if (message.sender.isMessageBlockedByAdmin) {
+            return { message: "Blocked By Admin", error: 'BlockedByAdmin', isSuccess: false };
+        }
+        else {
+            var to = message.to === "all" ? this.meetingStartRequest.roomId : message.to;
+            var messageObj = { type: "chat", message: message.toJsonObjectForSending(), to: to, shouldPresist: message.shouldPresist };
+            (_b = this.websocketCallHandler) === null || _b === void 0 ? void 0 : _b.sendSocketMessage(WebSocketBasicEvents.Message, messageObj);
+            return { message: "Message Sent", error: 'NoError', isSuccess: true };
+        }
+    };
+    MeetingHandler.prototype.getOldMessages = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                log.info("getOldMessages");
+                if (this.websocketCallHandler) {
+                    this.websocketCallHandler.sendSocketMessage(WebSocketBasicEvents.GetOldMessages, {});
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    MeetingHandler.prototype.onOldMessages = function (data) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                log.info(data);
+                return [2 /*return*/];
+            });
+        });
+    };
+    MeetingHandler.prototype.checkSocket = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (!this.meetingStartRequest) {
+                    log.error("meetingStartRequestObject not found");
+                    return [2 /*return*/];
+                }
+                if (!this.websocketCallHandler) {
+                    log.error("Init method not called");
+                    return [2 /*return*/];
+                }
+                log.info("checkSocket");
+                this.websocketCallHandler.startSocketConnection();
+                return [2 /*return*/];
+            });
+        });
+    };
+    MeetingHandler.prototype.startMeeting = function () {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_b) {
+                (_a = this.communicationHandler) === null || _a === void 0 ? void 0 : _a.onStartMeeingCalled();
+                return [2 /*return*/];
+            });
+        });
+    };
+    MeetingHandler.prototype.getMeetingStartTime = function () {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function () {
+            var meetingStartTimeObject;
+            return __generator(this, function (_c) {
+                if (!this.meetingStartRequest) {
+                    log.error("meetingStartRequestObject not found");
+                    return [2 /*return*/];
+                }
+                if (!this.websocketCallHandler) {
+                    log.error("Init method not called");
+                    return [2 /*return*/];
+                }
+                meetingStartTimeObject = { type: WebSocketBasicEvents.GetMeetingStartTime, to: (_a = this.meetingStartRequest) === null || _a === void 0 ? void 0 : _a.userId };
+                (_b = this.websocketCallHandler) === null || _b === void 0 ? void 0 : _b.sendSocketMessage(WebSocketBasicEvents.GetMeetingStartTime, meetingStartTimeObject);
+                return [2 /*return*/];
+            });
+        });
+    };
+    MeetingHandler.prototype.getEventEmitter = function () {
+        var _a;
+        return (_a = this.communicationHandler) === null || _a === void 0 ? void 0 : _a.getEventEmitter();
+    };
+    MeetingHandler.prototype.emitMessageToSource = function (emitType, payload) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_b) {
+                (_a = this.communicationHandler) === null || _a === void 0 ? void 0 : _a.emitMessageToSource(emitType, payload);
+                return [2 /*return*/];
+            });
+        });
+    };
+    MeetingHandler.prototype.cleanup = function () {
+        var _a, _b, _c;
+        this.meetingStartRequest = undefined;
+        this.reactNativeWebrtcPlugin = undefined;
+        (_a = this.communicationHandler) === null || _a === void 0 ? void 0 : _a.cleanup();
+        this.communicationHandler = undefined;
+        (_b = this.videoCallHandler) === null || _b === void 0 ? void 0 : _b.cleanup();
+        this.videoCallHandler = undefined;
+        (_c = this.websocketCallHandler) === null || _c === void 0 ? void 0 : _c.cleanup();
+        this.websocketCallHandler = undefined;
+    };
+    MeetingHandler.prototype.handleGA = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/];
+            });
+        });
+    };
+    return MeetingHandler;
+}());
+export { MeetingHandler };

package/lib/base/Base.d.ts

@@ -0,0 +1,9 @@
+import { MeetingStartRequest } from "..";
+import { CommunicationHandler } from "../inter-communication-handler/CommunicationHandler";
+export declare abstract class Base {
+    protected meetingStartRequest?: MeetingStartRequest;
+    protected communicationHandler?: CommunicationHandler;
+    constructor(_meetingStartRequest: MeetingStartRequest, _communicationHandler: CommunicationHandler);
+    protected onObjectCreated(): void;
+    cleanup(): void;
+}

package/lib/base/Base.js

@@ -0,0 +1,18 @@
+import * as log from 'loglevel';
+var Base = /** @class */ (function () {
+    function Base(_meetingStartRequest, _communicationHandler) {
+        this.meetingStartRequest = _meetingStartRequest;
+        this.communicationHandler = _communicationHandler;
+        this.onObjectCreated();
+    }
+    Base.prototype.onObjectCreated = function () {
+        log.info("Object created");
+    };
+    Base.prototype.cleanup = function () {
+        this.communicationHandler = undefined;
+        this.meetingStartRequest = undefined;
+        log.info("cleanup");
+    };
+    return Base;
+}());
+export { Base };

package/lib/index.d.ts

@@ -0,0 +1,4 @@
+export * from './model/MessagePayload';
+export * from './model/MeetingStartRequest';
+export * from './MeetingHandler';
+export * from './model/Event';

package/lib/index.js

@@ -0,0 +1,4 @@
+export * from './model/MessagePayload';
+export * from './model/MeetingStartRequest';
+export * from './MeetingHandler';
+export * from './model/Event';