Quellcode durchsuchen

ref(RTC): rename "owner" to "ownerEndpointId"

master
paweldomas vor 8 Jahren
Ursprung
Commit
af26c86db0
3 geänderte Dateien mit 18 neuen und 16 gelöschten Zeilen
  1. 5
    5
      modules/RTC/JitsiRemoteTrack.js
  2. 7
    5
      modules/RTC/RTC.js
  3. 6
    6
      modules/RTC/TraceablePeerConnection.js

+ 5
- 5
modules/RTC/JitsiRemoteTrack.js Datei anzeigen

15
  * @param {RTC} rtc the RTC service instance.
15
  * @param {RTC} rtc the RTC service instance.
16
  * @param {JitsiConference} conference the conference to which this track
16
  * @param {JitsiConference} conference the conference to which this track
17
  *        belongs to
17
  *        belongs to
18
- * @param {string} owner the endpoint ID of the track owner
18
+ * @param {string} ownerEndpointId the endpoint ID of the track owner
19
  * @param {MediaStream} stream WebRTC MediaStream, parent of the track
19
  * @param {MediaStream} stream WebRTC MediaStream, parent of the track
20
  * @param {MediaStreamTrack} track underlying WebRTC MediaStreamTrack for
20
  * @param {MediaStreamTrack} track underlying WebRTC MediaStreamTrack for
21
  *        the new JitsiRemoteTrack
21
  *        the new JitsiRemoteTrack
25
  * @param {boolean} muted the initial muted state
25
  * @param {boolean} muted the initial muted state
26
  * @constructor
26
  * @constructor
27
  */
27
  */
28
-function JitsiRemoteTrack(rtc, conference, owner, stream, track, mediaType, videoType,
29
-                          ssrc, muted) {
28
+function JitsiRemoteTrack(rtc, conference, ownerEndpointId, stream, track,
29
+                          mediaType, videoType, ssrc, muted) {
30
     JitsiTrack.call(
30
     JitsiTrack.call(
31
         this, conference, stream, track, function () {}, mediaType, videoType, ssrc);
31
         this, conference, stream, track, function () {}, mediaType, videoType, ssrc);
32
     this.rtc = rtc;
32
     this.rtc = rtc;
33
-    this.owner = owner;
33
+    this.ownerEndpointId = ownerEndpointId;
34
     this.muted = muted;
34
     this.muted = muted;
35
     // we want to mark whether the track has been ever muted
35
     // we want to mark whether the track has been ever muted
36
     // to detect ttfm events for startmuted conferences, as it can significantly
36
     // to detect ttfm events for startmuted conferences, as it can significantly
105
  * endpoint id/MUC nickname in case of Jitsi-meet.
105
  * endpoint id/MUC nickname in case of Jitsi-meet.
106
  */
106
  */
107
 JitsiRemoteTrack.prototype.getParticipantId = function() {
107
 JitsiRemoteTrack.prototype.getParticipantId = function() {
108
-    return this.owner;
108
+    return this.ownerEndpointId;
109
 };
109
 };
110
 
110
 
111
 /**
111
 /**

+ 7
- 5
modules/RTC/RTC.js Datei anzeigen

383
      * Initializes a new JitsiRemoteTrack instance with the data provided by
383
      * Initializes a new JitsiRemoteTrack instance with the data provided by
384
      * the signalling layer and SDP.
384
      * the signalling layer and SDP.
385
      *
385
      *
386
-     * @param {string} owner
386
+     * @param {string} ownerEndpointId
387
      * @param {MediaStream} stream
387
      * @param {MediaStream} stream
388
      * @param {MediaStreamTrack} track
388
      * @param {MediaStreamTrack} track
389
      * @param {MediaType} mediaType
389
      * @param {MediaType} mediaType
391
      * @param {string} ssrc
391
      * @param {string} ssrc
392
      * @param {boolean} muted
392
      * @param {boolean} muted
393
      */
393
      */
394
-    _createRemoteTrack (owner,
394
+    _createRemoteTrack (ownerEndpointId,
395
                         stream, track, mediaType, videoType, ssrc, muted) {
395
                         stream, track, mediaType, videoType, ssrc, muted) {
396
         const remoteTrack
396
         const remoteTrack
397
             = new JitsiRemoteTrack(
397
             = new JitsiRemoteTrack(
398
-                this, this.conference, owner, stream, track,
398
+                this, this.conference, ownerEndpointId, stream, track,
399
                 mediaType, videoType, ssrc, muted);
399
                 mediaType, videoType, ssrc, muted);
400
         const remoteTracks
400
         const remoteTracks
401
-            = this.remoteTracks[owner] || (this.remoteTracks[owner] = {});
401
+            = this.remoteTracks[ownerEndpointId]
402
+                || (this.remoteTracks[ownerEndpointId] = {});
402
 
403
 
403
         if (remoteTracks[mediaType]) {
404
         if (remoteTracks[mediaType]) {
404
-            logger.error("Overwriting remote track!", owner, mediaType);
405
+            logger.error(
406
+                "Overwriting remote track!", ownerEndpointId, mediaType);
405
         }
407
         }
406
         remoteTracks[mediaType] = remoteTrack;
408
         remoteTracks[mediaType] = remoteTrack;
407
 
409
 

+ 6
- 6
modules/RTC/TraceablePeerConnection.js Datei anzeigen

299
     // FIXME the length of ssrcLines[0] not verified, but it will fail
299
     // FIXME the length of ssrcLines[0] not verified, but it will fail
300
     // with global error handler anyway
300
     // with global error handler anyway
301
     let trackSsrc = ssrcLines[0].substring(7).split(' ')[0];
301
     let trackSsrc = ssrcLines[0].substring(7).split(' ')[0];
302
-    const owner = this.signallingLayer.getSSRCOwner(trackSsrc);
302
+    const ownerEndpointId = this.signallingLayer.getSSRCOwner(trackSsrc);
303
 
303
 
304
-    if (!owner) {
304
+    if (!ownerEndpointId) {
305
         GlobalOnErrorHandler.callErrorHandler(
305
         GlobalOnErrorHandler.callErrorHandler(
306
             new Error(
306
             new Error(
307
                 "No SSRC owner known for: " + trackSsrc
307
                 "No SSRC owner known for: " + trackSsrc
311
         return;
311
         return;
312
     }
312
     }
313
 
313
 
314
-    logger.log('associated ssrc', owner, trackSsrc);
314
+    logger.log('associated ssrc', ownerEndpointId, trackSsrc);
315
 
315
 
316
     const peerMediaInfo
316
     const peerMediaInfo
317
-        = this.signallingLayer.getPeerMediaInfo(owner, mediaType);
317
+        = this.signallingLayer.getPeerMediaInfo(ownerEndpointId, mediaType);
318
 
318
 
319
     if (!peerMediaInfo) {
319
     if (!peerMediaInfo) {
320
         GlobalOnErrorHandler.callErrorHandler(
320
         GlobalOnErrorHandler.callErrorHandler(
321
-            new Error("No peer media info available for: " + owner));
321
+            new Error("No peer media info available for: " + ownerEndpointId));
322
         // Abort
322
         // Abort
323
         return;
323
         return;
324
     }
324
     }
327
     const videoType = peerMediaInfo.videoType; // can be undefined
327
     const videoType = peerMediaInfo.videoType; // can be undefined
328
 
328
 
329
     this.rtc._createRemoteTrack(
329
     this.rtc._createRemoteTrack(
330
-        owner, stream, track, mediaType, videoType, trackSsrc, muted);
330
+        ownerEndpointId, stream, track, mediaType, videoType, trackSsrc, muted);
331
 };
331
 };
332
 
332
 
333
 /**
333
 /**

Laden…
Abbrechen
Speichern