@wazo/sdk 0.43.6 → 1.0.0-alpha.1

package/lib/utils/webrtc.js

@@ -1,6 +1,67 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseCandidate = void 0;
+exports.fetchNetworkStats = exports.upgradeToVideo = exports.downgradeToAudio = exports.createUaOptions = exports.getStreamFromConstraints = exports.getMediaConfiguration = exports.getVideoConstraints = exports.getAudioConstraints = exports.isAudioOnly = exports.updateRemoteStream = exports.setLocalMediaStream = exports.cleanupStream = exports.toggleVideo = exports.toggleAudio = exports.getWebRtcStats = exports.sessionWantsToDoVideo = exports.hasAVideoTrack = exports.hasVideoTrack = exports.getRemoteVideoStreamFromPc = exports.getRemoteVideoStream = exports.hasARemoteVideoTrack = exports.hasRemoteVideo = exports.isVideoRemotelyHeld = exports.getRemoteTracks = exports.getLocalVideoStream = exports.hasALocalVideoTrack = exports.hasLocalVideo = exports.isVideoTrack = exports.getRemoteStream = exports.getLocalTracks = exports.getLocalStream = exports.getPeerConnection = exports.parseCandidate = exports.getIceServers = exports.isAPrivateIp = exports.isFirefox = exports.isWeb = void 0;
+const peer_connection_configuration_default_1 = require("sip.js/lib/platform/web/session-description-handler/peer-connection-configuration-default");
+const web_1 = require("sip.js/lib/platform/web");
+const WazoSessionDescriptionHandler_1 = __importStar(require("../lib/WazoSessionDescriptionHandler"));
+const sdp_1 = require("./sdp");
+const IssueReporter_1 = __importDefault(require("../service/IssueReporter"));
+const array_1 = require("./array");
+const logger = IssueReporter_1.default.loggerFor('webrtc');
+// setting a 24hr timeout and letting the backend define the actual value
+const NO_ANSWER_TIMEOUT = 60 * 60 * 24; // in seconds
+const DEFAULT_ICE_TIMEOUT = 3000;
+const privateIpRegex = /^(?:10|127|172\.(?:1[6-9]|2[0-9]|3[01])|192\.168)\..*/;
+const isWeb = () => typeof window === 'object' && typeof document === 'object';
+exports.isWeb = isWeb;
+const isFirefox = () => (0, exports.isWeb)() && navigator.userAgent.toLowerCase().indexOf('firefox') > -1;
+exports.isFirefox = isFirefox;
+const isAPrivateIp = (ip) => privateIpRegex.exec(ip) == null;
+exports.isAPrivateIp = isAPrivateIp;
+const getIceServers = (ip) => {
+    if ((0, exports.isAPrivateIp)(ip)) {
+        return [{
+                urls: ['stun:stun.l.google.com:19302', 'stun:stun4.l.google.com:19302'],
+            }];
+    }
+    return [];
+};
+exports.getIceServers = getIceServers;
 const parseCandidate = (line) => {
     let parts;
     // Parse both variants.
@@ -39,3 +100,462 @@ const parseCandidate = (line) => {
     return candidate;
 };
 exports.parseCandidate = parseCandidate;
+const getPeerConnection = (sipCall) => {
+    if (!sipCall) {
+        return null;
+    }
+    return sipCall.sessionDescriptionHandler ? sipCall.sessionDescriptionHandler.peerConnection : null;
+};
+exports.getPeerConnection = getPeerConnection;
+const getLocalStream = (sipCall) => {
+    var _a;
+    return ((_a = sipCall === null || sipCall === void 0 ? void 0 : sipCall.sessionDescriptionHandler) === null || _a === void 0 ? void 0 : _a.localMediaStream) || null;
+};
+exports.getLocalStream = getLocalStream;
+const getLocalTracks = (sipCall) => {
+    const localStream = (0, exports.getLocalStream)(sipCall);
+    if (!localStream) {
+        return [];
+    }
+    return localStream.getTracks();
+};
+exports.getLocalTracks = getLocalTracks;
+const getRemoteStream = (sipCall) => {
+    var _a;
+    return ((_a = sipCall === null || sipCall === void 0 ? void 0 : sipCall.sessionDescriptionHandler) === null || _a === void 0 ? void 0 : _a.remoteMediaStream) || null;
+};
+exports.getRemoteStream = getRemoteStream;
+const isVideoTrack = (track) => track.kind === 'video' && track.readyState === 'live';
+exports.isVideoTrack = isVideoTrack;
+const hasLocalVideo = (sipCall) => (0, exports.getLocalTracks)(sipCall).some(exports.isVideoTrack);
+exports.hasLocalVideo = hasLocalVideo;
+const hasALocalVideoTrack = (sipCall) => (0, exports.getLocalTracks)(sipCall).some(track => track.kind === 'video');
+exports.hasALocalVideoTrack = hasALocalVideoTrack;
+const getLocalVideoStream = (sipCall) => ((0, exports.hasLocalVideo)(sipCall) ? (0, exports.getLocalStream)(sipCall) : null);
+exports.getLocalVideoStream = getLocalVideoStream;
+const getRemoteTracks = (sipCall) => {
+    const remoteStream = (0, exports.getRemoteStream)(sipCall);
+    if (!remoteStream) {
+        return [];
+    }
+    return remoteStream.getTracks();
+};
+exports.getRemoteTracks = getRemoteTracks;
+const isVideoRemotelyHeld = (sipCall) => {
+    const pc = (0, exports.getPeerConnection)(sipCall);
+    const sdp = pc && pc.remoteDescription ? pc.remoteDescription.sdp : null;
+    if (!sdp) {
+        return false;
+    }
+    const videoDirection = (0, sdp_1.getVideoDirection)(sdp);
+    return videoDirection === 'sendonly';
+};
+exports.isVideoRemotelyHeld = isVideoRemotelyHeld;
+const hasRemoteVideo = (sipCall) => (0, exports.getRemoteTracks)(sipCall).some(exports.isVideoTrack);
+exports.hasRemoteVideo = hasRemoteVideo;
+const hasARemoteVideoTrack = (sipCall) => (0, exports.getRemoteTracks)(sipCall).some(track => track.kind === 'video');
+exports.hasARemoteVideoTrack = hasARemoteVideoTrack;
+const getRemoteVideoStream = (sipCall) => {
+    if ((0, exports.isVideoRemotelyHeld)(sipCall)) {
+        return null;
+    }
+    return (0, exports.hasRemoteVideo)(sipCall) ? (0, exports.getRemoteStream)(sipCall) : null;
+};
+exports.getRemoteVideoStream = getRemoteVideoStream;
+const getRemoteVideoStreamFromPc = (sipCall) => {
+    const pc = (0, exports.getPeerConnection)(sipCall);
+    if (!pc) {
+        return null;
+    }
+    return pc.getRemoteStreams().find((stream) => !!stream.getVideoTracks().length);
+};
+exports.getRemoteVideoStreamFromPc = getRemoteVideoStreamFromPc;
+const hasVideoTrack = (sipCall) => (0, exports.hasLocalVideo)(sipCall) || (0, exports.hasRemoteVideo)(sipCall);
+exports.hasVideoTrack = hasVideoTrack;
+const hasAVideoTrack = (sipCall) => (0, exports.hasALocalVideoTrack)(sipCall) || (0, exports.hasARemoteVideoTrack)(sipCall);
+exports.hasAVideoTrack = hasAVideoTrack;
+// eslint-disable-next-line no-unused-vars
+const sessionWantsToDoVideo = (sipCall) => {
+    if (!sipCall) {
+        return false;
+    }
+    const { body, } = sipCall.request || sipCall;
+    // Sometimes with InviteClientContext the body is in the body attribute ...
+    const sdp = typeof body === 'object' && body ? body.body : body;
+    return (0, sdp_1.hasAnActiveVideo)(sdp);
+};
+exports.sessionWantsToDoVideo = sessionWantsToDoVideo;
+const getWebRtcStats = (sipCall) => __awaiter(void 0, void 0, void 0, function* () {
+    const pc = (0, exports.getPeerConnection)(sipCall);
+    if (!pc) {
+        return null;
+    }
+    return pc.getStats(null);
+});
+exports.getWebRtcStats = getWebRtcStats;
+const toggleAudio = (sipCall, muteAudio) => {
+    const sdh = sipCall.sessionDescriptionHandler;
+    const pc = ((sdh === null || sdh === void 0 ? void 0 : sdh.peerConnection) || null);
+    if (!pc) {
+        return;
+    }
+    if (pc.getSenders) {
+        pc.getSenders().forEach((sender) => {
+            if (sender && sender.track && sender.track.kind === 'audio') {
+                // eslint-disable-next-line
+                sender.track.enabled = !muteAudio;
+            }
+        });
+    }
+    else {
+        pc.getLocalStreams().forEach((stream) => {
+            stream.getAudioTracks().forEach(track => {
+                // eslint-disable-next-line
+                track.enabled = !muteAudio;
+            });
+        });
+    }
+};
+exports.toggleAudio = toggleAudio;
+const toggleVideo = (sipCall, muteCamera) => {
+    const sdh = sipCall.sessionDescriptionHandler;
+    const pc = sdh === null || sdh === void 0 ? void 0 : sdh.peerConnection;
+    if (pc === null || pc === void 0 ? void 0 : pc.getSenders) {
+        pc.getSenders().forEach((sender) => {
+            if (sender && sender.track && sender.track.kind === 'video') {
+                // eslint-disable-next-line
+                sender.track.enabled = !muteCamera;
+            }
+        });
+    }
+    else {
+        pc.getLocalStreams().forEach((stream) => {
+            stream.getVideoTracks().forEach(track => {
+                // eslint-disable-next-line
+                track.enabled = !muteCamera;
+            });
+        });
+    }
+};
+exports.toggleVideo = toggleVideo;
+const cleanupStream = (stream) => {
+    stream.getTracks().filter(track => track.enabled).forEach(track => track.stop());
+};
+exports.cleanupStream = cleanupStream;
+const setLocalMediaStream = (sipCall, newStream) => {
+    logger.info('setting local media stream', {
+        id: sipCall.id,
+        tracks: newStream ? newStream.getTracks() : null,
+    });
+    if (sipCall.sessionDescriptionHandler) {
+        // eslint-disable-next-line no-underscore-dangle
+        // @ts-ignore: protected
+        sipSession.sessionDescriptionHandler._localMediaStream = newStream;
+    }
+};
+exports.setLocalMediaStream = setLocalMediaStream;
+const updateRemoteStream = (sipCall, allTracks = true) => {
+    const remoteStream = (0, exports.getRemoteStream)(sipCall);
+    const pc = (0, exports.getPeerConnection)(sipCall);
+    logger.info('Updating remote stream', {
+        id: sipCall.id,
+        tracks: remoteStream ? remoteStream.getTracks() : null,
+        receiverTracks: pc && pc.getReceivers ? pc.getReceivers().map((receiver) => receiver.track) : null,
+    });
+    if (!pc || !remoteStream) {
+        return;
+    }
+    remoteStream.getTracks().forEach(track => {
+        if (allTracks || track.kind === 'video') {
+            remoteStream.removeTrack(track);
+        }
+    });
+    if (pc.getReceivers) {
+        pc.getReceivers().forEach((receiver) => {
+            if (allTracks || receiver.track.kind === 'video') {
+                remoteStream.addTrack(receiver.track);
+            }
+        });
+    }
+};
+exports.updateRemoteStream = updateRemoteStream;
+const isAudioOnly = (sipCall) => {
+    return Boolean(sipCall.sessionDescriptionHandlerModifiersReInvite.find(modifier => modifier === web_1.stripVideo));
+};
+exports.isAudioOnly = isAudioOnly;
+// @ts-ignore: media constraints
+const getAudioConstraints = (audio) => { var _a; return (((_a = audio === null || audio === void 0 ? void 0 : audio.deviceId) === null || _a === void 0 ? void 0 : _a.exact) ? audio : true); };
+exports.getAudioConstraints = getAudioConstraints;
+const getVideoConstraints = (video = false) => {
+    var _a, _b;
+    if (!video) {
+        return false;
+    }
+    // @ts-ignore: media constraints
+    return ((_b = (_a = this.video) === null || _a === void 0 ? void 0 : _a.deviceId) === null || _b === void 0 ? void 0 : _b.exact) ? this.video : true;
+};
+exports.getVideoConstraints = getVideoConstraints;
+// eslint-disable-next-line no-unused-vars
+const getRtcOptions = () => {
+    return {
+        mandatory: {
+            OfferToReceiveAudio: true,
+            OfferToReceiveVideo: false,
+        },
+    };
+};
+const getMediaConfiguration = (enableVideo, conference = false, constraints = null) => {
+    const screenSharing = constraints && 'screen' in constraints ? constraints.screen : false;
+    const isDesktop = constraints && 'desktop' in constraints ? constraints.desktop : false;
+    const withAudio = constraints && 'audio' in constraints ? constraints.audio : true;
+    const mandatoryVideo = constraints && typeof constraints.video === 'object' ? constraints.video.mandatory : {};
+    logger.info('Retrieving media a configuration', { enableVideo, screenSharing, isDesktop, withAudio, constraints });
+    return {
+        constraints: {
+            // Exact constraint are not supported with `getDisplayMedia` and we must have a video=false in desktop screenshare
+            audio: screenSharing ? !isDesktop : withAudio ? (0, exports.getAudioConstraints)(true) : false,
+            video: screenSharing ? isDesktop ? {
+                mandatory: Object.assign({ chromeMediaSource: 'desktop' }, (mandatoryVideo || {})),
+            } : {
+                cursor: 'always',
+            } : (0, exports.getVideoConstraints)(enableVideo),
+            screen: screenSharing,
+            desktop: isDesktop,
+            conference,
+        },
+        enableVideo,
+        conference,
+        offerOptions: {
+            OfferToReceiveAudio: true,
+            OfferToReceiveVideo: enableVideo,
+            mandatory: {
+                OfferToReceiveAudio: true,
+                OfferToReceiveVideo: enableVideo,
+            },
+        },
+    };
+};
+exports.getMediaConfiguration = getMediaConfiguration;
+const getStreamFromConstraints = (constraints_1, ...args_1) => __awaiter(void 0, [constraints_1, ...args_1], void 0, function* (constraints, conference = false) {
+    const video = constraints && constraints.video;
+    const { constraints: newConstraints } = (0, exports.getMediaConfiguration)(video, conference, constraints);
+    let newStream = null;
+    try {
+        newStream = yield (0, WazoSessionDescriptionHandler_1.wazoMediaStreamFactory)(newConstraints);
+    }
+    catch (e) { // Nothing to do when the user cancel the screensharing prompt
+    }
+    if (!newStream) {
+        return null;
+    }
+    newStream.local = true;
+    return newStream;
+});
+exports.getStreamFromConstraints = getStreamFromConstraints;
+const createUaOptions = (config, uaOptionsOverrides = {}, audio = false, video = false) => {
+    let { host } = config;
+    let port = config.port || 443;
+    if (config.websocketSip) {
+        const webSocketSip = config.websocketSip.split(':');
+        [host] = webSocketSip;
+        port = Number(webSocketSip[1]);
+    }
+    const { userUuid } = config;
+    const uaOptions = {
+        noAnswerTimeout: NO_ANSWER_TIMEOUT,
+        authorizationUsername: config.authorizationUser,
+        authorizationPassword: config.password,
+        displayName: config.displayName,
+        hackIpInContact: true,
+        contactParams: {
+            transport: 'wss',
+        },
+        logBuiltinEnabled: config.log ? config.log.builtinEnabled : null,
+        logLevel: config.log ? config.log.logLevel : null,
+        logConnector: config.log ? config.log.connector : null,
+        uri: (0, sdp_1.makeURI)(config.authorizationUser || '', config.host),
+        userAgentString: config.userAgentString || 'wazo-sdk',
+        reconnectionAttempts: 10000,
+        reconnectionDelay: 5,
+        // @ts-ignore
+        sessionDescriptionHandlerFactory: (sipCall, options = {}) => {
+            const uaLogger = sipCall.userAgent.getLogger('sip.WazoSessionDescriptionHandler');
+            const iceGatheringTimeout = 'peerConnectionOptions' in options ? options.peerConnectionOptions.iceGatheringTimeout || DEFAULT_ICE_TIMEOUT : DEFAULT_ICE_TIMEOUT;
+            const sdhOptions = Object.assign(Object.assign({}, options), { iceGatheringTimeout, peerConnectionConfiguration: Object.assign(Object.assign({}, (0, peer_connection_configuration_default_1.defaultPeerConnectionConfiguration)()), (options.peerConnectionConfiguration || {})) });
+            return new WazoSessionDescriptionHandler_1.default(uaLogger, WazoSessionDescriptionHandler_1.wazoMediaStreamFactory, sdhOptions, (0, exports.isWeb)(), sipCall);
+        },
+        transportOptions: {
+            traceSip: (uaOptionsOverrides === null || uaOptionsOverrides === void 0 ? void 0 : uaOptionsOverrides.traceSip) || false,
+            wsServers: `wss://${host}:${port}/api/asterisk/ws${userUuid ? `?userUuid=${userUuid}` : ''}`,
+        },
+        sessionDescriptionHandlerFactoryOptions: {
+            modifiers: [sdp_1.replaceLocalIpModifier],
+            alwaysAcquireMediaFirst: (0, exports.isFirefox)(),
+            constraints: {
+                audio: (0, exports.getAudioConstraints)(audio),
+                video: (0, exports.getVideoConstraints)(video),
+            },
+            peerConnectionOptions: {
+                iceCheckingTimeout: config.iceCheckingTimeout || 1000,
+                iceGatheringTimeout: config.iceCheckingTimeout || 1000,
+                rtcConfiguration: Object.assign(Object.assign({ rtcpMuxPolicy: 'require', iceServers: (0, exports.getIceServers)(config.host) }, getRtcOptions()), ((uaOptionsOverrides === null || uaOptionsOverrides === void 0 ? void 0 : uaOptionsOverrides.peerConnectionOptions) || {})),
+            },
+            // Configuration used in SDH to create the PeerConnection
+            peerConnectionConfiguration: Object.assign({ rtcpMuxPolicy: 'require', iceServers: (0, exports.getIceServers)(config.host) }, ((uaOptionsOverrides === null || uaOptionsOverrides === void 0 ? void 0 : uaOptionsOverrides.peerConnectionOptions) || {})),
+        },
+    };
+    uaOptionsOverrides === null || uaOptionsOverrides === void 0 ? true : delete uaOptionsOverrides.traceSip;
+    return Object.assign(Object.assign({}, uaOptions), uaOptionsOverrides);
+};
+exports.createUaOptions = createUaOptions;
+const downgradeToAudio = (sipCall) => {
+    // Release local video stream when downgrading to audio
+    const sessionDescriptionHandler = sipCall.sessionDescriptionHandler;
+    const localStream = sessionDescriptionHandler === null || sessionDescriptionHandler === void 0 ? void 0 : sessionDescriptionHandler.localMediaStream;
+    const pc = sessionDescriptionHandler === null || sessionDescriptionHandler === void 0 ? void 0 : sessionDescriptionHandler.peerConnection;
+    const videoTracks = localStream.getVideoTracks();
+    // Remove video senders
+    if (pc === null || pc === void 0 ? void 0 : pc.getSenders) {
+        pc.getSenders().filter((sender) => sender.track && sender.track.kind === 'video').forEach((videoSender) => {
+            videoSender.replaceTrack(null);
+        });
+    }
+    videoTracks.forEach((videoTrack) => {
+        videoTrack.enabled = false;
+        videoTrack.stop();
+        localStream.removeTrack(videoTrack);
+    });
+};
+exports.downgradeToAudio = downgradeToAudio;
+// Returns true if a re-INVITE is required
+const upgradeToVideo = (sipCall, constraints, isConference) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const pc = (0, exports.getPeerConnection)(sipCall);
+    // Check if a video sender already exists
+    let videoSender;
+    if (isConference) {
+        // We search for the last transceiver without `video-` in the mid (video- means remote transceiver)
+        const transceivers = (pc === null || pc === void 0 ? void 0 : pc.getTransceivers()) || [];
+        const transceiverIdx = (0, array_1.lastIndexOf)(transceivers, transceiver => transceiver.sender.track === null && transceiver.mid && transceiver.mid.indexOf('video') === -1);
+        videoSender = transceiverIdx !== -1 ? transceivers[transceiverIdx].sender : null;
+    }
+    else {
+        videoSender = pc && pc.getSenders && pc.getSenders().find((sender) => sender.track === null);
+    }
+    if (!videoSender) {
+        // When no video sender found, it means that we're in the first video upgrade in 1:1
+        return;
+    }
+    // Reuse bidirectional video stream
+    const newStream = yield (0, exports.getStreamFromConstraints)(constraints);
+    if (!newStream) {
+        console.warn(`Can't create media stream with: ${JSON.stringify(constraints || {})}`);
+        return;
+    }
+    // Add previous local audio track
+    if (constraints && !constraints.audio) {
+        const localVideoStream = (_a = sipCall.sessionDescriptionHandler) === null || _a === void 0 ? void 0 : _a.localMediaStream;
+        const localAudioTrack = localVideoStream.getTracks().find(track => track.kind === 'audio');
+        if (localAudioTrack) {
+            newStream.addTrack(localAudioTrack);
+        }
+    }
+    const videoTrack = newStream.getVideoTracks()[0];
+    if (videoTrack) {
+        videoSender.replaceTrack(videoTrack);
+    }
+    (0, exports.setLocalMediaStream)(sipCall, newStream);
+    return newStream;
+});
+exports.upgradeToVideo = upgradeToVideo;
+const fetchNetworkStats = (sipCall, lastNetworkStats) => __awaiter(void 0, void 0, void 0, function* () {
+    const stats = sipCall ? yield (0, exports.getWebRtcStats)(sipCall) : null;
+    if (!stats) {
+        return Promise.resolve(null);
+    }
+    const networkStats = {
+        audioBytesSent: 0,
+        videoBytesSent: 0,
+        videoBytesReceived: 0,
+        audioBytesReceived: 0,
+    };
+    const lastAudioSent = lastNetworkStats ? lastNetworkStats.audioBytesSent : 0;
+    const lastAudioContentSent = lastNetworkStats ? lastNetworkStats.audioContentSent : 0;
+    const lastVideoSent = lastNetworkStats ? lastNetworkStats.videoBytesSent : 0;
+    const lastAudioReceived = lastNetworkStats ? lastNetworkStats.audioBytesReceived : 0;
+    const lastAudioContentReceived = lastNetworkStats ? lastNetworkStats.audioContentReceived : 0;
+    const lastVideoReceived = lastNetworkStats ? lastNetworkStats.videoBytesReceived : 0;
+    const lastTransportSent = lastNetworkStats ? lastNetworkStats.transportSent : 0;
+    const lastTransportReceived = lastNetworkStats ? lastNetworkStats.transportReceived : 0;
+    let audioBytesSent = 0; // content + header
+    let audioBytesReceived = 0; // content + header
+    let audioContentSent = 0; // useful to detect blank call
+    let audioContentReceived = 0;
+    let videoBytesSent = 0;
+    let videoBytesReceived = 0;
+    let transportSent = 0;
+    let transportReceived = 0;
+    let packetsLost = 0;
+    stats.forEach(report => {
+        if (report.type === 'outbound-rtp' && report.kind === 'audio') {
+            audioBytesSent += Number(report.bytesSent) + Number(report.headerBytesSent);
+            audioContentSent += Number(report.bytesSent);
+        }
+        if (report.type === 'remote-outbound-rtp' && report.kind === 'audio') {
+            audioBytesSent += Number(report.bytesSent);
+        }
+        if (report.type === 'outbound-rtp' && report.kind === 'video') {
+            videoBytesSent += Number(report.bytesSent) + Number(report.headerBytesSent);
+        }
+        if (report.type === 'inbound-rtp' && report.kind === 'audio') {
+            packetsLost += Number(report.packetsLost);
+            networkStats.packetsReceived = Number(report.packetsReceived);
+            audioBytesReceived += Number(report.bytesReceived) + Number(report.headerBytesReceived);
+            audioContentReceived += Number(report.bytesReceived);
+        }
+        if (report.type === 'inbound-rtp' && report.kind === 'video') {
+            videoBytesReceived += Number(report.bytesReceived) + Number(report.headerBytesReceived);
+        }
+        if (report.type === 'outbound-rtp' && report.kind === 'video') {
+            if ('framesPerSecond' in report) {
+                networkStats.framesPerSecond = Number(report.framesPerSecond);
+            }
+            if ('framerateMean' in report) {
+                // framerateMean is only available in FF
+                networkStats.framesPerSecond = Math.round(report.framerateMean);
+            }
+        }
+        if (report.type === 'remote-inbound-rtp' && report.kind === 'audio') {
+            packetsLost += Number(report.packetsLost);
+            networkStats.roundTripTime = Number(report.roundTripTime);
+            networkStats.jitter = Number(report.jitter);
+        }
+        if (report.type === 'remote-inbound-rtp' && report.kind === 'video') {
+            packetsLost += Number(report.packetsLost);
+        }
+        if (report.type === 'transport') {
+            transportSent += Number(report.bytesSent);
+            transportReceived += Number(report.bytesReceived);
+        }
+    });
+    networkStats.packetsLost = packetsLost;
+    networkStats.totalAudioBytesSent = audioBytesSent;
+    networkStats.audioBytesSent = audioBytesSent - lastAudioSent;
+    networkStats.totalAudioBytesReceived = audioBytesReceived - lastAudioReceived;
+    networkStats.audioBytesReceived = audioBytesReceived;
+    networkStats.totalAudioContentSent = audioContentSent;
+    networkStats.audioContentSent = audioContentSent - lastAudioContentSent;
+    networkStats.totalAudioBytesReceived = audioContentReceived - lastAudioContentReceived;
+    networkStats.audioContentReceived = audioContentReceived;
+    networkStats.totalVideoBytesSent = videoBytesSent;
+    networkStats.videoBytesSent = videoBytesSent - lastVideoSent;
+    networkStats.totalVideoBytesReceived = videoBytesReceived;
+    networkStats.videoBytesReceived = videoBytesReceived - lastVideoReceived;
+    networkStats.totalTransportSent = transportSent - lastTransportSent;
+    networkStats.transportSent = transportSent;
+    networkStats.totalTransportReceived = transportReceived;
+    networkStats.transportReceived = transportReceived - lastTransportReceived;
+    networkStats.bandwidth = networkStats.audioBytesSent + networkStats.audioBytesReceived + networkStats.videoBytesSent + networkStats.videoBytesReceived + networkStats.transportReceived + networkStats.transportSent;
+    return networkStats;
+});
+exports.fetchNetworkStats = fetchNetworkStats;