ref(JitsiConference) Make methods getMediaSessions and getActiveMediaSession public.

JitsiConference.js

  * Returns the currently active media session if any.
  *
  * @returns {JingleSessionPC|undefined}
- * @private
  */
-JitsiConference.prototype._getActiveMediaSession = function() {
+JitsiConference.prototype.getActiveMediaSession = function() {
     return this.isP2PActive() ? this.p2pJingleSession : this.jvbJingleSession;
 };
 
  * Returns an array containing all media sessions existing in this conference.
  *
  * @returns {Array<JingleSessionPC>}
- * @private
  */
-JitsiConference.prototype._getMediaSessions = function() {
+JitsiConference.prototype.getMediaSessions = function() {
     const sessions = [];
 
     this.jvbJingleSession && sessions.push(this.jvbJingleSession);
 
                 // we do not want to send presence update during setEffect switching, which does remove and then add
                 && !(oldTrack?._setEffectInProgress || newTrack?._setEffectInProgress)) {
-                this._updateRoomPresence(this._getActiveMediaSession());
+                this._updateRoomPresence(this.getActiveMediaSession());
             }
 
             if (newTrack !== null && (this.isMutedByFocus || this.isVideoMutedByFocus)) {
     }
 
     const participant = this.participants[id];
-    const mediaSessions = this._getMediaSessions();
+    const mediaSessions = this.getMediaSessions();
     let tracksToBeRemoved = [];
 
     for (const session of mediaSessions) {
         JitsiConferenceEvents.P2P_STATUS,
         this,
         this.p2p);
-    this.eventEmitter.emit(
-        JitsiConferenceEvents._MEDIA_SESSION_ACTIVE_CHANGED,
-        this._getActiveMediaSession());
+    this.eventEmitter.emit(JitsiConferenceEvents._MEDIA_SESSION_ACTIVE_CHANGED, this.getActiveMediaSession());
 
     // Refresh connection interrupted/restored
     this.eventEmitter.emit(

modules/e2ee/KeyHandler.js

      * @private
      */
     _onLocalTrackAdded(track) {
-        for (const session of this.conference._getMediaSessions()) {
+        for (const session of this.conference.getMediaSessions()) {
             this._setupSenderE2EEForTrack(session, track);
         }
     }
      */
     _trackMuteChanged(track) {
         if (browser.doesVideoMuteByStreamRemove() && track.isLocal() && track.isVideoTrack() && !track.isMuted()) {
-            for (const session of this.conference._getMediaSessions()) {
+            for (const session of this.conference.getMediaSessions()) {
                 this._setupSenderE2EEForTrack(session, track);
             }
         }

modules/qualitycontrol/ReceiveVideoController.js

     setPreferredReceiveMaxFrameHeight(maxFrameHeight) {
         this._maxFrameHeight = maxFrameHeight;
 
-        for (const session of this._conference._getMediaSessions()) {
+        for (const session of this._conference.getMediaSessions()) {
             if (session.isP2P || !this._receiverVideoConstraints) {
                 maxFrameHeight && session.setReceiverVideoConstraint(maxFrameHeight);
             } else {
             this._selectedEndpoints = constraints.selectedEndpoints ?? this._selectedEndpoints;
             this._rtc.setNewReceiverVideoConstraints(constraints);
 
-            const p2pSession = this._conference._getMediaSessions().find(session => session.isP2P);
+            const p2pSession = this._conference.getMediaSessions().find(session => session.isP2P);
 
             if (p2pSession) {
                 let maxFrameHeight = Object.values(constraints.constraints)[0]?.maxHeight;

modules/qualitycontrol/ReceiveVideoController.spec.js

         this.mediaSessions = [];
     }
 
-    _getMediaSessions() {
+    getMediaSessions() {
         return this.mediaSessions;
     }
 }

modules/qualitycontrol/SendVideoController.js

         mediaSession.addListener(
             MediaSessionEvents.REMOTE_VIDEO_CONSTRAINTS_CHANGED,
             session => {
-                if (session === this.conference._getActiveMediaSession()) {
+                if (session === this.conference.getActiveMediaSession()) {
                     this._propagateSendMaxFrameHeight();
                 }
             });
         const promises = [];
 
         if (sendMaxFrameHeight >= 0) {
-            for (const session of this.conference._getMediaSessions()) {
+            for (const session of this.conference.getMediaSessions()) {
                 promises.push(session.setSenderVideoConstraint(sendMaxFrameHeight));
             }
         }
      * @returns {number|undefined}
      */
     selectSendMaxFrameHeight() {
-        const activeMediaSession = this.conference._getActiveMediaSession();
+        const activeMediaSession = this.conference.getActiveMediaSession();
         const remoteRecvMaxFrameHeight = activeMediaSession
             ? activeMediaSession.isP2P
                 ? activeMediaSession.getRemoteRecvMaxFrameHeight()

modules/qualitycontrol/SendVideoController.spec.js

         this.eventEmitter.emit(JitsiConferenceEvents._MEDIA_SESSION_ACTIVE_CHANGED, this.activeMediaSession);
     }
 
-    _getActiveMediaSession() {
+    getActiveMediaSession() {
         return this.activeMediaSession;
     }
 
-    _getMediaSessions() {
+    getMediaSessions() {
         return this.mediaSessions;
     }
 }

types/auto/JitsiConference.d.ts

      * @returns {Promise}
      */
     leave(): Promise<any>;
-    private _getActiveMediaSession;
-    private _getMediaSessions;
+    /**
+     * Returns the currently active media session if any.
+     *
+     * @returns {JingleSessionPC|undefined}
+     */
+    getActiveMediaSession(): any | undefined;
+    /**
+     * Returns an array containing all media sessions existing in this conference.
+     *
+     * @returns {Array<JingleSessionPC>}
+     */
+    getMediaSessions(): Array<any>;
     private _registerRtcListeners;
     private _sendBridgeVideoTypeMessage;
     /**