msg91-webrtc-call
Version:
**msg91-webrtc-call** is a lightweight JavaScript SDK that enables you to easily add peer-to-peer WebRTC audio/video calling functionality to your web applications using the MSG91 infrastructure.
500 lines (499 loc) • 19.9 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.WebRTC_EVENT = exports.CALL_EVENT = void 0;
const rtlayer_1 = require("./config/rtlayer");
const media_server_1 = require("./service/media-server");
const mediasoup_client_1 = require("mediasoup-client");
const util_1 = require("./util");
const call_1 = require("./type/call");
Object.defineProperty(exports, "CALL_EVENT", { enumerable: true, get: function () { return call_1.CALL_EVENT; } });
Object.defineProperty(exports, "WebRTC_EVENT", { enumerable: true, get: function () { return call_1.WebRTC_EVENT; } });
const event_emitter_1 = require("./util/event-emitter");
class CallManager extends event_emitter_1.EventEmitter {
constructor() {
super();
this.calls = new Map();
this.callListeners = new Map();
this.isSilent = false;
this.userStatus = call_1.USER_STATUS.IDLE;
this.ringtoneStatus = call_1.RINGTONE.STOP;
}
addCall(call) {
const info = call.getInfo();
const callId = info.id;
this.calls.set(callId, call);
this.updateUserStatus();
this.updateRingtoneStatus(this.userStatus);
const callConnectedListener = call.on(call_1.CALL_EVENT.CONNECTED, () => {
// Update the user status and ringtone status
this.updateUserStatus();
this.updateRingtoneStatus(this.userStatus);
});
const callEndedListener = call.on(call_1.CALL_EVENT.ENDED, () => {
// Cleanup the state for the call
this.updateUserStatus();
this.updateRingtoneStatus(this.userStatus);
this.removeCall(callId);
});
// Only for incoming calls
const callUnavailableListener = call.on(call_1.CALL_EVENT.UNAVAILABLE, () => {
// Mark the call as unavailable
this.updateUserStatus();
this.updateRingtoneStatus(this.userStatus);
this.removeCall(callId);
});
const callRejoinedListener = call.on(call_1.CALL_EVENT.REJOINED, () => {
this.updateUserStatus();
this.updateRingtoneStatus(this.userStatus);
// User rejoined the call
});
const callAnsweredListener = call.on(call_1.CALL_EVENT.ANSWERED, () => {
this.updateUserStatus();
this.updateRingtoneStatus(this.userStatus);
});
const callErrorListener = call.on(call_1.CALL_EVENT.ERROR, () => {
// Cleanup the state for the call
this.updateUserStatus();
this.updateRingtoneStatus(this.userStatus);
});
const callSilenceListener = call.on(call_1.CALL_EVENT.SILENCE_STATE, (data) => {
this.updateUserStatus();
this.updateRingtoneStatus(this.userStatus);
});
this.callListeners.set(callId, [callConnectedListener, callEndedListener, callUnavailableListener, callRejoinedListener, callAnsweredListener, callErrorListener, callSilenceListener]);
}
removeCall(callId) {
this.calls.delete(callId);
const listeners = this.callListeners.get(callId) || [];
listeners.forEach(listener => listener === null || listener === void 0 ? void 0 : listener.remove());
this.callListeners.delete(callId);
}
updateUserStatus() {
// Check if any call is in CONNECTED state
const isBusy = Array.from(this.calls.values()).some(call => call.getStatus() === call_1.CALL_STATUS.CONNECTED);
const currentStatus = isBusy ? call_1.USER_STATUS.BUSY : call_1.USER_STATUS.IDLE;
if (this.userStatus !== currentStatus) {
this.userStatus = currentStatus;
console.info("User status changed to:", this.userStatus);
}
}
updateRingtoneStatus(userStatus = this.userStatus) {
// Check if any incoming call is in RINGING state
const shouldRing = Array.from(this.calls.values()).some(call => {
const isRinging = call.getStatus() === call_1.CALL_STATUS.RINGING;
const isIncomingCall = call.getInfo().type === call_1.CALL_TYPE.INCOMING;
const isSilent = call.getInfo().silent == true;
return isRinging && isIncomingCall && !isSilent;
});
const isUserBusy = userStatus === call_1.USER_STATUS.BUSY;
let newRingtoneStatus = (shouldRing && !isUserBusy) ? call_1.RINGTONE.RING : call_1.RINGTONE.STOP;
if (this.isSilent)
newRingtoneStatus = call_1.RINGTONE.STOP; // Global silence
if (this.ringtoneStatus != newRingtoneStatus) {
this.ringtoneStatus = newRingtoneStatus;
console.info("Ringtone status changed to:", this.ringtoneStatus);
this.emit(call_1.CALL_MANAGER_EVENT.RINGTONE_STATUS_CHANGED, this.ringtoneStatus);
}
}
getCall(callId) {
return this.calls.get(callId);
}
silence(status = true) {
if (this.isSilent != status) {
this.isSilent = status;
this.updateUserStatus();
this.updateRingtoneStatus();
}
}
}
class WebRTC extends event_emitter_1.EventEmitter {
constructor(userToken) {
super();
this.status = 'idle';
this.callManager = new CallManager();
this.user = {};
this.userToken = userToken;
this.callManager.on(call_1.CALL_MANAGER_EVENT.RINGTONE_STATUS_CHANGED, (status) => {
if (status == call_1.RINGTONE.RING) {
this.emit(call_1.WebRTC_EVENT.PLAY_RINGTONE, {});
}
else {
this.emit(call_1.WebRTC_EVENT.STOP_RINGTONE, {});
}
});
(0, media_server_1.getUserData)(userToken).then((user) => {
this.user.id = user === null || user === void 0 ? void 0 : user.id;
this.user.name = user === null || user === void 0 ? void 0 : user.name;
rtlayer_1.default.on(`user:${this.user.id}:call`, (data) => {
data = JSON.parse(data);
let call = null;
data.token = this.callToken || data.callToken;
switch (data.type) {
case 'incoming-call':
call = new IncomingCall(this.user, userToken, data);
if (call)
this.emit(call_1.WebRTC_EVENT.INCOMING_CALL, call);
break;
case 'outgoing-call':
if (this.callId != data.id)
break;
call = new OutgoingCall(this.user, userToken, data);
if (call)
this.emit(call_1.WebRTC_EVENT.OUTGOING_CALL, call);
break;
default:
console.error("Invalid call type");
break;
}
if (call)
this.callManager.addCall(call);
if (call)
this.emit(call_1.WebRTC_EVENT.CALL, call);
});
console.log("USER REGISTERED : ", this.user);
}).catch((error) => {
console.error("USER REGISTRATION UN-SUCCESSFUL", error);
});
}
on(event, listener) {
return super.on(event, listener);
}
close() {
rtlayer_1.default.unsubscribe(`user:${this.user.id}:call`);
}
async call(callToken) {
let retryCount = 0;
while (!rtlayer_1.default.isOpen() && retryCount++ < 10) {
await new Promise(resolve => setTimeout(resolve, 300));
}
this.callToken = callToken;
const { id } = await (0, media_server_1.startNewCall)(callToken);
this.status = 'calling';
this.callId = id;
}
async rejoinCall(callId) {
this.callId = callId;
let retryCount = 0;
while (!rtlayer_1.default.isOpen() && retryCount++ < 10) {
await new Promise(resolve => setTimeout(resolve, 300));
}
const { id, message, error } = await (0, media_server_1.rejoinCall)(callId, this.userToken);
this.status = 'calling';
this.callId = id;
if (error) {
throw new Error(message);
}
}
async sendUserContext(data) {
if (!data)
return;
try {
await (0, media_server_1.sendUserContext)(this.userToken, Object.assign({ callId: this.callId }, data));
}
catch (error) {
console.error("Error sending user data:", error);
}
}
/**
*
* @param status Set global silence for incoming calls
*/
silence(status = true) {
this.callManager.silence(status);
}
}
class Call extends event_emitter_1.EventEmitter {
constructor(user, userToken, data) {
super();
this.existingCall = false;
this.status = call_1.CALL_STATUS.IDLE;
this.audioTrack = null;
this.rtlayerEvents = [];
this.setStatus(call_1.CALL_STATUS.RINGING);
this.userToken = userToken;
this.user = user;
this.id = data.id;
this.from = data.from;
this.to = data.to;
this.type = data.type;
this.producerTransport = data.producerTransport;
this.consumerTransport = data.consumerTransport;
this.routerRtpCapabilities = data.routerRtpCapabilities;
this.device = new mediasoup_client_1.Device();
this.mediaStream = new MediaStream();
this.existingCall = (data === null || data === void 0 ? void 0 : data.status) == 'connected' ? true : false;
}
on(event, listener) {
return super.on(event, listener);
}
addEvent(callback) {
this.rtlayerEvents.push(callback);
}
async setStatus(status) {
this.status = status;
}
getStatus() {
return this.status;
}
getMediaStream() {
return this.mediaStream;
}
isExistingCall() {
return this.existingCall;
}
mute() {
if (this.audioTrack) {
this.audioTrack.enabled = false;
this.emit(call_1.CALL_EVENT.MUTE, { uid: this.user.id });
}
}
unmute() {
if (this.audioTrack) {
this.audioTrack.enabled = true;
this.emit(call_1.CALL_EVENT.UNMUTE, { uid: this.user.id });
}
}
// Disconnect the connected call
hang(data) {
var _a;
(_a = this.audioTrack) === null || _a === void 0 ? void 0 : _a.stop();
this.audioTrack = null;
this.mediaStream.getTracks().forEach(track => track === null || track === void 0 ? void 0 : track.stop());
this.mediaStream = new MediaStream();
this.setStatus(call_1.CALL_STATUS.ENDED);
const eventData = data || this.getInfo();
this.emit(call_1.CALL_EVENT.ENDED, eventData);
(0, media_server_1.endCall)(this.id, this.userToken);
if (this.producer)
this.producer.close();
setTimeout(() => {
this.rtlayerEvents.forEach((event) => event === null || event === void 0 ? void 0 : event.remove());
}, 2000);
}
getInfo() {
return {
id: this.id,
from: this.from,
to: this.to,
type: this.type,
};
}
async setupCall() {
await this.device.load({ routerRtpCapabilities: this.routerRtpCapabilities });
const pTransport = this.device.createSendTransport(this.producerTransport);
const cTransport = this.device.createRecvTransport(this.consumerTransport);
pTransport.on('connect', async ({ dtlsParameters }, callback, errback) => {
try {
console.log("----------> producer transport has connected");
// Notify the server that the transport is ready to connect with the provided DTLS parameters
// socket.emit("connectProducerTransport", { dtlsParameters });
await (0, media_server_1.joinCall)(this.user.id, this.id, dtlsParameters, "producer");
// Callback to indicate success
callback();
}
catch (error) {
// Errback to indicate failure
errback(error);
}
});
pTransport.on("produce", async (parameters, callback, errback) => {
const { kind, rtpParameters } = parameters;
console.log("----------> transport-produce");
try {
// Notify the server to start producing media with the provided parameters
const response = await (0, media_server_1.startProducing)(this.user.id, this.id, kind, rtpParameters);
console.log(response);
callback({ id: response.id });
// socket.emit(
// "transport-produce",
// { kind, rtpParameters },
// ({ id }: any) => {
// // Callback to provide the server-generated producer ID back to the transport
// callback({ id });
// }
// );
}
catch (error) {
// Errback to indicate failure
errback(error);
}
});
cTransport.on('connect', async ({ dtlsParameters }, callback, errback) => {
try {
console.log("----------> consumer transport has connected");
// Notify the server that the transport is ready to connect with the provided DTLS parameters
// socket.emit("connectProducerTransport", { dtlsParameters });
await (0, media_server_1.joinCall)(this.user.id, this.id, dtlsParameters, "consumer");
// Callback to indicate success
callback();
}
catch (error) {
// Errback to indicate failure
errback(error);
}
});
const consumerEvents = rtlayer_1.default.on(`user:${this.user.id}:call:${this.id}:consume`, async (data) => {
data = JSON.parse(data);
let consumer = await cTransport.consume({
id: data.id,
producerId: data.producerId,
kind: data.kind,
rtpParameters: data.rtpParameters
});
console.log("----------> consumer created");
if (!consumer)
return;
const { track } = consumer;
console.log("TRACK", track);
this.mediaStream.addTrack(track);
this.emit(call_1.CALL_EVENT.CONNECTED, this.mediaStream);
});
this.rtlayerEvents.push(consumerEvents);
try {
let stream = await navigator.mediaDevices.getUserMedia({
audio: true,
// video: true,
});
const audioTrack = stream === null || stream === void 0 ? void 0 : stream.getAudioTracks()[0];
this.audioTrack = audioTrack;
this.producer = await pTransport.produce({
track: audioTrack,
});
}
catch (error) {
this.emit(call_1.CALL_EVENT.ERROR, { message: "Unable to access microphone", error: error });
}
}
}
class IncomingCall extends Call {
constructor(user, userToken, data) {
super(user, userToken, data);
this.isUnavailable = false;
this.isSilent = false;
if (this.existingCall) {
this.rejoin(data);
}
const callEvents = rtlayer_1.default.on(`call:${data.id}`, (data) => {
var _a;
data = JSON.parse(data);
switch (data.type) {
case 'call-ended': {
super.hang(data);
break;
}
case 'call-answered': {
if (((_a = data.answeredBy) === null || _a === void 0 ? void 0 : _a.id) != user.id) {
this.isUnavailable = true;
this.setStatus(call_1.CALL_STATUS.ENDED); // Mark call as ended for this user
this.emit(call_1.CALL_EVENT.UNAVAILABLE, data);
}
else {
this.setStatus(call_1.CALL_STATUS.CONNECTED);
this.emit(call_1.CALL_EVENT.ANSWERED, data);
}
break;
}
default: {
console.error("Invalid call type");
return;
}
}
});
this.addEvent(callEvents);
}
rejoin(data) {
this.isUnavailable = false;
super.setupCall();
super.setStatus(call_1.CALL_STATUS.CONNECTED);
setTimeout(() => {
this.emit(call_1.CALL_EVENT.REJOINED, data);
}, 100);
}
accept() {
if (this.isUnavailable)
return;
if (this.existingCall)
return;
super.setupCall();
super.setStatus(call_1.CALL_STATUS.CONNECTED);
}
silence(status = true) {
if (this.isSilent != status) {
this.isSilent = status;
this.emit(call_1.CALL_EVENT.SILENCE_STATE, { 'silent': status });
}
}
getInfo() {
const info = super.getInfo();
return Object.assign(Object.assign({}, info), { 'silent': this.isSilent });
}
reject() {
super.hang();
}
}
class OutgoingCall extends Call {
constructor(user, userToken, data) {
super(user, userToken, data);
if (this.existingCall) {
this.rejoin(data);
}
super.setupCall();
const callEvents = rtlayer_1.default.on(`call:${data.id}`, (data) => {
data = JSON.parse(data);
switch (data.type) {
case 'call-ended': {
super.hang(data);
break;
}
case 'call-answered': {
this.emit(call_1.CALL_EVENT.ANSWERED, data);
if (this.getStatus() == call_1.CALL_STATUS.CONNECTED)
return;
this.setStatus(call_1.CALL_STATUS.CONNECTED);
break;
}
default: {
console.error("Invalid call type");
return;
}
}
});
this.addEvent(callEvents);
const botEvents = rtlayer_1.default.on(`user:${this.user.id}:call:${this.id}:bot`, (data) => {
data = JSON.parse(data);
if (data.type == "message") {
this.emit(call_1.CALL_EVENT.MESSAGE, { message: data === null || data === void 0 ? void 0 : data.message, from: (data === null || data === void 0 ? void 0 : data.from) || "bot" });
}
});
this.addEvent(botEvents);
}
rejoin(data) {
// Join the call without ringing
// Hydrate call details by triggering rejoin event
setTimeout(() => {
this.emit(call_1.CALL_EVENT.REJOINED, data);
super.setStatus(call_1.CALL_STATUS.CONNECTED);
}, 100);
}
cancel() {
super.hang();
}
async sendMessage(message, isContext) {
if (!message.length)
return;
try {
await (0, media_server_1.sendMessage)(this.userToken, this.id, { message, isContext });
}
catch (error) {
console.error("Error sending message:", error);
}
}
}
let webrtc = new Map();
exports.default = (userToken, env = "prod") => {
(0, util_1.setEnvironment)(env);
if (webrtc.has(userToken))
return webrtc.get(userToken);
webrtc.set(userToken, new WebRTC(userToken));
return webrtc.get(userToken);
};