[_] Bring updates

.github/workflows/ci.yml

@@ -7,8 +7,8 @@ jobs:
     name: Build
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
-    - uses: actions/setup-node@v4
+    - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5  # v4
+    - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020  # v4
       with:
         node-version-file: '.nvmrc'
         cache: 'npm'

.github/workflows/deploy-docs.yml

@@ -21,8 +21,8 @@ jobs:
       url: ${{ steps.deployment.outputs.page_url }}
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5  # v4
+      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020  # v4
         with:
           node-version-file: '.nvmrc'
           cache: 'npm'
@@ -31,11 +31,11 @@ jobs:
           npm install
           npm run typedoc
       - name: Setup Pages
-        uses: actions/configure-pages@v5
+        uses: actions/configure-pages@983d7736d9b0ae728b81ab479565c72886d7745b  # v5
       - name: Upload artifact
-        uses: actions/upload-pages-artifact@v3
+        uses: actions/upload-pages-artifact@56afc609e74202658d3ffba0e8f6dda462b719fa  # v3
         with:
           path: 'docs'
       - name: Deploy to GitHub Pages
         id: deployment
-        uses: actions/deploy-pages@v4
+        uses: actions/deploy-pages@d6db90164ac5ed86f2b6aed7e0febac5b3c0c03e  # v4

.github/workflows/stale.yml

@@ -7,7 +7,7 @@ jobs:
   stale:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/stale@v8
+      - uses: actions/stale@1160a2240286f5da8ec72b1c0816ce2481aabf84  # v8
         with:
           stale-issue-message: 'This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.'
           stale-pr-message: 'This PR has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.'

JitsiConference.ts

@@ -620,6 +620,9 @@ export default class JitsiConference extends Listenable {
         this._onIceConnectionRestored = this._onIceConnectionRestored.bind(this);
         this.room.addListener(XMPPEvents.CONNECTION_RESTORED, this._onIceConnectionRestored);
 
+        this._onP2PTerminationRequired = this._onP2PTerminationRequired.bind(this);
+        this.room.addListener(XMPPEvents.P2P_TERMINATION_REQUIRED, this._onP2PTerminationRequired);
+
         this._updateProperties = this._updateProperties.bind(this);
         this.room.addListener(XMPPEvents.CONFERENCE_PROPERTIES_CHANGED, this._updateProperties);
 
@@ -828,7 +831,8 @@ export default class JitsiConference extends Listenable {
         Statistics.sendAnalytics(createConferenceEvent('joined', {
             ...connectionTimes,
             meetingId,
-            participantId: `${meetingId}.${this._statsCurrentId}`
+            participantId: `${meetingId}.${this._statsCurrentId}`,
+            supportsTurnInRoomMetadata: true
         }));
         this._conferenceJoinAnalyticsEventSent = Date.now();
     }
@@ -1810,6 +1814,26 @@ export default class JitsiConference extends Listenable {
         }
     }
 
+    /**
+     * Handles P2P_TERMINATION_REQUIRED event. Fired when a source-remove is detected on a P2P connection, which
+     * indicates that the browser has regenerated SSRCs for an existing source. The P2P session is stopped so the
+     * call falls back to JVB.
+     *
+     * @param {JingleSessionPC} session - The P2P Jingle session.
+     * @private
+     */
+    private _onP2PTerminationRequired(session: JingleSessionPC): void {
+        if (session !== this.p2pJingleSession) {
+            return;
+        }
+
+        logger.warn('Stopping P2P session due to SSRC regeneration on P2P connection');
+        this._stopP2PSession({
+            reason: 'connectivity-error',
+            reasonDescription: 'P2P SSRC regeneration'
+        });
+    }
+
     /**
      * Handles CONNECTION_RESTORED event.
      * @param {JingleSessionPC} session - The Jingle session.
@@ -2565,6 +2589,7 @@ export default class JitsiConference extends Listenable {
         );
 
         room.removeListener(XMPPEvents.MEETING_ID_SET, this._sendConferenceJoinAnalyticsEvent);
+        room.removeListener(XMPPEvents.P2P_TERMINATION_REQUIRED, this._onP2PTerminationRequired);
         room.removeListener(XMPPEvents.SESSION_ACCEPT, this._updateRoomPresence);
         room.removeListener(XMPPEvents.SOURCE_ADD, this._updateRoomPresence);
         room.removeListener(XMPPEvents.SOURCE_ADD_ERROR, this._removeLocalSourceOnReject);
@@ -4433,7 +4458,14 @@ export default class JitsiConference extends Listenable {
      */
     public joinLobby(displayName: string, email: string): Promise<void> {
         if (this.room) {
-            return this.room.getLobby().join(displayName, email);
+            if (!this.room.getLobby()?.lobbyRoom?.joined) {
+                return this.room.getLobby().join(displayName, email);
+            } else {
+                logger.warn('Already joined the lobby');
+
+                return Promise.resolve();
+            }
+
         }
 
         return Promise.reject(new Error('The conference not started'));

JitsiConferenceEventManager.ts

@@ -9,6 +9,7 @@ import JitsiRemoteTrack from './modules/RTC/JitsiRemoteTrack';
 import TraceablePeerConnection from './modules/RTC/TraceablePeerConnection';
 import RTCStats from './modules/RTCStats/RTCStats';
 import { RTCStatsEvents } from './modules/RTCStats/RTCStatsEvents';
+import { IInboundVideoStats } from './modules/qualitycontrol/QualityController';
 import JibriSession from './modules/recording/JibriSession';
 import { SPEAKERS_AUDIO_LEVELS } from './modules/statistics/constants';
 import Statistics from './modules/statistics/statistics';
@@ -476,6 +477,11 @@ export default class JitsiConferenceEventManager {
             if (typeof metadata.recording?.isTranscribingEnabled !== 'undefined') {
                 conference._setTranscribingEnabled(Boolean(metadata.recording.isTranscribingEnabled));
             }
+
+            if (metadata.services) {
+                chatRoom.xmpp.connection.jingle.onReceiveStunAndTurnCredentials(metadata);
+            }
+
             conference.eventEmitter.emit(JitsiConferenceEvents.METADATA_UPDATED, metadata);
         });
     }
@@ -621,6 +627,11 @@ export default class JitsiConferenceEventManager {
                 JitsiConferenceEvents.ENCODE_TIME_STATS_RECEIVED, tpc, stats);
         });
 
+        conference.statistics.addInboundVideoStatsListener((tpc: TraceablePeerConnection, stats: Map<number, IInboundVideoStats>) => {
+            conference.eventEmitter.emit(
+                JitsiConferenceEvents.INBOUND_VIDEO_STATS_RECEIVED, tpc, stats);
+        });
+
         // if we are in startSilent mode we will not be sending/receiving so nothing to detect
         if (!conference.options.config.startSilent) {
             conference.statistics.addByteSentStatsListener((tpc: TraceablePeerConnection, stats: RTCEncodedAudioFrameMetadata) => {

JitsiConferenceEvents.ts

@@ -227,6 +227,16 @@ export enum JitsiConferenceEvents {
      */
     FORWARDED_SOURCES_CHANGED = 'conference.forwardedSourcesChanged',
 
+    /**
+     * Indicates that inbound video stats have been received for remote video streams that are receiving
+     * media bytes but decoding no frames. Fired when at least one such stream exists, and once more with an
+     * empty map when all previously-failing streams have recovered (all-clear signal).
+     *
+     * @param {TraceablePeerConnection} tpc - The peer connection.
+     * @param {Map<number, { bitrateDownload: number, fps: number, participantId: string }>} stats - Stats per SSRC.
+     */
+    INBOUND_VIDEO_STATS_RECEIVED = 'conference.inbound_video_stats_received',
+
     /**
      * You are kicked from the conference.
      * @param {JitsiParticipant} the participant that initiated the kick.

JitsiConnection.ts

@@ -156,8 +156,10 @@ export default class JitsiConnection {
      * This method allows renewal of the tokens if they are expiring.
      * @param token - The new token.
      */
-    setToken(token: string): void {
+    refreshToken(token: string): Promise<void> {
         this.token = token;
+
+        return this._xmpp.refreshToken(this.token);
     }
 
     /**

JitsiConnectionEvents.spec.ts

@@ -8,6 +8,7 @@ describe( "/JitsiConnectionEvents members", () => {
         CONNECTION_ESTABLISHED,
         CONNECTION_FAILED,
         CONNECTION_REDIRECTED,
+        CONNECTION_TOKEN_EXPIRED,
         DISPLAY_NAME_REQUIRED,
         PROPERTIES_UPDATED,
         JitsiConnectionEvents,
@@ -19,6 +20,7 @@ describe( "/JitsiConnectionEvents members", () => {
         expect( CONNECTION_ESTABLISHED ).toBe( 'connection.connectionEstablished' );
         expect( CONNECTION_FAILED ).toBe( 'connection.connectionFailed' );
         expect( CONNECTION_REDIRECTED ).toBe( 'connection.redirected' );
+        expect( CONNECTION_TOKEN_EXPIRED ).toBe( 'connection.token_expired' );
         expect( DISPLAY_NAME_REQUIRED ).toBe( 'connection.display_name_required' );
         expect( PROPERTIES_UPDATED ).toBe( 'connection.propertiesUpdated' );
 
@@ -28,6 +30,7 @@ describe( "/JitsiConnectionEvents members", () => {
         expect( JitsiConnectionEvents.CONNECTION_ESTABLISHED ).toBe( 'connection.connectionEstablished' );
         expect( JitsiConnectionEvents.CONNECTION_FAILED ).toBe( 'connection.connectionFailed' );
         expect( JitsiConnectionEvents.CONNECTION_REDIRECTED ).toBe( 'connection.redirected' );
+        expect( JitsiConnectionEvents.CONNECTION_TOKEN_EXPIRED ).toBe( 'connection.token_expired' );
         expect( JitsiConnectionEvents.DISPLAY_NAME_REQUIRED ).toBe( 'connection.display_name_required' );
         expect( JitsiConnectionEvents.PROPERTIES_UPDATED ).toBe( 'connection.propertiesUpdated' );
     } );

JitsiConnectionEvents.ts

@@ -40,6 +40,11 @@ export enum JitsiConnectionEvents {
      */
     CONNECTION_REDIRECTED = 'connection.redirected',
 
+    /**
+     * The connection is trying to resume, but token is expired.
+     */
+    CONNECTION_TOKEN_EXPIRED = 'connection.token_expired',
+
     /**
      * Indicates that the display name is required over this connection and need to be supplied when
      * joining the room.
@@ -59,5 +64,6 @@ export const CONNECTION_DISCONNECTED = JitsiConnectionEvents.CONNECTION_DISCONNE
 export const CONNECTION_ESTABLISHED = JitsiConnectionEvents.CONNECTION_ESTABLISHED;
 export const CONNECTION_FAILED = JitsiConnectionEvents.CONNECTION_FAILED;
 export const CONNECTION_REDIRECTED = JitsiConnectionEvents.CONNECTION_REDIRECTED;
+export const CONNECTION_TOKEN_EXPIRED = JitsiConnectionEvents.CONNECTION_TOKEN_EXPIRED;
 export const DISPLAY_NAME_REQUIRED = JitsiConnectionEvents.DISPLAY_NAME_REQUIRED;
 export const PROPERTIES_UPDATED = JitsiConnectionEvents.PROPERTIES_UPDATED;

JitsiMeetJS.ts

@@ -117,7 +117,7 @@ export interface IJoinConferenceOptions {
     conferenceOptions?: IConferenceOptions;
     connectionOptions?: IConnectionOptions;
     jaas?: {
-        release?: boolean;
+        release?: string; // backend release "1234"
         useStaging?: boolean;
     };
     tracks?: JitsiLocalTrack[];
@@ -460,6 +460,12 @@ const JitsiMeetJS = {
 
             const useStage = options.jaas?.useStaging ?? false;
             const jaasDomain = useStage ? 'staging.8x8.vc' : '8x8.vc';
+            let serviceUrl = `wss://${jaasDomain}/${appId}/xmpp-websocket?room=${roomName}`;
+
+            if (options.jaas?.release) {
+                serviceUrl = `${serviceUrl}&release=release-${options.jaas.release}`;
+            }
+
             const opts = {
                 analytics: {
                     rtcstatsEnabled: true,
@@ -471,7 +477,7 @@ const JitsiMeetJS = {
                     domain: jaasDomain,
                     muc: `conference.${appId}.${jaasDomain}`
                 },
-                serviceUrl: `wss://${jaasDomain}/${appId}/xmpp-websocket?room=${roomName}`,
+                serviceUrl,
                 websocketKeepAliveUrl: `https://${jaasDomain}/${appId}/_unlock?room=${roomName}`
             };
 

modules/RTC/JitsiLocalTrack.ts

@@ -628,6 +628,7 @@ export default class JitsiLocalTrack extends JitsiTrack {
         this._originalStream = this.stream;
         this._setStream(this._streamEffect.startEffect(this._originalStream));
         this.track = this.stream.getTracks()[0];
+        this._effectEnabled = true;
     }
 
     /**
@@ -642,6 +643,7 @@ export default class JitsiLocalTrack extends JitsiTrack {
             this._setStream(this._originalStream);
             this._originalStream = null;
             this.track = this.stream ? this.stream.getTracks()[0] : null;
+            this._effectEnabled = false;
         }
     }
 
@@ -1210,20 +1212,22 @@ export default class JitsiLocalTrack extends JitsiTrack {
         this.stopStream();
 
         const initialSettings = this.track.getSettings();
-        const constraintsToApply = {
-            ...initialSettings,
-            ...constraints
-        };
 
+        const deviceId = initialSettings?.deviceId;
         const deviceIdKey = mediaType === MediaType.AUDIO ? 'micDeviceId' : 'cameraDeviceId';
         let mediaStreamData: IStreamInfo | undefined;
 
         try {
             logger.debug(`applyConstraints for track ${this} with constraints: ${JSON.stringify(constraints)}`);
 
+            const constraintsToApply = {
+                ...initialSettings,
+                ...constraints
+            };
+
             [ mediaStreamData ] = await RTCUtils.obtainAudioAndVideoPermissions({
                 constraints: { [mediaType]: constraintsToApply },
-                [deviceIdKey]: constraintsToApply.deviceId,
+                ...(deviceId && { [deviceIdKey]: deviceId }),
                 devices: [ mediaType ]
             });
 
@@ -1241,7 +1245,7 @@ export default class JitsiLocalTrack extends JitsiTrack {
 
             [ mediaStreamData ] = await RTCUtils.obtainAudioAndVideoPermissions({
                 constraints: { [mediaType]: initialSettings },
-                [deviceIdKey]: constraintsToApply.deviceId,
+                ...(deviceId && { [deviceIdKey]: deviceId }),
                 devices: [ mediaType ]
             });
         }

modules/RTC/RTCUtils.js

@@ -9,6 +9,8 @@ import { RTCEvents } from '../../service/RTC/RTCEvents';
 import Resolutions from '../../service/RTC/Resolutions';
 import { VideoType } from '../../service/RTC/VideoType';
 import { AnalyticsEvents } from '../../service/statistics/AnalyticsEvents';
+import RTCStats from '../RTCStats/RTCStats';
+import { RTCStatsEvents } from '../RTCStats/RTCStatsEvents';
 import browser from '../browser';
 import Statistics from '../statistics/statistics';
 import Listenable from '../util/Listenable';
@@ -399,7 +401,16 @@ class RTCUtils extends Listenable {
                 gumTimeout = setTimeout(() => {
                     timeoutExpired = true;
                     gumTimeout = undefined;
-                    reject(new JitsiTrackError(JitsiTrackErrors.TIMEOUT));
+
+                    const timeoutError = new JitsiTrackError(JitsiTrackErrors.TIMEOUT);
+
+                    RTCStats.sendStatsEntry(RTCStatsEvents.GET_USER_MEDIA_ERROR_EVENT, null, {
+                        devices: umDevices,
+                        message: timeoutError.message,
+                        name: timeoutError.name
+                    });
+
+                    reject(timeoutError);
                 }, timeout);
             }
 
@@ -419,6 +430,15 @@ class RTCUtils extends Listenable {
                     const jitsiError = new JitsiTrackError(error, constraints, umDevices);
 
                     if (!timeoutExpired) {
+                        // Skip emitting when the timeout already fired and reported the failure,
+                        // to avoid double-reporting a single gUM call.
+                        RTCStats.sendStatsEntry(RTCStatsEvents.GET_USER_MEDIA_ERROR_EVENT, null, {
+                            constraint: error.constraint,
+                            devices: umDevices,
+                            message: error.message,
+                            name: error.name
+                        });
+
                         if (typeof gumTimeout !== 'undefined') {
                             clearTimeout(gumTimeout);
                         }