podchat-browser 12.9.19-snapshot.9 → 12.9.19

package/changelog.md

@@ -5,7 +5,27 @@ to see complete list of changelog please visit [ChangeLog](http://gp.fanapsoft.i
 
 ## [Unreleased]
 
-## [12.9.18] 05-01-2025
+## [12.9.19] 30-05-2026
+
+### Added
+- Added possibility to get the original data from threads cache
+- Added method reInit
+- Implemented dataChannel for multitrack calls
+- Added new callType other than normal callType for single user calls
+- Added method getKurentoPeersQualityMetrics
+- Added method getJanusPeersQualityMetrics
+- Added possibility to startSendDataChannel when needed
+
+### Fixed
+- Improved REMOVE_CALL_PARTICIPANT event type 95
+- Fixed bug in method forceJoin
+- Fixed bugs in new contact methods
+
+### Changed
+- Added uniqueId to new thread event
+- Added field returnOriginalData to get originalData from cache
+
+## [12.9.18] 05-01-2026
 
 ### Added
 
@@ -42,7 +62,6 @@ to see complete list of changelog please visit [ChangeLog](http://gp.fanapsoft.i
 
 ### Added
 
-
 - Added optional in memory cache for getThreads
 - Added optional in memory cache for getHistory
 - Added cache for method getHistoryByMessageIdRange

package/dist/node/buildConfig.json

@@ -1 +1 @@
-{"version":"12.9.19-snapshot.9","date":"۱۴۰۵/۲/۱۲","VersionInfo":"Release: false, Snapshot: true, Is For Test: true"}
+{"version":"12.9.19","date":"۱۴۰۵/۳/۹","VersionInfo":"Release: true, Snapshot: false, Is For Test: false"}

package/dist/node/call.module.js

@@ -471,7 +471,7 @@ function ChatCall(app, params) {
 
 
   function shouldNotProcessChatMessage(type, threadId) {
-    var restrictedMessageTypes = [_constants.chatMessageVOTypes.MUTE_CALL_PARTICIPANT, _constants.chatMessageVOTypes.UNMUTE_CALL_PARTICIPANT, _constants.chatMessageVOTypes.CALL_PARTICIPANT_JOINED, _constants.chatMessageVOTypes.REMOVE_CALL_PARTICIPANT, _constants.chatMessageVOTypes.RECONNECT, _constants.chatMessageVOTypes.TURN_OFF_VIDEO_CALL, _constants.chatMessageVOTypes.TURN_ON_VIDEO_CALL, _constants.chatMessageVOTypes.DESTINED_RECORD_CALL, _constants.chatMessageVOTypes.RECORD_CALL, _constants.chatMessageVOTypes.RECORD_CALL_STARTED, _constants.chatMessageVOTypes.END_RECORD_CALL, _constants.chatMessageVOTypes.TERMINATE_CALL, _constants.chatMessageVOTypes.CALL_STICKER_SYSTEM_MESSAGE, _constants.chatMessageVOTypes.CALL_RECORDING_FAILED, _constants.chatMessageVOTypes.RAISE_HAND, _constants.chatMessageVOTypes.LOWER_HAND, _constants.chatMessageVOTypes.SWITCH_TO_GROUP_CALL_REQUEST // chatMessageVOTypes.END_CALL
+    var restrictedMessageTypes = [_constants.chatMessageVOTypes.MUTE_CALL_PARTICIPANT, _constants.chatMessageVOTypes.UNMUTE_CALL_PARTICIPANT, _constants.chatMessageVOTypes.CALL_PARTICIPANT_JOINED, _constants.chatMessageVOTypes.REMOVE_CALL_PARTICIPANT, _constants.chatMessageVOTypes.RECONNECT, _constants.chatMessageVOTypes.TURN_OFF_VIDEO_CALL, _constants.chatMessageVOTypes.TURN_ON_VIDEO_CALL, _constants.chatMessageVOTypes.DESTINED_RECORD_CALL, _constants.chatMessageVOTypes.RECORD_CALL, _constants.chatMessageVOTypes.RECORD_CALL_STARTED, _constants.chatMessageVOTypes.END_RECORD_CALL, _constants.chatMessageVOTypes.TERMINATE_CALL, _constants.chatMessageVOTypes.CALL_STICKER_SYSTEM_MESSAGE, _constants.chatMessageVOTypes.CALL_RECORDING_FAILED, _constants.chatMessageVOTypes.RAISE_HAND, _constants.chatMessageVOTypes.LOWER_HAND, _constants.chatMessageVOTypes.SWITCH_TO_GROUP_CALL_REQUEST, _constants.chatMessageVOTypes.CALL_PARTICIPANT_FORCE_JOINED // chatMessageVOTypes.END_CALL
     ];
 
     if ((!app.call.callStopQueue.callStarted || threadId != app.callsManager.currentCallId()) && restrictedMessageTypes.includes(type)) {
@@ -600,11 +600,6 @@ function ChatCall(app, params) {
 
         break;
 
-      /**
-       * Type 263    Force Join
-       */
-
-      case _constants.chatMessageVOTypes.FORCE_JOIN:
       /**
        * Type 74    Start Call (Start sender and receivers)
        */
@@ -1244,6 +1239,52 @@ function ChatCall(app, params) {
       case _constants.chatMessageVOTypes.REMOVE_PERMISSION_FROM_CALL_PARTICIPANT:
         app.call.adminMethods.onRemoveCallParticipantsPermission(uniqueId, messageContent, chatMessage, threadId);
         break;
+
+      /**
+       * Type 263    Force Join
+       */
+
+      case _constants.chatMessageVOTypes.FORCE_JOIN:
+        if (app.call.currentCall()) {
+          app.chatEvents.fireEvent('callEvents', {
+            type: 'FORCE_JOINED_ELSEWHERE',
+            callId: threadId,
+            message: 'User force joined elsewhere',
+            uniqueId: uniqueId
+          });
+          app.call.currentCall().forceSilentClose();
+          app.callsManager.removeItem(app.callsManager.currentCallId());
+          return;
+        }
+
+        if (!callRequestController.canProcessStartCall(threadId)) {
+          app.chatEvents.fireEvent('callEvents', {
+            type: 'CALL_STARTED_ELSEWHERE',
+            callId: threadId,
+            message: 'Call already started somewhere else..., aborting...',
+            uniqueId: uniqueId
+          });
+          return;
+        }
+
+        callRequestController.iRequestedCall = false;
+        callRequestController.iAcceptedCall = false;
+        processChatStartCallEvent(chatMessage, type, messageContent, contentCount, threadId, uniqueId);
+        break;
+
+      /**
+       * Type 264    A user has forceJoined
+       */
+
+      case _constants.chatMessageVOTypes.CALL_PARTICIPANT_FORCE_JOINED:
+        app.call.currentCall().updateParticipantsState();
+        app.chatEvents.fireEvent('callEvents', {
+          type: 'CALL_PARTICIPANT_FORCE_JOINED',
+          callId: threadId,
+          result: messageContent,
+          uniqueId: uniqueId
+        });
+        break;
     }
   };
 

package/dist/node/chat.js

@@ -1901,6 +1901,7 @@ function Chat(params) {
       case _constants.chatMessageVOTypes.RECEIVE_CALL_REQUEST:
       case _constants.chatMessageVOTypes.START_CALL:
       case _constants.chatMessageVOTypes.FORCE_JOIN:
+      case _constants.chatMessageVOTypes.CALL_PARTICIPANT_FORCE_JOINED:
       case _constants.chatMessageVOTypes.START_CALL_INSTANT:
       case _constants.chatMessageVOTypes.END_CALL_REQUEST:
       case _constants.chatMessageVOTypes.END_CALL:
@@ -8962,7 +8963,18 @@ function Chat(params) {
       })), null, true, {});
     }
 
-    app.call.currentCall().sendCallData(params.jsonData);
+    if (app.call.currentCall().sendCallData) app.call.currentCall().sendCallData(params.jsonData);
+  };
+
+  publicized.startSendDataChannel = function (params, callback) {
+    if (!app.call.currentCall()) {
+      app.errorHandler.raiseError(app.errorHandler.getFilledErrorObject(_objectSpread(_objectSpread({}, _errorHandler.errorList.INVALID_CALLID), {}, {
+        replacements: ['startSendDataChannel']
+      })), callback, false, {});
+      return;
+    }
+
+    app.call.currentCall().startSendDataChannel();
   };
 
   publicized.getKurentoPeersQualityMetrics = /*#__PURE__*/function () {
@@ -9018,6 +9030,59 @@ function Chat(params) {
     };
   }();
 
+  publicized.getJanusPeersQualityMetrics = /*#__PURE__*/function () {
+    var _ref5 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2(params, callback) {
+      var parseData, metrics;
+      return _regenerator["default"].wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              if (app.call.currentCall()) {
+                _context2.next = 3;
+                break;
+              }
+
+              app.errorHandler.raiseError(app.errorHandler.getFilledErrorObject(_objectSpread(_objectSpread({}, _errorHandler.errorList.INVALID_CALLID), {}, {
+                replacements: ['getJanusPeersQualityMetrics']
+              })), callback, false, {});
+              return _context2.abrupt("return");
+
+            case 3:
+              parseData = params.parseData;
+
+              if (!app.call.currentCall().callServerController().isJanus()) {
+                _context2.next = 11;
+                break;
+              }
+
+              _context2.next = 7;
+              return app.call.currentCall().getJanusPeersQualityMetrics(parseData);
+
+            case 7:
+              metrics = _context2.sent;
+              callback && callback({
+                hasEror: false,
+                result: metrics
+              });
+              _context2.next = 12;
+              break;
+
+            case 11:
+              app.errorHandler.raiseError(_errorHandler.errorList.CALL_SERVER_IS_NOT_JANUS, callback, false, {});
+
+            case 12:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2);
+    }));
+
+    return function (_x3, _x4) {
+      return _ref5.apply(this, arguments);
+    };
+  }();
+
   publicized.reInit = function (config) {
     app.messenger.stopChatPing();
     params.socketAddress = config.socketAddress;

package/dist/node/lib/call/multitrack/callManager.js

@@ -62,7 +62,10 @@ function MultiTrackCallManager(_ref) {
     inquiryCallCounter: 0,
     receivePeerReConnectTimes: 0,
     ti: atob(callConfig.tInfo).split(":"),
-    callType: callConfig.callType
+    callType: callConfig.callType,
+    janusQualityMonitor: null,
+    silentEndCall: false,
+    sendDataChannelEnabled: false
   };
   var publicized = {
     processCallMessage: processCallMessage,
@@ -285,11 +288,11 @@ function MultiTrackCallManager(_ref) {
   }
 
   function _correctWhenScreenOwnerChanged() {
-    _correctWhenScreenOwnerChanged = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee9(_ref3) {
+    _correctWhenScreenOwnerChanged = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee11(_ref3) {
       var inquiryResult, dataChangeDetected, screenOwnerChatId;
-      return _regenerator["default"].wrap(function _callee9$(_context10) {
+      return _regenerator["default"].wrap(function _callee11$(_context12) {
         while (1) {
-          switch (_context10.prev = _context10.next) {
+          switch (_context12.prev = _context12.next) {
             case 0:
               inquiryResult = _ref3.inquiryResult, dataChangeDetected = _ref3.dataChangeDetected;
               screenOwnerChatId = config.users.findUserIdByClientId(Number(inquiryResult.screenShareUser));
@@ -302,11 +305,11 @@ function MultiTrackCallManager(_ref) {
               // }
 
               if (!config.users.userExists('screenShare')) {
-                _context10.next = 11;
+                _context12.next = 11;
                 break;
               }
 
-              _context10.next = 10;
+              _context12.next = 10;
               return config.users.removeItem('screenShare');
 
             case 10:
@@ -317,10 +320,10 @@ function MultiTrackCallManager(_ref) {
 
             case 12:
             case "end":
-              return _context10.stop();
+              return _context12.stop();
           }
         }
-      }, _callee9);
+      }, _callee11);
     }));
     return _correctWhenScreenOwnerChanged.apply(this, arguments);
   }
@@ -539,7 +542,7 @@ function MultiTrackCallManager(_ref) {
           sendPeerFailed && createPeerManager('send');
           setTimeout(function () {
             if (sendPeerFailed) {
-              if (app.sdkParams.callOptions.enableDataChannel) {
+              if (app.sdkParams.callOptions.enableDataChannel && config.sendDataChannelEnabled) {
                 config.sendPeerManager.startDataChannel();
                 config.sendPeerManager.addTrack({
                   topic: "data-channel-".concat(config.callId, "-").concat(config.users.get(app.store.user.get().id).user().clientId),
@@ -793,7 +796,7 @@ function MultiTrackCallManager(_ref) {
 
                               _i = _context2.t1.value;
                               _context2.next = 5;
-                              return checkTURNServer(serversTemp[_i].split(":")[0], '3478', true, config.ti[0], config.ti[1], 3000);
+                              return checkTURNServer(serversTemp[_i].split(":")[0], '3478', true, config.ti[0], config.ti[1], 4000);
 
                             case 5:
                               turnCheckRes = _context2.sent;
@@ -877,9 +880,8 @@ function MultiTrackCallManager(_ref) {
         var user = config.users.get(app.store.user.get().id); //Start my own senders
 
         if (app.sdkParams.callOptions.enableDataChannel) {
-          config.receivePeerManager.startDataChannel();
-          config.sendPeerManager.startDataChannel();
-          user.startDataChannel();
+          config.receivePeerManager.startDataChannel(); // config.sendPeerManager.startDataChannel();
+          // user.startDataChannel();
         }
 
         if (user.user().video) {
@@ -916,24 +918,24 @@ function MultiTrackCallManager(_ref) {
   }
 
   function _callStop() {
-    _callStop = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee10() {
+    _callStop = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee12() {
       var resetCurrentCallId,
           resetCameraPaused,
-          _args11 = arguments;
-      return _regenerator["default"].wrap(function _callee10$(_context11) {
+          _args13 = arguments;
+      return _regenerator["default"].wrap(function _callee12$(_context13) {
         while (1) {
-          switch (_context11.prev = _context11.next) {
+          switch (_context13.prev = _context13.next) {
             case 0:
-              resetCurrentCallId = _args11.length > 0 && _args11[0] !== undefined ? _args11[0] : true;
-              resetCameraPaused = _args11.length > 1 && _args11[1] !== undefined ? _args11[1] : true;
-              _context11.next = 4;
+              resetCurrentCallId = _args13.length > 0 && _args13[0] !== undefined ? _args13[0] : true;
+              resetCameraPaused = _args13.length > 1 && _args13[1] !== undefined ? _args13[1] : true;
+              _context13.next = 4;
               return config.users.destroy();
 
             case 4:
               config.sendPeerManager && config.sendPeerManager.destroy();
               config.receivePeerManager && config.receivePeerManager.destroy();
 
-              if (app.call.callStopQueue.callStarted) {
+              if (app.call.callStopQueue.callStarted && !config.silentEndCall) {
                 sendCallMessage({
                   id: 'EXIT_CLIENT',
                   token: app.sdkParams.token
@@ -948,10 +950,10 @@ function MultiTrackCallManager(_ref) {
 
             case 11:
             case "end":
-              return _context11.stop();
+              return _context13.stop();
           }
         }
-      }, _callee10);
+      }, _callee12);
     }));
     return _callStop.apply(this, arguments);
   }
@@ -1409,7 +1411,7 @@ function MultiTrackCallManager(_ref) {
         //         config.users.get(userId).appendVideoToCallDiv();
         //     }
         // }
-        config.receivePeerManager.removeRequestTimeout(uniqueId);
+        config.receivePeerManager && config.receivePeerManager.removeRequestTimeout(uniqueId);
         config.receivePeerManager && config.receivePeerManager.processingCurrentTrackCompleted(); // config.isReconnecting = false;
         // config.receivePeerManager && requestReceivingMedia();
 
@@ -2222,6 +2224,258 @@ function MultiTrackCallManager(_ref) {
     config.sendPeerManager.sendCallData(jsonData);
   };
 
+  publicized.startSendDataChannel = function () {
+    config.sendDataChannelEnabled = true;
+    config.sendPeerManager.startDataChannel();
+    config.sendPeerManager.addTrack({
+      topic: "data-channel-".concat(config.callId, "-").concat(config.users.get(app.store.user.get().id).user().clientId),
+      mediaType: 3,
+      //currentTrackId: stream.getTracks()[0].id,
+      clientId: config.users.get(app.store.user.get().id).user().clientId,
+      onTrackCallback: function onTrackCallback() {}
+    });
+  };
+
+  function createJanusQualityMonitor() {
+    var prev = new Map();
+
+    function calcBitrate(id, bytes, now) {
+      var last = prev.get(id);
+
+      if (!last) {
+        prev.set(id, {
+          bytes: bytes,
+          time: now
+        });
+        return null;
+      }
+
+      var bitrate = (bytes - last.bytes) * 8 / ((now - last.time) / 1000);
+      prev.set(id, {
+        bytes: bytes,
+        time: now
+      });
+      return bitrate;
+    }
+
+    function calcLoss(pLost, pRecv) {
+      var total = pLost + pRecv;
+      if (total === 0) return 0;
+      return pLost / total * 100;
+    }
+
+    function trackId(report) {
+      return "".concat(report.kind, "_").concat(report.ssrc, "_").concat(report.mid || "x");
+    }
+
+    function parsePc(_x16, _x17, _x18) {
+      return _parsePc.apply(this, arguments);
+    }
+
+    function _parsePc() {
+      _parsePc = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee9(pc, type, parseData) {
+        var stats, now, out;
+        return _regenerator["default"].wrap(function _callee9$(_context10) {
+          while (1) {
+            switch (_context10.prev = _context10.next) {
+              case 0:
+                _context10.next = 2;
+                return pc.getStats();
+
+              case 2:
+                stats = _context10.sent;
+                now = Date.now();
+
+                if (parseData) {
+                  _context10.next = 8;
+                  break;
+                }
+
+                return _context10.abrupt("return", stats);
+
+              case 8:
+                out = {
+                  connection: {},
+                  tracks: {}
+                };
+                stats.forEach(function (report) {
+                  // ---------- CONNECTION ----------
+                  if (report.type === "candidate-pair" && report.state === "succeeded") {
+                    out.connection.rtt = report.currentRoundTripTime;
+                  } // ---------- INBOUND (RECV) ----------
+
+
+                  if (report.type === "inbound-rtp" && !report.isRemote) {
+                    var id = trackId(report);
+                    if (!out.tracks[id]) out.tracks[id] = {
+                      kind: report.kind
+                    };
+                    var t = out.tracks[id];
+                    t.direction = "recv"; // jitter
+
+                    t.jitter = report.jitter; // loss
+
+                    if (report.packetsLost != null && report.packetsReceived != null) {
+                      t.loss = calcLoss(report.packetsLost, report.packetsReceived);
+                    } // bitrate
+
+
+                    if (report.bytesReceived != null) {
+                      t.bitrate = calcBitrate(report.id, report.bytesReceived, now);
+                    }
+
+                    if (report.kind === "video") {
+                      t.fps = report.framesPerSecond;
+                      t.frameDrops = report.framesDropped;
+                    }
+                  } // ---------- OUTBOUND (SEND) ----------
+
+
+                  if (report.type === "outbound-rtp") {
+                    var _id = trackId(report);
+
+                    if (!out.tracks[_id]) out.tracks[_id] = {
+                      kind: report.kind
+                    };
+                    var _t = out.tracks[_id];
+                    _t.direction = "send";
+
+                    if (report.bytesSent != null) {
+                      _t.bitrate = calcBitrate(report.id, report.bytesSent, now);
+                    }
+
+                    if (report.kind === "video") {
+                      _t.fps = report.framesPerSecond;
+                    }
+
+                    if (report.qualityLimitationReason) {
+                      _t.qualityLimitation = report.qualityLimitationReason;
+                    }
+                  } // ---------- REMOTE (SEND LOSS) ----------
+
+
+                  if (report.type === "remote-inbound-rtp") {
+                    var _id2 = trackId(report);
+
+                    if (!out.tracks[_id2]) out.tracks[_id2] = {
+                      kind: report.kind
+                    };
+                    var _t2 = out.tracks[_id2]; // jitter
+
+                    _t2.jitter = report.jitter;
+
+                    if (report.fractionLost != null) {
+                      _t2.loss = report.fractionLost / 256 * 100;
+                    } else if (report.packetsLost != null) {
+                      _t2.loss = report.packetsLost; // fallback
+                    }
+
+                    if (report.roundTripTime) {
+                      out.connection.rtt = report.roundTripTime;
+                    }
+                  }
+                });
+                return _context10.abrupt("return", out);
+
+              case 11:
+              case "end":
+                return _context10.stop();
+            }
+          }
+        }, _callee9);
+      }));
+      return _parsePc.apply(this, arguments);
+    }
+
+    function getStats(_x19) {
+      return _getStats.apply(this, arguments);
+    }
+
+    function _getStats() {
+      _getStats = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee10(parseData) {
+        var sendPc, recvPc, send, recv;
+        return _regenerator["default"].wrap(function _callee10$(_context11) {
+          while (1) {
+            switch (_context11.prev = _context11.next) {
+              case 0:
+                sendPc = config.sendPeerManager.getPeer().peerConnection;
+                recvPc = config.receivePeerManager.getPeer().peerConnection;
+
+                if (!sendPc) {
+                  _context11.next = 8;
+                  break;
+                }
+
+                _context11.next = 5;
+                return parsePc(sendPc, "send", parseData);
+
+              case 5:
+                _context11.t0 = _context11.sent;
+                _context11.next = 9;
+                break;
+
+              case 8:
+                _context11.t0 = null;
+
+              case 9:
+                send = _context11.t0;
+
+                if (!recvPc) {
+                  _context11.next = 16;
+                  break;
+                }
+
+                _context11.next = 13;
+                return parsePc(recvPc, "recv", parseData);
+
+              case 13:
+                _context11.t1 = _context11.sent;
+                _context11.next = 17;
+                break;
+
+              case 16:
+                _context11.t1 = null;
+
+              case 17:
+                recv = _context11.t1;
+                return _context11.abrupt("return", {
+                  send: send,
+                  recv: recv
+                });
+
+              case 19:
+              case "end":
+                return _context11.stop();
+            }
+          }
+        }, _callee10);
+      }));
+      return _getStats.apply(this, arguments);
+    }
+
+    return {
+      getStats: getStats
+    };
+  }
+
+  publicized.getJanusPeersQualityMetrics = function () {
+    var parseData = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+    if (!config.janusQualityMonitor) config.janusQualityMonitor = createJanusQualityMonitor();
+    return config.janusQualityMonitor.getStats(parseData);
+  };
+
+  publicized.forceSilentClose = function () {
+    config.silentEndCall = true; // publicized.destroy();
+  };
+
+  publicized.isForceSilentClose = function () {
+    return config.silentEndCall;
+  };
+
+  publicized.updateParticipantsState = function () {
+    socketConnectListener();
+  };
+
   setTimeout(function () {
     startCallWebRTCFunctions(config.callConfig);
   }, 50);