podchat-browser/dist/node/lib/call/multitrack/callUser.js

Javascript SDK to use POD's Chat Service - Browser Only

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.CallScreenShare = CallScreenShare;
exports.CallUser = CallUser;

var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));

var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));

var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));

var _utility = _interopRequireDefault(require("../../../utility/utility"));

var _errorHandler = require("../../errorHandler");

function CallUser(app, user) {
  var config = {
    callId: user.callId,
    userId: user.userId,
    user: user,
    isMe: user.userId == app.store.user.get().id,
    containerTag: null,
    htmlElements: {},
    videoIsOpen: false,
    audioIsOpen: false,
    topicMetaData: {
      audioLevelInterval: null
    },
    slowLinkTimeout: null,
    isDestroyed: false,
    videoReceiveVersion: -1,
    audioReceiveVersion: -1,
    videoStream: null,
    audioStream: null,
    streamTracks: {
      video: null,
      audio: null
    },
    oldAudioStreamId: null,
    newAudioStreamId: null
  };
  var publicized = {
    getAudioStream: function getAudioStream() {
      return config.audioStream;
    },
    getVideoStream: function getVideoStream() {
      return config.videoStream;
    },
    switchSpeaker: function switchSpeaker(deviceId) {
      return (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
        var audioObject;
        return _regenerator["default"].wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                try {
                  audioObject = publicized.getAudioObject();

                  if (audioObject) {
                    audioObject.setSinkId(deviceId);
                    app.sdkParams.consoleLogging && console.log("speaker changed");
                  }
                } catch (error) {
                  console.error('Error setting audio output:', error);
                }

              case 1:
              case "end":
                return _context.stop();
            }
          }
        }, _callee);
      }))();
    },
    audioIsOpen: function audioIsOpen() {
      return config.audioIsOpen;
    },
    resetTopicVersions: function resetTopicVersions() {
      config.videoReceiveVersion = -1;
      config.audioReceiveVersion = -1;
    },
    getAudioObject: function getAudioObject() {
      return config.audioObject;
    },
    userId: function userId() {
      return config.userId;
    },
    isMe: function isMe() {
      return config.userId == app.store.user.get().id;
    },
    setVideoIsOpen: function setVideoIsOpen(value) {
      config.videoIsOpen = value;
    },
    setAudioIsOpen: function setAudioIsOpen(value) {
      config.audioIsOpen = value;
    },
    isScreenShare: function isScreenShare() {
      return false;
    },
    user: function user() {
      return config.user;
    },
    getHTMLElements: function getHTMLElements() {
      return config.htmlElements;
    },
    getVideoHtmlElement: function getVideoHtmlElement() {
      var elementUniqueId = _utility["default"].generateUUID();

      if (config.user.video && !config.htmlElement) {
        config.htmlElement = document.createElement('video');
        var el = config.htmlElement;
        el.setAttribute('id', 'callUserVideo-' + config.user.videoTopicName);
        el.setAttribute('class', app.call.sharedVariables.callVideoTagClassName);
        el.setAttribute('playsinline', '');
        el.setAttribute('muted', '');
        el.setAttribute('autoplay', '');
        el.setAttribute('data-uniqueId', elementUniqueId);
        el.setAttribute('width', app.call.sharedVariables.callVideoMinWidth + 'px');
        el.setAttribute('height', app.call.sharedVariables.callVideoMinHeight + 'px'); // el.setAttribute('controls', '');
      }

      return config.htmlElement;
    },
    appendVideoToCallDiv: function appendVideoToCallDiv() {
      if (!app.call.sharedVariables.callDivId) {
        app.sdkParams.consoleLogging && console.log('No Call DIV has been declared!');
        return;
      }

      var user = config.user,
          callParentDiv = document.getElementById(app.call.sharedVariables.callDivId),
          userContainer = document.getElementById("callParticipantWrapper-" + config.userId);

      if (!userContainer) {
        callParentDiv.appendChild(config.htmlElements.container);
        userContainer = document.getElementById("callParticipantWrapper-" + config.userId);
      }

      if (user.video) {
        if (!document.getElementById("callUserVideo-" + config.user.videoTopicName)) {
          userContainer.appendChild(config.htmlElements[config.user.videoTopicName]);
          config.htmlElements[config.user.videoTopicName].play();
        } else {
          var targetEl = document.getElementById('callUserVideo-' + config.user.videoTopicName);

          if (!targetEl.srcObject) {
            targetEl.srcObject = config.htmlElements[config.user.videoTopicName].srcObject;
          }
        }
      }

      app.call.currentCall().sendCallDivs();
    },
    videoTopicManager: function videoTopicManager() {// return config.videoTopicManager;
    },
    audioTopicManager: function audioTopicManager() {// return config.audioTopicManager;
    },
    removeAudioWatcherInterval: function removeAudioWatcherInterval() {
      if (config.topicMetaData) {
        clearInterval(config.topicMetaData.audioLevelInterval);
      }
    },
    replaceVideoStream: function replaceVideoStream(newStream, callback) {
      var deviceManager = app.call.deviceManager;

      if (deviceManager.mediaStreams.getVideoInput()) {
        config.htmlElements[config.user.videoTopicName].srcObject = newStream;

        try {
          app.call.currentCall().sendPeerManager().changeVideoSendStream(newStream);
          var targetEl = document.getElementById('callUserVideo-' + config.user.videoTopicName);

          if (!targetEl.srcObject) {
            targetEl.srcObject = config.htmlElements[config.user.videoTopicName].srcObject;
          }

          callback && callback();
        } catch (error) {
          app.call.currentCall().raiseCallError({
            code: _errorHandler.errorList.CHANGE_MEDIA_DEVICE_FAILED.code,
            message: error.message
          }, null, true);
          publicized.stopVideo();
          setTimeout(function () {
            app.call.currentCall().sendCallDivs();
          });
        }
      }
    },
    changeVideoStream: function changeVideoStream(deviceId, callback) {
      var conf = {
        deviceId: {
          exact: deviceId
        }
      },
          deviceManager = app.call.deviceManager;

      if (deviceManager.mediaStreams.getVideoInput()) {
        deviceManager.mediaStreams.stopVideoInput();
        deviceManager.grantUserMediaDevicesPermissions({
          video: conf
        }, function (result) {
          if (!result.hasError) {
            var stream = deviceManager.mediaStreams.getVideoInput();
            config.htmlElements[config.user.videoTopicName].srcObject = stream;

            try {
              app.call.currentCall().sendPeerManager().changeVideoSendStream(stream);
              var targetEl = document.getElementById('callUserVideo-' + config.user.videoTopicName);

              if (!targetEl.srcObject) {
                targetEl.srcObject = config.htmlElements[config.user.videoTopicName].srcObject;
              }

              callback && callback();
            } catch (error) {
              app.call.currentCall().raiseCallError({
                code: _errorHandler.errorList.CHANGE_MEDIA_DEVICE_FAILED.code,
                message: error.message
              }, null, true);
              publicized.stopVideo();
              setTimeout(function () {
                app.call.currentCall().sendCallDivs();
              });
            }
          } else {
            app.call.currentCall().raiseCallError({
              code: result.errorCode,
              message: result.errorMessage
            }, null, true);
            publicized.stopVideo();
            setTimeout(function () {
              app.call.currentCall().sendCallDivs();
            });
          }
        });
      } else {
        throw new Error('[SDK] Webcam is not active');
      }
    },
    changeAudioStream: function changeAudioStream(deviceId, callback) {
      var conf = {
        deviceId: {
          exact: deviceId
        }
      },
          deviceManager = app.call.deviceManager;

      if (deviceManager.mediaStreams.getAudioInput()) {
        deviceManager.mediaStreams.stopAudioInput();
        app.call.deviceManager.grantUserMediaDevicesPermissions({
          audio: conf
        }, function (result) {
          if (!result.hasError) {
            try {
              var stream = app.call.deviceManager.mediaStreams.getAudioInput();
              app.call.currentCall().sendPeerManager().getPeer().switchAudioStream(stream);
              callback && callback();
            } catch (error) {
              app.call.currentCall().raiseCallError({
                code: _errorHandler.errorList.CHANGE_MEDIA_DEVICE_FAILED.code,
                message: error.message
              }, null, true);
              publicized.stopAudio();
            }
          } else {
            app.call.currentCall().raiseCallError({
              code: result.errorCode,
              message: result.errorMessage
            }, null, true);
            publicized.stopAudio();
          }
        });
      } else {
        throw new Error('[SDK] Microphone is not active');
      }
    },
    startAudio: function startAudio(sendTopic, conf) {
      return (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2() {
        return _regenerator["default"].wrap(function _callee2$(_context2) {
          while (1) {
            switch (_context2.prev = _context2.next) {
              case 0:
                if (config.isMe) {
                  app.call.deviceManager.grantUserMediaDevicesPermissions({
                    audio: true
                  }, function (result) {
                    if (!result.hasError) {
                      config.audioIsOpen = true;
                      config.user.mute = false; // config.audioReceiveVersion = conf.version;

                      addSendTrackToPeerManager('audio');
                    }
                  });
                } else {
                  config.audioIsOpen = true;
                  config.user.mute = false;
                  config.audioReceiveVersion = conf.version;
                  addReceiveTrackToPeerManager('audio', conf);
                }

              case 1:
              case "end":
                return _context2.stop();
            }
          }
        }, _callee2);
      }))();
    },
    startVideo: function startVideo(sendTopic, conf) {
      return (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3() {
        return _regenerator["default"].wrap(function _callee3$(_context3) {
          while (1) {
            switch (_context3.prev = _context3.next) {
              case 0:
                if (config.isMe) {
                  app.call.deviceManager.grantUserMediaDevicesPermissions({
                    video: {
                      width: app.call.sharedVariables.callVideoMinWidth,
                      framerate: 10
                    }
                  }, function (result) {
                    if (!result.hasError) {
                      config.user.video = true;
                      config.videoIsOpen = true;
                      addSendTrackToPeerManager('video');
                    }
                  });
                } else {
                  config.user.video = true;
                  config.videoIsOpen = true;
                  config.videoReceiveVersion = conf.version;
                  addReceiveTrackToPeerManager('video', conf);
                }

              case 1:
              case "end":
                return _context3.stop();
            }
          }
        }, _callee3);
      }))();
    },
    pauseVideoSendStream: function pauseVideoSendStream() {
      var localStream = app.call.deviceManager.mediaStreams.getVideoInput();
      if (localStream) localStream.getTracks()[0].enabled = false;
    },
    pauseAudioSendStream: function pauseAudioSendStream() {
      var localStream = app.call.deviceManager.mediaStreams.getAudioInput();
      if (localStream) localStream.getTracks()[0].enabled = false;
    },
    // pauseSendStream() {
    //     let localStream;
    //     switch (config.mediaType) {
    //         case 'audio':
    //             localStream = app.call.currentCall().deviceManager().mediaStreams.getAudioInput()
    //             break;
    //         case 'video':
    //             if(config.isScreenShare) {
    //                 localStream = app.call.currentCall().deviceManager().mediaStreams.getScreenShareInput();
    //             } else {
    //                 localStream = app.call.currentCall().deviceManager().mediaStreams.getVideoInput();
    //             }
    //     }
    //     if(localStream)
    //         localStream.getTracks()[0].enabled = false;
    // },
    resumeVideoSendStream: function resumeVideoSendStream() {
      var localStream = app.call.deviceManager.mediaStreams.getVideoInput();
      if (localStream) localStream.getTracks()[0].enabled = true;
    },
    resumeAudioSendStream: function resumeAudioSendStream() {
      var localStream = app.call.deviceManager.mediaStreams.getAudioInput();
      if (localStream) localStream.getTracks()[0].enabled = true;
    },
    startSLowLink: function startSLowLink() {
      app.chatEvents.fireEvent('callEvents', {
        type: 'SLOW_LINK',
        callId: config.callId,
        message: "Slow link",
        userId: config.userId
      });
      config.slowLinkTimeout && clearTimeout(config.slowLinkTimeout);
      config.slowLinkTimeout = setTimeout(function () {
        app.chatEvents.fireEvent('callEvents', {
          type: 'SLOW_LINK_RESOLVED',
          callId: config.callId,
          message: "Slow link resolved",
          userId: config.userId
        });
      }, 10000);
    },
    correctWithServerData: function correctWithServerData(remoteInfo) {
      if (config.videoIsOpen && !remoteInfo.video) {
        publicized.stopVideo();
      }

      if (!config.videoIsOpen && remoteInfo.video) {
        config.user.video = true;
      }

      if (config.audioIsOpen && remoteInfo.mute) {
        publicized.stopAudio();
      }

      if (!config.audioIsOpen && !remoteInfo.mute) {
        config.user.mute = false;
      }
    },
    getAudioStreamHasChanged: function getAudioStreamHasChanged() {
      var hasChange = config.oldAudioStreamId != config.newAudioStreamId;
      config.oldAudioStreamId = config.newAudioStreamId;
      return hasChange;
    },
    getVideoStreamHasChanged: function getVideoStreamHasChanged() {
      var hasChange = config.oldVideoStreamId != config.newVideoStreamId;
      config.oldVideoStreamId = config.newVideoStreamId;
      return hasChange;
    },
    destroy: function destroy() {
      return (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee4() {
        return _regenerator["default"].wrap(function _callee4$(_context4) {
          while (1) {
            switch (_context4.prev = _context4.next) {
              case 0:
                _context4.next = 2;
                return publicized.stopVideo();

              case 2:
                _context4.next = 4;
                return publicized.stopAudio();

              case 4:
                config.isDestroyed = true; // await publicized.destroyVideo();
                // await publicized.destroyAudio();

                config.htmlElements = {};
                user = null;

              case 7:
              case "end":
                return _context4.stop();
            }
          }
        }, _callee4);
      }))();
    },
    stopAudio: function stopAudio() {
      return (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee5() {
        var currentCall;
        return _regenerator["default"].wrap(function _callee5$(_context5) {
          while (1) {
            switch (_context5.prev = _context5.next) {
              case 0:
                config.user.mute = true;
                config.audioIsOpen = false;
                currentCall = app.call.currentCall();

                if (!currentCall.isDestroyed()) {
                  if (config.isMe) currentCall.sendPeerManager() && currentCall.sendPeerManager().removeTrack(config.user.audioTopicName);else {
                    currentCall.receivePeerManager() && currentCall.receivePeerManager().removeTrack(config.user.audioTopicName);
                  }
                }

                _context5.next = 6;
                return publicized.destroyAudio();

              case 6:
              case "end":
                return _context5.stop();
            }
          }
        }, _callee5);
      }))();
    },
    destroyAudio: function destroyAudio() {
      return (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee6() {
        return _regenerator["default"].wrap(function _callee6$(_context6) {
          while (1) {
            switch (_context6.prev = _context6.next) {
              case 0:
                config.audioReceiveVersion = -1;
                console.log('[media][audio] destroy, topic: ', config.user.audioTopicName);

                if (config.audioObject) {
                  config.audioObject.srcObject = null;
                  config.audioObject = null;
                }

                config.audioIsOpen = false;

                if (app.call.currentCall().receivePeerManager()) {
                  app.call.currentCall().receivePeerManager().removeTrack(config.user.audioTopicName);
                }

                publicized.removeAudioWatcherInterval();

              case 6:
              case "end":
                return _context6.stop();
            }
          }
        }, _callee6);
      }))();
    },
    stopVideo: function stopVideo() {
      return (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee7() {
        var currentCall;
        return _regenerator["default"].wrap(function _callee7$(_context7) {
          while (1) {
            switch (_context7.prev = _context7.next) {
              case 0:
                config.user.video = false;
                config.videoIsOpen = false;
                currentCall = app.call.currentCall();

                if (!currentCall.isDestroyed()) {
                  if (config.isMe) {
                    currentCall.sendPeerManager() && currentCall.sendPeerManager().removeTrack(config.user.videoTopicName);
                  } else {
                    currentCall.receivePeerManager() && currentCall.receivePeerManager().removeTrack(config.user.videoTopicName);
                  }
                }

                _context7.next = 6;
                return publicized.destroyVideo();

              case 6:
              case "end":
                return _context7.stop();
            }
          }
        }, _callee7);
      }))();
    },
    destroyVideo: function destroyVideo() {
      return (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee8() {
        return _regenerator["default"].wrap(function _callee8$(_context8) {
          while (1) {
            switch (_context8.prev = _context8.next) {
              case 0:
                config.videoReceiveVersion = -1;
                config.videoIsOpen = false;

                if (config.htmlElements[config.user.videoTopicName]) {
                  config.htmlElements[config.user.videoTopicName].remove();
                  delete config.htmlElements[config.user.videoTopicName];
                }

                if (app.call.currentCall().receivePeerManager()) {
                  app.call.currentCall().receivePeerManager().removeTrack(config.user.videoTopicName);
                }

              case 4:
              case "end":
                return _context8.stop();
            }
          }
        }, _callee8);
      }))();
    },
    getReceiveVideoVersion: function getReceiveVideoVersion() {
      return config.videoReceiveVersion;
    },
    getReceiveAudioVersion: function getReceiveAudioVersion() {
      return config.audioReceiveVersion;
    },
    processTrackChange: function processTrackChange(conf) {
      if (conf.topic.indexOf('Vi-') > -1) {
        if (!config.videoIsOpen && conf.isReceiving) {
          publicized.startVideo(conf.topic.replace('Vi-', ''), conf);
        } else if (config.videoIsOpen && !conf.isReceiving) {
          publicized.stopVideo();
        } else if (config.videoIsOpen && conf.isReceiving && config.videoReceiveVersion != conf.version) {
          publicized.stopVideo();
          setTimeout(function () {
            publicized.startVideo(conf.topic.replace('Vi-', ''), conf);
          }, 200);
        }
      } else if (conf.topic.indexOf('Vo-') > -1) {
        // config.audioReceiveVersion = conf.version;
        if (!config.audioIsOpen && conf.isReceiving) {
          publicized.startAudio(conf.topic.replace('Vo-', ''), conf);
        } else if (config.audioIsOpen && !conf.isReceiving) {
          publicized.stopAudio();
        } else if (config.audioIsOpen && conf.isReceiving && config.audioReceiveVersion != conf.version) {
          publicized.stopAudio();
          setTimeout(function () {
            publicized.startAudio(conf.topic.replace('Vo-', ''), conf);
          }, 200);
        }
      }
    },
    isVideoOpen: function isVideoOpen() {
      return config.videoIsOpen;
    },
    isAudioOpen: function isAudioOpen() {
      return config.audioIsOpen;
    },
    resetTopicVersion: function resetTopicVersion(topic) {
      if (topic.mediaType == 0) {
        config.videoReceiveVersion = -1;
      } else if (topic.mediaType == 1) {
        config.audioReceiveVersion = -1;
      }
    },
    watchAudioLevel: function watchAudioLevel(stream) {
      var user = config.user,
          topicMetadata = config.topicMetaData; // Create and configure the audio pipeline

      var analyzer = app.call.audioCtx().createAnalyser();
      analyzer.fftSize = 512;
      analyzer.smoothingTimeConstant = 0.1;
      var sourceNode = app.call.audioCtx().createMediaStreamSource(stream);
      sourceNode.connect(analyzer); // Analyze the sound

      topicMetadata.audioLevelInterval = setInterval(function () {
        // Compute the max volume level (-Infinity...0)
        var fftBins = new Float32Array(analyzer.frequencyBinCount); // Number of values manipulated for each sample

        analyzer.getFloatFrequencyData(fftBins); // audioPeakDB varies from -Infinity up to 0

        var audioPeakDB = Math.max.apply(Math, (0, _toConsumableArray2["default"])(fftBins)); // Compute a wave (0...)

        var frequencyRangeData = new Uint8Array(analyzer.frequencyBinCount);
        analyzer.getByteFrequencyData(frequencyRangeData);
        var sum = frequencyRangeData.reduce(function (p, c) {
          return p + c;
        }, 0); // audioMeter varies from 0 to 10

        var audioMeter = Math.sqrt(sum / frequencyRangeData.length); //console.log({audioMeter}, {audioPeakDB});

        if (audioPeakDB > -50 && audioMeter > 0) {
          app.chatEvents.fireEvent('callStreamEvents', {
            type: 'USER_SPEAKING',
            userId: config.userId,
            audioLevel: convertToAudioLevel(audioPeakDB),
            isNoise: false,
            isMute: false
          });
        } else if (audioPeakDB !== -Infinity && audioPeakDB < -60 && audioMeter > 0) {
          app.chatEvents.fireEvent('callStreamEvents', {
            type: 'USER_SPEAKING',
            userId: config.userId,
            audioLevel: 0,
            isNoise: true,
            isMute: false
          });
        } else if (audioPeakDB === -Infinity && audioMeter == 0) {
          app.chatEvents.fireEvent('callStreamEvents', {
            type: 'USER_SPEAKING',
            userId: config.userId,
            audioLevel: 0,
            isNoise: false,
            isMute: true
          });
        }
      }, 500);

      function convertToAudioLevel(soundPower) {
        if (soundPower <= -60) {
          return 0;
        } else if (soundPower >= -60 && soundPower < -50) {
          return 1;
        } else if (soundPower >= -50 && soundPower < -40) {
          return 2;
        } else if (soundPower >= -40 && soundPower < 30) {
          return 3;
        } else if (soundPower >= -30) {
          return 4;
        }
      }
    }
  };

  function addSendTrackToPeerManager(media, retries) {
    if (retries > 3) return;

    if (!app.call.currentCall().sendPeerManager()) {
      retryAgain(media, retries + 1);
      return;
    }

    var addRes;

    if (media == 'video') {
      var stream = app.call.deviceManager.mediaStreams.getVideoInput();
      addRes = app.call.currentCall().sendPeerManager().addTrack({
        currentTrackId: stream.getTracks()[0].id,
        clientId: config.user.clientId,
        topic: config.user.videoTopicName,
        mediaType: 0,
        stream: stream,
        onTrackCallback: onTrackCallback,
        onOpenFailure: onOpenFailure
      });
    } else {
      addRes = app.call.currentCall().sendPeerManager().addTrack({
        clientId: config.user.clientId,
        topic: config.user.audioTopicName,
        mediaType: 1,
        stream: app.call.deviceManager.mediaStreams.getAudioInput(),
        onTrackCallback: onTrackCallback,
        onOpenFailure: onOpenFailure
      });
    }

    if (addRes === 0) {
      retryAgain(media, retries + 1);
    }

    function retryAgain(media, retries) {
      if (config.isDestroyed) return;
      setTimeout(function () {
        addSendTrackToPeerManager(media, retries);
      }, 100);
    }
  }

  function addReceiveTrackToPeerManager(media, conf) {
    var retries = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
    if (retries > 3) return;

    if (!app.call.currentCall().receivePeerManager()) {
      retryAgain(media, conf, retries + 1);
      return;
    }

    var addRes;

    if (media == 'video') {
      addRes = app.call.currentCall().receivePeerManager().addTrack({
        clientId: config.user.clientId,
        topic: config.user.videoTopicName,
        mediaType: 0,
        requestedTopicVersion: conf.version,
        mline: conf && conf.mline,
        onTrackCallback: onTrackCallback,
        onOpenFailure: onOpenFailure,
        onUpdateSuccess: onUpdateSuccess
      });
    } else {
      addRes = app.call.currentCall().receivePeerManager().addTrack({
        clientId: config.user.clientId,
        topic: config.user.audioTopicName,
        mediaType: 1,
        requestedTopicVersion: conf.version,
        mline: conf && conf.mline,
        onTrackCallback: onTrackCallback,
        onOpenFailure: onOpenFailure,
        onUpdateSuccess: onUpdateSuccess
      });
    }

    if (addRes === 0) {
      retryAgain(media, conf, retries + 1);
    }

    function retryAgain(media, conf, retries) {
      if (config.isDestroyed) return;
      setTimeout(function () {
        addReceiveTrackToPeerManager(media, conf, retries);
      }, 100);
    }
  }

  function onOpenFailure(item) {
    if (item.mediaType == 0) {
      config.videoIsOpen = false;
    } else if (item.mediaType == 1) {
      config.audioIsOpen = false;
    }

    if (config.isMe) {
      if (item.mediaType == 0) {
        publicized.startVideo(config.user.topicSend, null);
      } else {
        publicized.startAudio(config.user.topicSend, null);
      }
    } // app.call.currentCall().sendCallMessage({
    //     id: 'REQUEST_RECEIVING_MEDIA',
    //     token: app.sdkParams.token,
    //     chatId: config.callId,
    //     brokerAddress: config.user.brokerAddress,
    // }, null, {});

  }

  function onUpdateSuccess(line) {
    if (line.mediaType == 0) {
      config.videoReceiveVersion = line.requestedTopicVersion;
    } else if (line.mediaType == 1) {
      config.audioReceiveVersion = line.requestedTopicVersion;
    }
  }

  function onTrackCallback(line, track) {
    var stream,
        trc,
        isAudio = line.topic.indexOf('Vo-') > -1,
        isVideo = line.topic.indexOf('Vi-') > -1;

    if (isVideo) {
      if (track) trc = track; // stream = new MediaStream([track]);
      else trc = config.streamTracks.video; // stream = new MediaStream([config.streamTracks.video]);

      config.streamTracks.video = trc;
    } else if (isAudio) {
      if (track) trc = track;else trc = config.streamTracks.audio;
      config.streamTracks.audio = trc;
    }

    stream = new MediaStream([trc]);

    if (isAudio) {
      config.audioStream = stream;

      if (!config.newAudioStreamId) {
        config.oldAudioStreamId = null;
        config.newAudioStreamId = config.audioStream.id;
      } else {
        config.oldAudioStreamId = config.newAudioStreamId;
        config.newAudioStreamId = config.audioStream.id;
      }
    } else {
      config.videoStream = stream;

      if (!config.newVideoStreamId) {
        config.oldVideoStreamId = null;
        config.newVideoStreamId = config.videoStream.id;
      } else {
        config.oldVideoStreamId = config.newVideoStreamId;
        config.newVideoStreamId = config.videoStream.id;
      }
    }

    if (config.isMe) {
      if (isAudio) {
        publicized.watchAudioLevel(stream);
        app.call.currentCall().sendCallDivs();
      } else if (app.sdkParams.enableCallDivs) {
        var el = publicized.getVideoHtmlElement();
        el.srcObject = stream;
        config.htmlElements[config.user.videoTopicName] = el;
        publicized.appendVideoToCallDiv();
      } else {
        //to send streams
        app.call.currentCall().sendCallDivs();
      }
    } else {
      if (isAudio) {
        console.log('[media][audio] create, topic: ', line.topic);
        config.audioObject = new Audio();
        config.audioObject.srcObject = stream; // config.audioObject.srcObject = stream;

        config.audioObject.autoplay = true;
        config.audioObject.play();
        publicized.watchAudioLevel(stream);
        app.call.currentCall().sendCallDivs();
      } else if (isVideo && app.sdkParams.enableCallDivs) {
        var _el = publicized.getVideoHtmlElement();

        _el.srcObject = null;
        setTimeout(function () {
          _el.srcObject = stream;
          config.htmlElements[config.user.videoTopicName] = _el;
          publicized.appendVideoToCallDiv();
        }, 100);
      } else {
        //to send streams
        app.call.currentCall().sendCallDivs();
      }
    }
  }

  function setup(participant) {
    config.user = participant;

    if (config.isMe) {
      config.user.direction = 'send';
    } else {
      config.user.direction = 'receive';
    }

    config.user.videoTopicName = 'Vi-' + config.user.topicSend;
    config.user.audioTopicName = 'Vo-' + config.user.topicSend;

    if (app.sdkParams.enableCallDivs) {
      generateContainerElement();
    }
  }

  function generateContainerElement() {
    if (!config.htmlElements.container) {
      config.htmlElements.container = document.createElement('div');
      var el = config.htmlElements.container;
      el.setAttribute('id', 'callParticipantWrapper-' + config.userId);
      el.classList.add('participant');
      el.classList.add('wrapper');
      el.classList.add('user-' + config.userId);
      el.classList.add(config.isMe ? 'local' : 'remote');
    }

    return config.htmlElements;
  }

  setup(user);
  return publicized;
}

function CallScreenShare(app, user) {
  var config = {
    callId: user.callId,
    userId: user.userId,
    isMe: false,
    user: user,
    videoIsOpen: false,
    type: "screenShare",
    containerTag: null,
    htmlElements: {},
    videoStream: null,
    isDestroyed: false,
    videoReceiveVersion: -1,
    streamTracks: {
      video: null
    },
    oldAudioStreamId: null,
    newAudioStreamId: null
  };
  var publicized = {
    getReceiveVideoVersion: function getReceiveVideoVersion() {
      return config.videoReceiveVersion;
    },
    isVideoOpen: function isVideoOpen() {
      return config.videoIsOpen;
    },
    getVideoStream: function getVideoStream() {
      return config.videoStream;
    },
    getAudioTrack: function getAudioTrack() {
      return null;
    },
    isMe: function isMe() {
      return app.call.currentCall().screenShareInfo.iAmOwner();
    },
    audioIsOpen: function audioIsOpen() {
      return false;
    },
    resetTopicVersions: function resetTopicVersions() {
      config.videoReceiveVersion = -1;
    },
    isScreenShare: function isScreenShare() {
      return true;
    },
    getVideoStreamHasChanged: function getVideoStreamHasChanged() {
      var hasChange = config.oldVideoStreamId != config.newVideoStreamId;
      config.oldVideoStreamId = config.newVideoStreamId;
      if (hasChange) config.htmlElement.setAttribute("data-uniqueId", _utility["default"].generateUUID());
      return hasChange;
    },
    user: function user() {
      return config.user;
    },
    setVideoIsOpen: function setVideoIsOpen(value) {
      config.videoIsOpen = value;
    },
    setAudioIsOpen: function setAudioIsOpen(value) {
      config.audioIsOpen = value;
    },
    getHTMLElements: function getHTMLElements() {
      return config.htmlElements;
    },
    appendVideoToCallDiv: function appendVideoToCallDiv() {
      if (!app.call.sharedVariables.callDivId) {
        app.sdkParams.consoleLogging && console.log('No Call DIV has been declared!');
        return;
      }

      var user = config.user,
          callParentDiv = document.getElementById(app.call.sharedVariables.callDivId),
          userContainer = document.getElementById("callParticipantWrapper-" + config.userId);

      if (!userContainer) {
        callParentDiv.appendChild(config.htmlElements.container);
        userContainer = document.getElementById("callParticipantWrapper-" + config.userId);
      }

      if (user.video) {
        if (!document.getElementById("callUserVideo-" + config.user.videoTopicName)) {
          userContainer.appendChild(config.htmlElements[config.user.videoTopicName]);
          config.videoStream.getTracks()[0].enabled = true;
          setTimeout(function () {
            var el = document.getElementById("callUserVideo-" + config.user.videoTopicName);
            if (!el) return;
            el.addEventListener('loadedmetadata', playTheTag);
            el.srcObject = config.videoStream;

            function playTheTag() {
              el.play();
            }
          }, 500); // config.htmlElements[config.user.videoTopicName].srcObject = config.videoStream
          // config.htmlElements[config.user.videoTopicName].play();
        }
      }

      app.call.currentCall().sendCallDivs();
    },
    audioStopManager: function audioStopManager() {
      return config.user.audioStopManager;
    },
    startAudio: function startAudio(sendTopic) {
      return;
    },
    startVideo: function startVideo(sendTopic, conf) {
      config.user.video = true;
      config.videoIsOpen = true;
      var iAmOwner = app.call.currentCall().screenShareInfo.iAmOwner();

      if (iAmOwner) {
        app.call.deviceManager.grantScreenSharePermission({
          closeStream: false
        }).then(function (stream) {
          if (!stream) {
            alert("Error: could not find screenShareInput");
          } else {
            var onScreenShareEndCallback = function onScreenShareEndCallback(event) {
              // Click on browser UI stop sharing button
              if (!config.user) return;
              stream.getVideoTracks()[0].removeEventListener("ended", onScreenShareEndCallback);

              if (app.call.currentCall() && app.call.currentCall().screenShareInfo.isStarted()) {
                app.call.endScreenShare({
                  callId: config.callId
                });
              }
            };

            stream.getVideoTracks()[0].addEventListener("ended", onScreenShareEndCallback);
            addSendTrackToPeerManager();
          }
        })["catch"](function (error) {// reject(error)
        });
      } else {
        config.videoReceiveVersion = conf.version;
        addReceiveTrackToPeerManager(conf);
      }
    },
    resumeVideoSendStream: function resumeVideoSendStream() {
      var localStream = app.call.deviceManager.mediaStreams.getVideoInput();
      if (localStream) localStream.getTracks()[0].enabled = true;
    },
    processTrackChange: function processTrackChange(conf) {
      if (conf.topic.indexOf('Vi-') > -1 || conf.topic.indexOf('screen') > -1) {
        // config.videoReceiveVersion = conf.version;
        if (!config.videoIsOpen && conf.isReceiving) {
          publicized.startVideo(conf.topic.replace('Vi-', ''), conf);
        } else if (config.videoIsOpen && !conf.isReceiving) {
          config.videoIsOpen = false;
          publicized.stopVideo();
        } else if (config.videoIsOpen && conf.isReceiving && config.videoReceiveVersion != conf.version) {
          //&& config.videoReceiveVersion != conf.version
          publicized.stopVideo();
          setTimeout(function () {
            publicized.startVideo(conf.topic.replace('Vi-', ''), conf);
          }, 200);
        }
      }
    },
    resetTopicVersion: function resetTopicVersion(topic) {
      if (topic.mediaType == 2) {
        config.videoReceiveVersion = -1;
      }
    },
    reconnectTopic: function reconnectTopic(media) {
      return (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee9() {
        return _regenerator["default"].wrap(function _callee9$(_context9) {
          while (1) {
            switch (_context9.prev = _context9.next) {
              case 0:
                _context9.next = 2;
                return publicized.destroyVideo();

              case 2:
                _context9.next = 4;
                return publicized.startVideo(config.user.topic);

              case 4:
              case "end":
                return _context9.stop();
            }
          }
        }, _callee9);
      }))();
    },
    destroy: function destroy() {
      return (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee10() {
        return _regenerator["default"].wrap(function _callee10$(_context10) {
          while (1) {
            switch (_context10.prev = _context10.next) {
              case 0:
                _context10.next = 2;
                return publicized.stopVideo();

              case 2:
                config.isDestroyed = true;
                config.htmlElements = {};
                config.user = null;

              case 5:
              case "end":
                return _context10.stop();
            }
          }
        }, _callee10);
      }))();
    },
    stopVideo: function stopVideo() {
      var _arguments = arguments;
      return (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee11() {
        var _app$call$currentCall;

        var notifyServer, iAmOwner, currentCall;
        return _regenerator["default"].wrap(function _callee11$(_context11) {
          while (1) {
            switch (_context11.prev = _context11.next) {
              case 0:
                notifyServer = _arguments.length > 0 && _arguments[0] !== undefined ? _arguments[0] : true;
                config.user.video = false;
                config.videoIsOpen = false;
                iAmOwner = (_app$call$currentCall = app.call.currentCall().screenShareInfo) === null || _app$call$currentCall === void 0 ? void 0 : _app$call$currentCall.iAmOwner();
                currentCall = app.call.currentCall();

                if (!currentCall.isDestroyed()) {
                  // if(notifyServer) {
                  if (iAmOwner) app.call.currentCall().sendPeerManager() && app.call.currentCall().sendPeerManager().removeTrack(config.user.videoTopicName);else app.call.currentCall().receivePeerManager() && app.call.currentCall().receivePeerManager().removeTrack(config.user.videoTopicName); // throw new Error();
                  // }
                }

                _context11.next = 8;
                return publicized.destroyVideo();

              case 8:
              case "end":
                return _context11.stop();
            }
          }
        }, _callee11);
      }))();
    },
    destroyAudio: function destroyAudio() {},
    destroyVideo: function destroyVideo() {
      return (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee12() {
        var el;
        return _regenerator["default"].wrap(function _callee12$(_context12) {
          while (1) {
            switch (_context12.prev = _context12.next) {
              case 0:
                config.videoReceiveVersion = -1;
                config.videoIsOpen = false;

                if (app.call.currentCall().receivePeerManager()) {
                  app.call.currentCall().receivePeerManager().removeTrack(config.user.videoTopicName);
                }

                if (app.call.currentCall().sendPeerManager()) {
                  app.call.currentCall().sendPeerManager().removeTrack(config.user.videoTopicName);
                }

                el = document.getElementById("callUserVideo-" + config.user.videoTopicName);

                if (el) {
                  el.remove();
                  delete config.htmlElements[config.user.videoTopicName];
                }

              case 6:
              case "end":
                return _context12.stop();
            }
          }
        }, _callee12);
      }))();
    },
    isOwnerChanged: function isOwnerChanged(clientId) {
      return config.user.clientId != clientId;
    }
  };

  function setup(user) {
    var iAmOwner = app.call.currentCall().screenShareInfo.iAmOwner();
    var obj = {
      video: true,
      callId: user.callId,
      userId: user.userId,
      topic: user.topicSend,
      clientId: user.clientId
    };
    obj.direction = iAmOwner ? 'send' : 'receive';
    obj.videoTopicName = obj.topic; //`Vi-send-${obj.callId}-screenShare`;//config.topic;

    config.user = obj;
    config.isMe = app.call.currentCall().screenShareInfo.iAmOwner(); // publicized.appendUserToCallDiv(generateContainerElement())

    if (app.sdkParams.enableCallDivs) {
      generateContainerElement();
    }

    if (config.user.video && app.call.currentCall().screenShareInfo.iAmOwner()) {
      publicized.startVideo(obj.topic);
    }
  }

  function addSendTrackToPeerManager(retries) {
    if (retries > 3) return;

    if (!app.call.currentCall().sendPeerManager()) {
      retryAgain(retries + 1);
      return;
    }

    var addRes = app.call.currentCall().sendPeerManager().addTrack({
      clientId: config.user.clientId,
      topic: config.user.videoTopicName,
      mediaType: 2,
      isScreenShare: true,
      stream: app.call.deviceManager.mediaStreams.getScreenShareInput(),
      onTrackCallback: onTrackCallback
    });

    if (addRes === 0) {
      retryAgain(retries + 1);
    }

    function retryAgain(retries) {
      if (config.isDestroyed) return;
      setTimeout(function () {
        addSendTrackToPeerManager(retries);
      }, 10);
    }
  }

  function addReceiveTrackToPeerManager(conf) {
    var retries = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
    if (retries > 3) return;

    if (!app.call.currentCall().receivePeerManager()) {
      retryAgain(conf, retries + 1);
      return;
    }

    var addRes = app.call.currentCall().receivePeerManager().addTrack({
      clientId: config.user.clientId,
      topic: config.user.videoTopicName,
      mediaType: 2,
      isScreenShare: true,
      requestedTopicVersion: conf.version,
      mline: conf && conf.mline,
      onTrackCallback: onTrackCallback,
      onOpenFailure: onOpenFailure,
      onUpdateSuccess: onUpdateSuccess
    });

    if (addRes === 0) {
      retryAgain(conf, retries + 1);
    }

    function retryAgain(conf, retries) {
      if (config.isDestroyed) return;
      setTimeout(function () {
        addReceiveTrackToPeerManager(conf, retries);
      }, 10);
    }
  }

  function onOpenFailure(item) {
    if (item.mediaType == 2) {
      config.videoIsOpen = false;
    }

    if (publicized.isMe()) {
      if (item.mediaType == 2) {
        publicized.startVideo(config.user.topicSend, null);
      }
    } // app.call.currentCall().sendCallMessage({
    //     id: 'REQUEST_RECEIVING_MEDIA',
    //     token: app.sdkParams.token,
    //     chatId: config.callId,
    //     brokerAddress: config.user.brokerAddress,
    // }, null, {});

  }

  function generateContainerElement() {
    if (!config.htmlElements.container) {
      config.htmlElements.container = document.createElement('div');
      var el = config.htmlElements.container;
      el.setAttribute('id', 'callParticipantWrapper-' + config.userId);
      el.classList.add('participant');
      el.classList.add('wrapper');
      el.classList.add('user-' + config.userId);
      el.classList.add(config.isMe ? 'local' : 'remote');
    }

    return config.htmlElements;
  }

  function getVideoHtmlElement() {
    var elementUniqueId = _utility["default"].generateUUID();

    if (config.user.video && !config.htmlElement) {
      config.htmlElement = document.createElement('video');
      var el = config.htmlElement;
      el.setAttribute('id', 'callUserVideo-' + config.user.videoTopicName);
      el.setAttribute('class', app.call.sharedVariables.callVideoTagClassName);
      el.setAttribute('playsinline', '');
      el.setAttribute('muted', '');
      el.setAttribute('autoplay', '');
      el.setAttribute('data-uniqueId', elementUniqueId);
      el.setAttribute('width', app.call.sharedVariables.callVideoMinWidth + 'px');
      el.setAttribute('height', app.call.sharedVariables.callVideoMinHeight + 'px'); // el.setAttribute('controls', '');
    }

    return config.htmlElement;
  }

  function onUpdateSuccess(line) {
    config.videoReceiveVersion = line.requestedTopicVersion;
  }

  function onTrackCallback(line, track) {
    var trc;

    if (line.mediaType == 2) {
      if (track) trc = track; // stream = new MediaStream([track]);
      else trc = config.streamTracks.video;
    } // trc.onunmute = (event) => {
    //     console.log('[debug][onTrackCallback][trc.onunmute] ', event)
    // }
    // trc.onmute = (event) => {
    //     console.log('[debug][onTrackCallback][trc.onmute] ', event)
    // }


    config.streamTracks.video = trc;
    var stream = new MediaStream([trc]);
    config.videoStream = stream;

    if (!config.newVideoStreamId) {
      config.oldVideoStreamId = null;
      config.newVideoStreamId = config.videoStream.id;
    } else {
      config.oldVideoStreamId = config.newVideoStreamId;
      config.newVideoStreamId = config.videoStream.id;
    }

    if (app.sdkParams.enableCallDivs) {
      var el = getVideoHtmlElement(); // el.addEventListener('loadedmetadata', playTheTag);
      // el.srcObject = stream;

      config.htmlElements[config.user.videoTopicName] = el;
      publicized.appendVideoToCallDiv();
    }
  }

  setup(user);
  return publicized;
}