feat: Moves redirected event to connection events.

JitsiConferenceErrors.spec.ts

         OFFER_ANSWER_FAILED,
         PASSWORD_NOT_SUPPORTED,
         PASSWORD_REQUIRED,
-        REDIRECTED,
         RESERVATION_ERROR,
         VIDEOBRIDGE_NOT_AVAILABLE,
         JitsiConferenceErrors,
         expect( PASSWORD_NOT_SUPPORTED ).toBe( 'conference.passwordNotSupported' );
         expect( PASSWORD_REQUIRED ).toBe( 'conference.passwordRequired' );
         expect( RESERVATION_ERROR ).toBe( 'conference.reservationError' );
-        expect( REDIRECTED ).toBe( 'conference.redirected' );
         expect( VIDEOBRIDGE_NOT_AVAILABLE ).toBe( 'conference.videobridgeNotAvailable' );
 
         expect( JitsiConferenceErrors ).toBeDefined();
         expect( JitsiConferenceErrors.PASSWORD_NOT_SUPPORTED ).toBe( 'conference.passwordNotSupported' );
         expect( JitsiConferenceErrors.PASSWORD_REQUIRED ).toBe( 'conference.passwordRequired' );
         expect( JitsiConferenceErrors.RESERVATION_ERROR ).toBe( 'conference.reservationError' );
-        expect( JitsiConferenceErrors.REDIRECTED ).toBe( 'conference.redirected' );
         expect( JitsiConferenceErrors.VIDEOBRIDGE_NOT_AVAILABLE ).toBe( 'conference.videobridgeNotAvailable' );
     } );
 

JitsiConferenceErrors.ts

      */
     PASSWORD_REQUIRED = 'conference.passwordRequired',
 
-    /**
-     * The conference is redirected to a visitor node.
-     */
-    REDIRECTED = 'conference.redirected',
-
     /**
      * Indicates that reservation system returned error.
      */
      * Indicates that there is no available videobridge.
      */
     VIDEOBRIDGE_NOT_AVAILABLE = 'conference.videobridgeNotAvailable'
-};
+}
 
 // exported for backward compatibility
 export const AUTHENTICATION_REQUIRED = JitsiConferenceErrors.AUTHENTICATION_REQUIRED;
 export const OFFER_ANSWER_FAILED = JitsiConferenceErrors.OFFER_ANSWER_FAILED;
 export const PASSWORD_NOT_SUPPORTED = JitsiConferenceErrors.PASSWORD_NOT_SUPPORTED;
 export const PASSWORD_REQUIRED = JitsiConferenceErrors.PASSWORD_REQUIRED;
-export const REDIRECTED = JitsiConferenceErrors.REDIRECTED;
 export const RESERVATION_ERROR = JitsiConferenceErrors.RESERVATION_ERROR;
 export const VIDEOBRIDGE_NOT_AVAILABLE = JitsiConferenceErrors.VIDEOBRIDGE_NOT_AVAILABLE;

JitsiConferenceEventManager.js

         JitsiConferenceEvents.CONFERENCE_FAILED,
         JitsiConferenceErrors.AUTHENTICATION_REQUIRED);
 
-    this.chatRoomForwarder.forward(XMPPEvents.REDIRECTED,
-        JitsiConferenceEvents.CONFERENCE_FAILED,
-        JitsiConferenceErrors.REDIRECTED);
-
     this.chatRoomForwarder.forward(XMPPEvents.BRIDGE_DOWN,
         JitsiConferenceEvents.CONFERENCE_FAILED,
         JitsiConferenceErrors.VIDEOBRIDGE_NOT_AVAILABLE);

JitsiConnectionEvents.spec.ts

         CONNECTION_DISCONNECTED,
         CONNECTION_ESTABLISHED,
         CONNECTION_FAILED,
+        CONNECTION_REDIRECTED,
         WRONG_STATE,
         DISPLAY_NAME_REQUIRED,
         JitsiConnectionEvents,
         expect( CONNECTION_DISCONNECTED ).toBe( 'connection.connectionDisconnected' );
         expect( CONNECTION_ESTABLISHED ).toBe( 'connection.connectionEstablished' );
         expect( CONNECTION_FAILED ).toBe( 'connection.connectionFailed' );
+        expect( CONNECTION_REDIRECTED ).toBe( 'connection.redirected' );
         expect( WRONG_STATE ).toBe( 'connection.wrongState' );
         expect( DISPLAY_NAME_REQUIRED ).toBe( 'connection.display_name_required' );
 
         expect( JitsiConnectionEvents.CONNECTION_DISCONNECTED ).toBe( 'connection.connectionDisconnected' );
         expect( JitsiConnectionEvents.CONNECTION_ESTABLISHED ).toBe( 'connection.connectionEstablished' );
         expect( JitsiConnectionEvents.CONNECTION_FAILED ).toBe( 'connection.connectionFailed' );
+        expect( JitsiConnectionEvents.CONNECTION_REDIRECTED ).toBe( 'connection.redirected' );
         expect( JitsiConnectionEvents.WRONG_STATE ).toBe( 'connection.wrongState' );
         expect( JitsiConnectionEvents.DISPLAY_NAME_REQUIRED ).toBe( 'connection.display_name_required' );
     } );
         const keys = Object.keys( others );
         expect( keys ).withContext( `Extra members: ${ keys.join( ", " ) }` ).toEqual( [] );
     } );
-} );
+} );

JitsiConnectionEvents.ts

      */
     CONNECTION_FAILED = 'connection.connectionFailed',
 
+    /**
+     * The connection is redirected to a visitor node.
+     */
+    CONNECTION_REDIRECTED = 'connection.redirected',
+
     /**
      * Indicates that the performed action cannot be executed because the
      * connection is not in the correct state(connected, disconnected, etc.)
      * There are cases like lobby room where display name is required.
      */
     DISPLAY_NAME_REQUIRED = 'connection.display_name_required'
-};
+}
 
 // exported for backward compatibility
 export const CONNECTION_DISCONNECTED = JitsiConnectionEvents.CONNECTION_DISCONNECTED;
 export const CONNECTION_ESTABLISHED = JitsiConnectionEvents.CONNECTION_ESTABLISHED;
 export const CONNECTION_FAILED = JitsiConnectionEvents.CONNECTION_FAILED;
+export const CONNECTION_REDIRECTED = JitsiConnectionEvents.CONNECTION_REDIRECTED;
 export const WRONG_STATE = JitsiConnectionEvents.WRONG_STATE;
 export const DISPLAY_NAME_REQUIRED = JitsiConnectionEvents.DISPLAY_NAME_REQUIRED;

modules/xmpp/ChatRoom.js

 
         this.eventsForwarder = new EventEmitterForwarder(this.xmpp.moderator, this.eventEmitter);
         this.eventsForwarder.forward(AuthenticationEvents.IDENTITY_UPDATED, AuthenticationEvents.IDENTITY_UPDATED);
-        this.eventsForwarder.forward(XMPPEvents.REDIRECTED, XMPPEvents.REDIRECTED);
         this.eventsForwarder.forward(XMPPEvents.AUTHENTICATION_REQUIRED, XMPPEvents.AUTHENTICATION_REQUIRED);
         this.eventsForwarder.forward(XMPPEvents.FOCUS_DISCONNECTED, XMPPEvents.FOCUS_DISCONNECTED);
         this.eventsForwarder.forward(XMPPEvents.RESERVATION_ERROR, XMPPEvents.RESERVATION_ERROR);
         return this.role === 'moderator';
     }
 
-    /**
-     * Redirected back.
-     * @param iq The received iq.
-     */
-    onVisitorIQ(iq) {
-        const visitors = $(iq).find('>visitors[xmlns="jitsi:visitors"]');
-        const response = $(iq).find('promotion-response');
-
-        if (visitors.length && response.length
-            && String(response.attr('allow')).toLowerCase() === 'true') {
-            logger.warn('Redirected back to main room.');
-
-            this.eventEmitter.emit(
-                XMPPEvents.REDIRECTED, undefined, visitors.attr('focusjid'), response.attr('username'));
-        }
-    }
-
     /**
      * Obtains the info about given media advertised (in legacy format) in the MUC presence of the participant
      * identified by the given endpoint JID. This is for mantining interop with endpoints that do not support
 
         this.eventsForwarder.removeListeners(
             AuthenticationEvents.IDENTITY_UPDATED,
-            XMPPEvents.REDIRECTED,
             XMPPEvents.AUTHENTICATION_REQUIRED,
             XMPPEvents.FOCUS_DISCONNECTED,
             XMPPEvents.RESERVATION_ERROR);

modules/xmpp/moderator.js

 import $ from 'jquery';
 import { $iq, Strophe } from 'strophe.js';
 
+import { CONNECTION_REDIRECTED } from '../../JitsiConnectionEvents';
 import FeatureFlags from '../flags/FeatureFlags';
 import Settings from '../settings/Settings';
 import Listenable from '../util/Listenable';
         // availability.
         this.sipGatewayEnabled = false;
 
+        this.xmpp = xmpp;
         this.connection = xmpp.connection;
 
         // The JID to which conference-iq requests are sent over XMPP.
             if (conferenceRequest.vnode && !this.options.iAmRecorder && !this.options.iAmSipGateway) {
                 logger.warn(`Redirected to: ${conferenceRequest.vnode} with focusJid ${conferenceRequest.focusJid} }`);
 
-                this.eventEmitter.emit(XMPPEvents.REDIRECTED, conferenceRequest.vnode, conferenceRequest.focusJid);
+                this.xmpp.eventEmitter.emit(CONNECTION_REDIRECTED, conferenceRequest.vnode, conferenceRequest.focusJid);
 
                 return;
             }

modules/xmpp/strophe.emuc.js

 import $ from 'jquery';
 import { Strophe } from 'strophe.js';
 
+import { CONNECTION_REDIRECTED } from '../../JitsiConnectionEvents';
 import { XMPPEvents } from '../../service/xmpp/XMPPEvents';
 
 import ChatRoom from './ChatRoom';
         const from = iq.getAttribute('from');
         const room = this.rooms[Strophe.getBareJidFromJid(from)];
 
-        room?.onVisitorIQ(iq);
+        if (!room) {
+            return true;
+        }
+
+        const visitors = $(iq).find('>visitors[xmlns="jitsi:visitors"]');
+        const response = $(iq).find('promotion-response');
+
+        if (visitors.length && response.length
+            && String(response.attr('allow')).toLowerCase() === 'true') {
+            logger.warn('Redirected back to main room.');
+
+            this.xmpp.eventEmitter.emit(
+                CONNECTION_REDIRECTED, undefined, visitors.attr('focusjid'), response.attr('username'));
+        }
 
         return true;
     }

service/xmpp/XMPPEvents.ts

      */
     RECORDER_STATE_CHANGED = 'xmpp.recorderStateChanged',
 
-    /**
-     * The conference was redirected to a visitor node.
-     */
-    REDIRECTED = 'xmpp.redirected',
-
     // Designates an event indicating that we received statistics from a
     // participant in the MUC.
     REMOTE_STATS = 'xmpp.remote_stats',