skapi-js 1.0.187-beta.4 → 1.0.188-beta.1

package/js/methods/webrtc.js

@@ -1,4 +1,5 @@
 import { SkapiError } from "../Main";
+import { extractFormData } from "../utils/utils";
 import validator from "../utils/validator";
 export const __peerConnection = {};
 export const __dataChannel = {};
@@ -13,51 +14,62 @@ function setBuffer(buffer, recipient, item) {
     }
     buffer[recipient].push(item);
 }
-function processBuffer(buffer, recipient, fn) {
+async function processBuffer(buffer, recipient, fn) {
     let proceed = [];
     if (buffer[recipient]) {
-        buffer[recipient].forEach(v => {
-            if (v)
-                proceed.push(fn(v));
-        });
+        for (let v of buffer[recipient]) {
+            if (v) {
+                let process = fn(v);
+                if (process instanceof Promise) {
+                    process = await process;
+                }
+                proceed.push(process);
+            }
+        }
+        ;
         delete buffer[recipient];
     }
     return proceed;
 }
 export async function answerSdpOffer(offer, recipient) {
-    this.log('answerSdpOffer', offer);
     if (!this?.session?.accessToken?.jwtToken) {
         throw new SkapiError('Access token is required.', { code: 'INVALID_PARAMETER' });
     }
     let socket = await this.__socket;
+    async function sendAnswer(offer, recipient, socket) {
+        this.log('answerSdpOffer from', recipient);
+        await __peerConnection[recipient].setRemoteDescription(new RTCSessionDescription(offer));
+        const answer = await __peerConnection[recipient].createAnswer();
+        await __peerConnection[recipient].setLocalDescription(answer);
+        socket.send(JSON.stringify({
+            action: 'rtc',
+            uid: recipient,
+            content: { sdpanswer: answer },
+            token: this.session.accessToken.jwtToken
+        }));
+    }
     if (__peerConnection?.[recipient]) {
         if (!offer) {
-            return processBuffer(__rtcSdpOfferBuffer, recipient, (offer) => answerSdpOffer.bind(this)(offer, recipient));
+            await processBuffer(__rtcSdpOfferBuffer, recipient, (offer) => sendAnswer.bind(this)(offer, recipient, socket));
+        }
+        else {
+            await processBuffer(__rtcSdpOfferBuffer, recipient, (offer) => sendAnswer.bind(this)(offer, recipient, socket));
+            await sendAnswer.bind(this)(offer, recipient, socket);
         }
     }
     else {
         if (offer) {
-            return setBuffer(__rtcSdpOfferBuffer, recipient, offer);
+            setBuffer(__rtcSdpOfferBuffer, recipient, offer);
         }
     }
-    await Promise.all(processBuffer(__rtcSdpOfferBuffer, recipient, (offer) => answerSdpOffer.bind(this)(offer, recipient)));
-    await __peerConnection[recipient].setRemoteDescription(new RTCSessionDescription(offer));
-    const answer = await __peerConnection[recipient].createAnswer();
-    await __peerConnection[recipient].setLocalDescription(answer);
-    socket.send(JSON.stringify({
-        action: 'rtc',
-        uid: recipient,
-        content: { sdpanswer: answer },
-        token: this.session.accessToken.jwtToken
-    }));
 }
 export async function receiveIceCandidate(candidate, recipient) {
     this.log('receiveIceCandidate', candidate);
     if (__peerConnection?.[recipient] && __peerConnection[recipient]?.remoteDescription && __peerConnection[recipient]?.remoteDescription?.type) {
         if (!candidate) {
-            return processBuffer(__rtcCandidatesBuffer, recipient, (candidate) => receiveIceCandidate.bind(this)(candidate, recipient));
+            return processBuffer(__rtcCandidatesBuffer, recipient, (candidate) => __peerConnection[recipient].addIceCandidate(candidate));
         }
-        await Promise.all(processBuffer(__rtcCandidatesBuffer, recipient, (candidate) => receiveIceCandidate.bind(this)(candidate, recipient)));
+        await processBuffer(__rtcCandidatesBuffer, recipient, (candidate) => __peerConnection[recipient].addIceCandidate(candidate));
         await __peerConnection[recipient].addIceCandidate(candidate);
     }
     else {
@@ -66,81 +78,93 @@ export async function receiveIceCandidate(candidate, recipient) {
 }
 export async function closeRTC(params) {
     validator.Params(params, {
-        recipient: v => validator.UserId(v),
+        cid: v => {
+            if (v && typeof v !== 'string') {
+                throw new SkapiError(`"cid" should be type: <string>.`, { code: 'INVALID_PARAMETER' });
+            }
+            if (v && v.slice(0, 4) !== 'cid:') {
+                throw new SkapiError(`"cid" should be a valid connection id.`, { code: 'INVALID_PARAMETER' });
+            }
+            return v;
+        },
         close: 'boolean'
     });
     let socket = await this.__socket;
-    let { recipient, closeAll = false } = params || {};
-    if (!closeAll && !recipient) {
-        throw new SkapiError(`"recipient" is required.`, { code: 'INVALID_PARAMETER' });
+    let { cid, close_all = false } = params || {};
+    if (!close_all && !cid) {
+        throw new SkapiError(`"cid" is required.`, { code: 'INVALID_PARAMETER' });
     }
-    function close(recipient) {
-        if (!recipient) {
-            throw new SkapiError(`"recipient" is required.`, { code: 'INVALID_PARAMETER' });
+    let close = (cid) => {
+        if (!cid) {
+            throw new SkapiError(`"cid" is required.`, { code: 'INVALID_PARAMETER' });
         }
-        delete __rtcSdpOfferBuffer[recipient];
-        delete __rtcCandidatesBuffer[recipient];
-        if (__dataChannel[recipient]) {
-            Object.values(__dataChannel[recipient]).forEach(channel => {
+        delete __rtcSdpOfferBuffer[cid];
+        delete __rtcCandidatesBuffer[cid];
+        if (__dataChannel[cid]) {
+            Object.values(__dataChannel[cid]).forEach(channel => {
                 if (channel.readyState !== 'closed') {
                     channel.close();
                 }
             });
-            delete __dataChannel[recipient];
         }
-        if (__peerConnection?.[recipient]) {
-            if (__peerConnection[recipient].connectionState !== 'closed') {
-                __peerConnection[recipient].close();
+        delete __dataChannel[cid];
+        if (__peerConnection?.[cid]) {
+            if (__peerConnection[cid].connectionState !== 'closed') {
+                __peerConnection[cid].close();
                 socket.send(JSON.stringify({
                     action: 'rtc',
-                    uid: recipient,
+                    uid: cid,
                     content: { hungup: this.user.user_id },
                     token: this.session.accessToken.jwtToken
                 }));
             }
             let msg = {
                 type: 'connectionstatechange',
-                target: __peerConnection[recipient],
+                target: __peerConnection[cid],
                 timestamp: new Date().toISOString(),
-                state: __peerConnection[recipient].connectionState,
-                iceState: __peerConnection[recipient].iceConnectionState,
-                signalingState: __peerConnection[recipient].signalingState
+                state: __peerConnection[cid].connectionState,
+                iceState: __peerConnection[cid].iceConnectionState,
+                signalingState: __peerConnection[cid].signalingState
             };
-            if (__rtcCallbacks[recipient]) {
-                __rtcCallbacks[recipient](msg);
+            if (__rtcCallbacks[cid]) {
+                __rtcCallbacks[cid](msg);
             }
-            delete __rtcCallbacks[recipient];
-            delete __receiver_ringing[recipient];
-            delete __caller_ringing[recipient];
             this.log('closeRTC', msg);
         }
-        delete __peerConnection[recipient];
-    }
-    if (closeAll) {
+        delete __rtcCallbacks[cid];
+        delete __receiver_ringing[cid];
+        delete __caller_ringing[cid];
+        delete __peerConnection[cid];
+    };
+    if (close_all) {
         for (let key in __peerConnection) {
-            close.bind(this)(key);
+            close(key);
         }
     }
     else {
-        close.bind(this)(recipient);
+        close(cid);
     }
 }
 export async function connectRTC(params, callback) {
     if (typeof callback !== 'function') {
         throw new SkapiError(`Callback is required.`, { code: 'INVALID_PARAMETER' });
     }
-    let socket = this.__socket ? await this.__socket : this.__socket;
-    if (!socket) {
-        throw new SkapiError(`No realtime connection. Execute connectRealtime() before this method.`, { code: 'INVALID_REQUEST' });
-    }
     if (!this?.session?.accessToken?.jwtToken) {
         throw new SkapiError('Access token is required.', { code: 'INVALID_PARAMETER' });
     }
     params = validator.Params(params, {
-        recipient: 'string',
+        cid: v => {
+            if (typeof v !== 'string') {
+                throw new SkapiError(`"cid" should be type: <string>.`, { code: 'INVALID_PARAMETER' });
+            }
+            if (v.slice(0, 4) !== 'cid:') {
+                throw new SkapiError(`"cid" should be a valid connection id.`, { code: 'INVALID_PARAMETER' });
+            }
+            return v;
+        },
         ice: ['string', () => 'stun:stun.skapi.com:3468'],
-        mediaStream: v => v,
-        dataChannelSettings: ['text-chat', 'file-transfer', 'video-chat', 'voice-chat', {
+        media: v => v,
+        channels: ['text-chat', 'file-transfer', 'video-chat', 'voice-chat', 'gaming', {
                 ordered: 'boolean',
                 maxPacketLifeTime: 'number',
                 maxRetransmits: 'number',
@@ -148,142 +172,140 @@ export async function connectRTC(params, callback) {
             }, () => {
                 return [{ ordered: true, maxPacketLifeTime: 10, protocol: 'default' }];
             }]
-    }, ['recipient']);
-    let { recipient, ice } = params;
-    if (!(params?.mediaStream instanceof MediaStream)) {
-        if (params?.mediaStream?.video || params?.mediaStream?.audio) {
+    }, ['cid']);
+    let { cid, ice } = params;
+    if (!(params?.media instanceof MediaStream)) {
+        if (params?.media?.video || params?.media?.audio) {
             if (location.hostname !== 'localhost' && location.protocol !== 'https:') {
                 throw new SkapiError(`Media stream is only supported on either localhost or https.`, { code: 'INVALID_REQUEST' });
             }
         }
     }
-    if (socket.readyState === 1) {
-        const configuration = {
-            iceServers: [
-                { urls: ice }
-            ]
-        };
-        if (!__peerConnection?.[recipient]) {
-            __peerConnection[recipient] = new RTCPeerConnection(configuration);
+    let socket = this.__socket ? await this.__socket : this.__socket;
+    if (!socket) {
+        throw new SkapiError(`No realtime connection. Execute connectRealtime() before this method.`, { code: 'INVALID_REQUEST' });
+    }
+    if (socket.readyState !== 1) {
+        throw new SkapiError('Realtime connection is not ready.', { code: 'INVALID_REQUEST' });
+    }
+    const configuration = {
+        iceServers: [
+            { urls: ice }
+        ]
+    };
+    if (!__peerConnection?.[cid]) {
+        __peerConnection[cid] = new RTCPeerConnection(configuration);
+    }
+    if (params?.media) {
+        if (params?.media instanceof MediaStream || this.__mediaStream) {
+            this.__mediaStream = this.__mediaStream || params.media;
         }
-        if (params?.mediaStream) {
-            if (params?.mediaStream instanceof MediaStream) {
-                this.__mediaStream = params.mediaStream;
-            }
-            else {
-                if (params?.mediaStream?.video || params?.mediaStream?.audio) {
-                    this.__mediaStream = await navigator.mediaDevices.getUserMedia({
-                        video: params?.mediaStream?.video,
-                        audio: params?.mediaStream?.audio
-                    });
-                }
-            }
-            if (this.__mediaStream)
-                this.__mediaStream.getTracks().forEach(track => {
-                    __peerConnection[recipient].addTrack(track, this.__mediaStream);
+        else {
+            if (params?.media?.video || params?.media?.audio) {
+                this.__mediaStream = await navigator.mediaDevices.getUserMedia({
+                    video: params?.media?.video,
+                    audio: params?.media?.audio
                 });
-        }
-        __rtcCallbacks[recipient] = callback;
-        if (!__dataChannel[recipient]) {
-            __dataChannel[recipient] = {};
-        }
-        for (let i = 0; i < params.dataChannelSettings.length; i++) {
-            let options = params.dataChannelSettings[i];
-            if (typeof options === 'string') {
-                switch (options) {
-                    case 'text-chat':
-                        options = { ordered: true, maxRetransmits: 10, protocol: 'text-chat' };
-                        break;
-                    case 'file-transfer':
-                        options = { ordered: false, maxPacketLifeTime: 3000, protocol: 'file-transfer' };
-                        break;
-                    case 'video-chat':
-                        options = { ordered: true, maxPacketLifeTime: 10, protocol: 'video-chat' };
-                        break;
-                    case 'voice-chat':
-                        options = { ordered: true, maxPacketLifeTime: 10, protocol: 'voice-chat' };
-                        break;
-                    default:
-                        options = { ordered: true, maxRetransmits: 10, protocol: 'default' };
-                        break;
-                }
             }
-            let protocol = params.dataChannelSettings[i].protocol || 'default';
-            if (Object.keys(__dataChannel[recipient]).includes(protocol)) {
-                throw new SkapiError(`Data channel with the protocol "${protocol}" already exists.`, { code: 'INVALID_REQUEST' });
+        }
+        if (this.__mediaStream)
+            this.__mediaStream.getTracks().forEach(track => {
+                __peerConnection[cid].addTrack(track, this.__mediaStream);
+            });
+    }
+    __rtcCallbacks[cid] = callback;
+    if (!__dataChannel[cid]) {
+        __dataChannel[cid] = {};
+    }
+    for (let i = 0; i < params.channels.length; i++) {
+        let options = params.channels[i];
+        if (typeof options === 'string') {
+            switch (options) {
+                case 'text-chat':
+                    options = { ordered: true, maxRetransmits: 10, protocol: 'text-chat' };
+                    break;
+                case 'file-transfer':
+                    options = { ordered: false, maxPacketLifeTime: 3000, protocol: 'file-transfer' };
+                    break;
+                case 'video-chat':
+                    options = { ordered: true, maxRetransmits: 10, protocol: 'video-chat' };
+                    break;
+                case 'voice-chat':
+                    options = { ordered: true, maxRetransmits: 10, protocol: 'voice-chat' };
+                    break;
+                case 'gaming':
+                    options = { ordered: false, maxPacketLifeTime: 100, protocol: 'gaming' };
+                    break;
+                default:
+                    options = { ordered: true, maxRetransmits: 10, protocol: 'default' };
+                    break;
             }
-            let dataChannel = __peerConnection[recipient].createDataChannel(protocol, options);
-            __dataChannel[recipient][protocol] = dataChannel;
         }
-        for (let key in __dataChannel[recipient]) {
-            let dataChannel = __dataChannel[recipient][key];
-            handleDataChannel.bind(this)(recipient, dataChannel);
+        let protocol = options.protocol || 'default';
+        if (Object.keys(__dataChannel[cid]).includes(protocol)) {
+            throw new SkapiError(`Data channel with the protocol "${protocol}" already exists.`, { code: 'INVALID_REQUEST' });
         }
-        peerConnectionHandler.bind(this)(recipient, ['onnegotiationneeded']);
-        await sendOffer.bind(this)(recipient);
-        return new Promise((resolve, reject) => {
-            __caller_ringing[recipient] = ((proceed) => {
-                this.log('receiver picked up the call', recipient);
+        let dataChannel = __peerConnection[cid].createDataChannel(protocol, options);
+        __dataChannel[cid][protocol] = dataChannel;
+    }
+    for (let key in __dataChannel[cid]) {
+        let dataChannel = __dataChannel[cid][key];
+        handleDataChannel.bind(this)(cid, dataChannel);
+    }
+    peerConnectionHandler.bind(this)(cid, ['onnegotiationneeded']);
+    await sendOffer.bind(this)(cid);
+    return {
+        hangup: () => __caller_ringing[cid] && __caller_ringing[cid](false),
+        connection: new Promise(resolve => {
+            __caller_ringing[cid] = ((proceed) => {
+                this.log('receiver picked up the call', cid);
                 if (!proceed) {
-                    resolve(null);
-                    return;
+                    closeRTC.bind(this)({ cid: cid });
+                    return null;
                 }
-                __peerConnection[recipient].onnegotiationneeded = (() => {
-                    sendOffer.bind(this)(recipient);
-                    if (__rtcCallbacks[recipient])
-                        __rtcCallbacks[recipient]({
+                __peerConnection[cid].onnegotiationneeded = () => {
+                    this.log('onnegotiationneeded', `Sending offer to "${cid}".`);
+                    sendOffer.bind(this)(cid);
+                    if (__rtcCallbacks[cid])
+                        __rtcCallbacks[cid]({
                             type: 'negotiationneeded',
-                            target: __peerConnection[recipient],
+                            target: __peerConnection[cid],
                             timestamp: new Date().toISOString(),
-                            signalingState: __peerConnection[recipient].signalingState,
-                            connectionState: __peerConnection[recipient].iceConnectionState,
-                            gatheringState: __peerConnection[recipient].iceGatheringState
+                            signalingState: __peerConnection[cid].signalingState,
+                            connectionState: __peerConnection[cid].iceConnectionState,
+                            gatheringState: __peerConnection[cid].iceGatheringState
                         });
-                }).bind(this);
+                };
                 resolve({
-                    target: __peerConnection[recipient],
-                    dataChannel: __dataChannel[recipient],
-                    hangup: (() => {
-                        closeRTC.bind(this)({ recipient });
-                    }).bind(this),
-                    mediaStream: this.__mediaStream
+                    target: __peerConnection[cid],
+                    channels: __dataChannel[cid],
+                    hangup: () => closeRTC.bind(this)({ cid: cid }),
+                    media: this.__mediaStream
                 });
             }).bind(this);
-            ;
-        });
-    }
-    else {
-        throw new SkapiError('Realtime connection is not ready.', { code: 'INVALID_REQUEST' });
-    }
+        })
+    };
 }
 export function respondRTC(msg) {
     return async (params, callback) => {
-        let rtc = msg.message;
-        let sender = msg.sender;
+        params = params || {};
+        params = extractFormData(params).data;
+        let sender = msg.sender_cid;
+        let socket = await this.__socket;
         if (!__receiver_ringing[sender]) {
             return null;
         }
         if (typeof callback !== 'function') {
             throw new SkapiError(`Callback is required.`, { code: 'INVALID_PARAMETER' });
         }
-        if (!(params?.mediaStream instanceof MediaStream)) {
-            if (params?.mediaStream?.video || params?.mediaStream?.audio) {
+        if (!(params?.media instanceof MediaStream)) {
+            if (params?.media?.video || params?.media?.audio) {
                 if (location.hostname !== 'localhost' && location.protocol !== 'https:') {
                     throw new SkapiError(`Media stream is only supported on either localhost or https.`, { code: 'INVALID_REQUEST' });
                 }
             }
         }
-        let socket = await this.__socket;
-        if (params?.hangup) {
-            socket.send(JSON.stringify({
-                action: 'rtc',
-                uid: sender,
-                content: { hungup: this.user.user_id },
-                token: this.session.accessToken.jwtToken
-            }));
-            return null;
-        }
-        let { ice = 'stun:stun.skapi.com:3468' } = params || {};
+        let { ice = 'stun:stun.skapi.com:3468' } = params;
         if (!__peerConnection?.[sender]) {
             __peerConnection[sender] = new RTCPeerConnection({
                 iceServers: [
@@ -291,15 +313,15 @@ export function respondRTC(msg) {
                 ]
             });
         }
-        if (params?.mediaStream) {
-            if (params?.mediaStream instanceof MediaStream) {
-                this.__mediaStream = params.mediaStream;
+        if (params?.media) {
+            if (params?.media instanceof MediaStream || this.__mediaStream) {
+                this.__mediaStream = this.__mediaStream || params.media;
             }
             else {
-                if (params?.mediaStream?.video || params?.mediaStream?.audio)
+                if (params?.media?.video || params?.media?.audio)
                     this.__mediaStream = await navigator.mediaDevices.getUserMedia({
-                        video: params?.mediaStream?.video,
-                        audio: params?.mediaStream?.audio
+                        video: params?.media?.video,
+                        audio: params?.media?.audio
                     });
             }
             if (this.__mediaStream)
@@ -319,8 +341,8 @@ export function respondRTC(msg) {
             handleDataChannel.bind(this)(sender, dataChannel);
         };
         peerConnectionHandler.bind(this)(sender, ['onnegotiationneeded']);
-        await answerSdpOffer.bind(this)(rtc?.sdpoffer, sender);
-        await receiveIceCandidate.bind(this)(rtc?.candidate, sender);
+        await answerSdpOffer.bind(this)(null, sender);
+        await receiveIceCandidate.bind(this)(null, sender);
         socket.send(JSON.stringify({
             action: 'rtc',
             uid: sender,
@@ -329,11 +351,9 @@ export function respondRTC(msg) {
         }));
         return {
             target: __peerConnection[sender],
-            dataChannel: __dataChannel[sender],
-            hangup: (() => {
-                closeRTC.bind(this)({ recipient: sender });
-            }).bind(this),
-            mediaStream: this.__mediaStream
+            channels: __dataChannel[sender],
+            hangup: () => closeRTC.bind(this)({ cid: sender }),
+            media: this.__mediaStream
         };
     };
 }
@@ -341,12 +361,12 @@ async function sendOffer(recipient) {
     if (!this?.session?.accessToken?.jwtToken) {
         throw new SkapiError('Access token is required.', { code: 'INVALID_PARAMETER' });
     }
+    this.log('sendOffer', recipient);
     let socket = await this.__socket;
     const offer = await __peerConnection[recipient].createOffer();
     await __peerConnection[recipient].setLocalDescription(offer);
     let sdpoffer = __peerConnection[recipient].localDescription;
-    this.log('rtcSdpOffer', sdpoffer);
-    validator.UserId(recipient);
+    this.log('rtcSdpOffer to:', sdpoffer);
     socket.send(JSON.stringify({
         action: 'rtc',
         uid: recipient,
@@ -355,10 +375,10 @@ async function sendOffer(recipient) {
     }));
 }
 async function sendIceCandidate(event, recipient) {
-    if (this?.session?.accessToken?.jwtToken) {
+    if (!this?.session?.accessToken?.jwtToken) {
         throw new SkapiError('Access token is required.', { code: 'INVALID_PARAMETER' });
     }
-    validator.UserId(recipient);
+    this.log('sendIceCandidate to:', recipient);
     let socket = await this.__socket;
     if (!event.candidate) {
         this.log('candidate-end', 'All ICE candidates have been sent');
@@ -485,13 +505,13 @@ function peerConnectionHandler(key, skipKey) {
             });
             let state = peer.connectionState;
             if (state === 'disconnected' || state === 'failed' || state === 'closed') {
-                closeRTC.bind(this)({ recipient: key });
+                closeRTC.bind(this)({ cid: key });
             }
         }
     };
     for (const [event, handler] of Object.entries(handlers)) {
         if (!skip.has(event)) {
-            peer[event] = handler.bind(this);
+            peer[event] = handler;
         }
     }
 }
@@ -540,7 +560,7 @@ function handleDataChannel(key, dataChannel, skipKey) {
             if (__dataChannel[key]) {
                 delete __dataChannel[key][dataChannel.label];
                 if (Object.keys(__dataChannel[key]).length === 0) {
-                    closeRTC.bind(this)({ recipient: key });
+                    closeRTC.bind(this)({ cid: key });
                 }
             }
         },
@@ -573,7 +593,7 @@ function handleDataChannel(key, dataChannel, skipKey) {
     };
     for (const [event, handler] of Object.entries(events)) {
         if (!skip.has(event)) {
-            dataChannel[event] = handler.bind(this);
+            dataChannel[event] = handler;
         }
     }
 }