feat(file-sharing): Adds file sharing options. (#2829)

* feat(file-sharing): Adds file sharing options.

* squash: Adds missing jsdocs.

* squash: Updates docs for a backend change.

* squash: exports type IFileMetadata.

JitsiConference.js

         return this.room?.getBreakoutRooms();
     }
 
+    /**
+     * Returns the file sharing manager object.
+     *
+     * @returns {Object} the file sharing manager.
+     */
+    getFileSharing() {
+        return this.room?.getFileSharing();
+    }
+
     /**
      * Returns the metadata handler object.
      *

JitsiConferenceEventManager.js

         this.chatRoomForwarder.forward(XMPPEvents.BREAKOUT_ROOMS_UPDATED,
             JitsiConferenceEvents.BREAKOUT_ROOMS_UPDATED);
 
+        // File sharing
+        this.chatRoomForwarder.forward(XMPPEvents.FILE_SHARING_FILES_RECEIVED,
+            JitsiConferenceEvents.FILE_SHARING_FILES_RECEIVED);
+        this.chatRoomForwarder.forward(XMPPEvents.FILE_SHARING_FILE_ADDED,
+            JitsiConferenceEvents.FILE_SHARING_FILE_ADDED);
+        this.chatRoomForwarder.forward(XMPPEvents.FILE_SHARING_FILE_REMOVED,
+            JitsiConferenceEvents.FILE_SHARING_FILE_REMOVED);
+
         // Room metadata.
         chatRoom.addListener(XMPPEvents.ROOM_METADATA_UPDATED, metadata => {
             if (metadata.startMuted) {

JitsiConferenceEvents.spec.ts

         ENCODE_TIME_STATS_RECEIVED,
         ENDPOINT_MESSAGE_RECEIVED,
         ENDPOINT_STATS_RECEIVED,
+        FILE_SHARING_FILES_RECEIVED,
+        FILE_SHARING_FILE_ADDED,
+        FILE_SHARING_FILE_REMOVED,
         JVB121_STATUS,
         KICKED,
         PARTICIPANT_KICKED,
         expect( DTMF_SUPPORT_CHANGED ).toBe( 'conference.dtmfSupportChanged' );
         expect( ENDPOINT_MESSAGE_RECEIVED ).toBe( 'conference.endpoint_message_received' );
         expect( ENDPOINT_STATS_RECEIVED ).toBe( 'conference.endpoint_stats_received' );
+        expect( FILE_SHARING_FILES_RECEIVED ).toBe( 'conference.file_sharing.files_received' );
+        expect( FILE_SHARING_FILE_ADDED ).toBe( 'conference.file_sharing.file_added' );
+        expect( FILE_SHARING_FILE_REMOVED ).toBe( 'conference.file_sharing.file_removed' );
         expect( JVB121_STATUS ).toBe( 'conference.jvb121Status' );
         expect( KICKED ).toBe( 'conference.kicked' );
         expect( PARTICIPANT_KICKED ).toBe( 'conference.participant_kicked' );
         expect( JitsiConferenceEvents.ENCODE_TIME_STATS_RECEIVED ).toBe( 'conference.encode_time_stats_received' );
         expect( JitsiConferenceEvents.ENDPOINT_MESSAGE_RECEIVED ).toBe( 'conference.endpoint_message_received' );
         expect( JitsiConferenceEvents.ENDPOINT_STATS_RECEIVED ).toBe( 'conference.endpoint_stats_received' );
+        expect( JitsiConferenceEvents.FILE_SHARING_FILES_RECEIVED ).toBe( 'conference.file_sharing.files_received' );
+        expect( JitsiConferenceEvents.FILE_SHARING_FILE_ADDED ).toBe( 'conference.file_sharing.file_added' );
+        expect( JitsiConferenceEvents.FILE_SHARING_FILE_REMOVED ).toBe( 'conference.file_sharing.file_removed' );
         expect( JitsiConferenceEvents.JVB121_STATUS ).toBe( 'conference.jvb121Status' );
         expect( JitsiConferenceEvents.KICKED ).toBe( 'conference.kicked' );
         expect( JitsiConferenceEvents.PARTICIPANT_KICKED ).toBe( 'conference.participant_kicked' );

JitsiConferenceEvents.ts

      */
     ENDPOINT_STATS_RECEIVED = 'conference.endpoint_stats_received',
 
+    /**
+     * Event emitted when a list file is received in the conference. This event is fired when a participant joins
+     * and the file list is sent to them.
+     * @param {Map<String, IFileMetadata>} files - The map of files received in the conference with key the file ID.
+     */
+    FILE_SHARING_FILES_RECEIVED = 'conference.file_sharing.files_received',
+
+    /**
+     * Event emitted when a file is added to the conference.
+     * @param {IFileMetadata} file - The file object containing metadata about the file.
+     */
+    FILE_SHARING_FILE_ADDED = 'conference.file_sharing.file_added',
+
+    /**
+     * Event emitted when a file is removed from the conference.
+     * @param {String} fileId - The ID of the file that was removed.
+     */
+    FILE_SHARING_FILE_REMOVED = 'conference.file_sharing.file_removed',
+
     /**
      * The forwarded sources set is changed.
      *
 export const ENCODE_TIME_STATS_RECEIVED = JitsiConferenceEvents.ENCODE_TIME_STATS_RECEIVED;
 export const ENDPOINT_MESSAGE_RECEIVED = JitsiConferenceEvents.ENDPOINT_MESSAGE_RECEIVED;
 export const ENDPOINT_STATS_RECEIVED = JitsiConferenceEvents.ENDPOINT_STATS_RECEIVED;
+export const FILE_SHARING_FILES_RECEIVED = JitsiConferenceEvents.FILE_SHARING_FILES_RECEIVED;
+export const FILE_SHARING_FILE_ADDED = JitsiConferenceEvents.FILE_SHARING_FILE_ADDED;
+export const FILE_SHARING_FILE_REMOVED = JitsiConferenceEvents.FILE_SHARING_FILE_REMOVED;
 export const FORWARDED_SOURCES_CHANGED = JitsiConferenceEvents.FORWARDED_SOURCES_CHANGED;
 export const JVB121_STATUS = JitsiConferenceEvents.JVB121_STATUS;
 export const KICKED = JitsiConferenceEvents.KICKED;

modules/xmpp/AVModeration.ts

  * The AVModeration logic.
  */
 export default class AVModeration {
-
-    /**
-     * Constructs AV moderation room.
-     *
-     * @param {ChatRoom} room the main room.
-     */
     private _xmpp: XMPP;
     private _mainRoom: ChatRoom;
     private _moderationEnabledByType: IModerationEnabledByType;
     private _whitelistAudio: string[];
     private _whitelistVideo: string[];
 
+    /**
+     * Constructs AV moderation room.
+     *
+     * @param {ChatRoom} room the main room.
+     */
     constructor(room: ChatRoom) {
         this._xmpp = room.xmpp;
 

modules/xmpp/ChatRoom.js

 
 import AVModeration from './AVModeration';
 import BreakoutRooms from './BreakoutRooms';
+import FileSharing from './FileSharing';
 import Lobby from './Lobby';
 import RoomMetadata from './RoomMetadata';
 import XmppConnection from './XmppConnection';
         }
         this.avModeration = new AVModeration(this);
         this.breakoutRooms = new BreakoutRooms(this);
+        this.fileSharing = new FileSharing(this);
         this.roomMetadata = new RoomMetadata(this);
         this.initPresenceMap(options);
         this.lastPresences = {};
         return this.breakoutRooms;
     }
 
+    /**
+     * @returns {FileSharing}
+     */
+    getFileSharing() {
+        return this.fileSharing;
+    }
+
     /**
      * @returns {RoomMetadata}
      */
     leave(reason) {
         this.avModeration.dispose();
         this.breakoutRooms.dispose();
+        this.fileSharing.dispose();
         this.roomMetadata.dispose();
 
         const promises = [];

modules/xmpp/FileSharing.ts

+import { XMPPEvents } from '../../service/xmpp/XMPPEvents';
+
+import ChatRoom from './ChatRoom';
+import XMPP from './xmpp';
+
+export const IDENTITY_TYPE = 'file-sharing';
+
+/**
+ * The file metadata used in file sharing.
+ * Fields like `authorParticipantId`, `authorParticipantJid`, and `authorParticipantName` and `conferenceFullName` will
+ * be set by the backend, so passing them is optional.
+ */
+export type IFileMetadata = {
+    /**
+     * The ID of the participant who uploaded the file.
+     */
+    authorParticipantId?: string;
+
+    /**
+     * The connection JID of the participant who uploaded the file.
+     */
+    authorParticipantJid?: string;
+
+    /**
+     * The name of the participant who uploaded the file.
+     */
+    authorParticipantName?: string;
+
+    /**
+     * The jid of the conference where the file was uploaded.
+     */
+    conferenceFullName?: string;
+
+    /**
+     * The unique ID of the file.
+     */
+    fileId: string;
+
+    /**
+     * The name of the file.
+     */
+    fileName: string;
+
+    /**
+     * The size of the file in bytes.
+     */
+    fileSize: number;
+
+    /**
+     * The file type (file extension).
+     */
+    fileType: string;
+
+    /**
+     * The time when it was uploaded.
+     */
+    timestamp: number;
+};
+
+/**
+ * The FileSharing logic.
+ */
+export default class FileSharing {
+    private _mainRoom: ChatRoom;
+    private _xmpp: XMPP;
+
+    /**
+     * Constructs File sharing manager for a room.
+     *
+     * @param {ChatRoom} room the main room.
+     */
+    constructor(room: ChatRoom) {
+        this._mainRoom = room;
+        this._xmpp = room.xmpp;
+
+        this._handleMessages = this._handleMessages.bind(this);
+        this._mainRoom.xmpp.addListener(XMPPEvents.FILE_SHARING_EVENT, this._handleMessages);
+    }
+
+    /**
+     * Stops listening for events.
+     */
+    dispose() {
+        this._mainRoom.xmpp.removeListener(XMPPEvents.FILE_SHARING_EVENT, this._handleMessages);
+    }
+
+    /**
+     * Whether AV moderation is supported on backend.
+     *
+     * @returns {boolean} whether AV moderation is supported on backend.
+     */
+    isSupported() {
+        return Boolean(this._xmpp.fileSharingComponentAddress);
+    }
+
+    /**
+     * Returns the file sharing identity type (service name).
+     *
+     * @returns {string} the file sharing service name.
+     */
+    getIdentityType() {
+        return IDENTITY_TYPE;
+    }
+
+    /**
+     * Adds a file to the file sharing component after the file has been uploaded.
+     * @param metadata - The metadata of the file to be added.
+     */
+    addFile(metadata: IFileMetadata) {
+        const message = {
+            type: 'add',
+            xmlns: 'http://jitsi.org/jitmeet'
+        };
+
+        this._sendMessage(message, metadata);
+    }
+
+    /**
+     * Removes a file from the file sharing component after the file was deleted.
+     * @param fileId - The file ID of the file to be removed.
+     */
+    removeFile(fileId: string) {
+        const message = {
+            type: 'remove',
+            fileId,
+            xmlns: 'http://jitsi.org/jitmeet'
+        };
+
+        this._sendMessage(message);
+    }
+
+    /**
+     * Helper to send a file sharing message to the component.
+     *
+     * @param {Object} message - Command that needs to be sent.
+     * @param {Object} content - The content to add to the element created if any.
+     */
+    _sendMessage(message: object, content?: object) {
+        const msg = $msg({ to: this._xmpp.fileSharingComponentAddress });
+
+        msg.c(IDENTITY_TYPE, message, content ? JSON.stringify(content) : undefined).up();
+
+        this._xmpp.connection.send(msg);
+    }
+
+    /**
+     * Handles a message for file sharing.
+     *
+     * @param {object} payload - Arbitrary data.
+     */
+    _handleMessages(payload) {
+        switch (payload.event) {
+        case 'add':
+
+            this._mainRoom.eventEmitter.emit(XMPPEvents.FILE_SHARING_FILE_ADDED, payload.file);
+
+            break;
+        case 'remove': {
+            this._mainRoom.eventEmitter.emit(XMPPEvents.FILE_SHARING_FILE_REMOVED, payload.fileId);
+            break;
+        }
+        case 'list': {
+            this._mainRoom.eventEmitter.emit(XMPPEvents.FILE_SHARING_FILES_RECEIVED, payload.files);
+            break;
+        }
+        }
+    }
+}

modules/xmpp/xmpp.js

 import RandomUtil from '../util/RandomUtil';
 
 import Caps, { parseDiscoInfo } from './Caps';
+import { IDENTITY_TYPE as FILE_SHARING_IDENTITY_TYPE } from './FileSharing';
 import XmppConnection from './XmppConnection';
 import Moderator from './moderator';
 import './strophe.disco';
                 }
             }
 
+            if (identity.type === FILE_SHARING_IDENTITY_TYPE) {
+                this.fileSharingComponentAddress = identity.name;
+                this._components.push(this.fileSharingComponentAddress);
+            }
+
             if (identity.type === 'room_metadata') {
                 this.roomMetadataComponentAddress = identity.name;
                 this._components.push(this.roomMetadataComponentAddress);
             this.eventEmitter.emit(XMPPEvents.AV_MODERATION_RECEIVED, parsedJson);
         } else if (parsedJson[JITSI_MEET_MUC_TYPE] === 'breakout_rooms') {
             this.eventEmitter.emit(XMPPEvents.BREAKOUT_ROOMS_EVENT, parsedJson);
+        } else if (parsedJson[JITSI_MEET_MUC_TYPE] === FILE_SHARING_IDENTITY_TYPE) {
+            this.eventEmitter.emit(XMPPEvents.FILE_SHARING_EVENT, parsedJson);
         } else if (parsedJson[JITSI_MEET_MUC_TYPE] === 'room_metadata') {
             this.eventEmitter.emit(XMPPEvents.ROOM_METADATA_EVENT, parsedJson);
         } else if (parsedJson[JITSI_MEET_MUC_TYPE] === 'visitors') {

service/xmpp/XMPPEvents.spec.ts

         expect( XMPPEvents.EMUC_ROOM_ADDED ).toBe( 'xmpp.emuc_room_added' );
         expect( XMPPEvents.EMUC_ROOM_REMOVED ).toBe( 'xmpp.emuc_room_removed' );
         expect( XMPPEvents.ETHERPAD ).toBe( 'xmpp.etherpad' );
+        expect( XMPPEvents.FILE_SHARING_EVENT ).toBe( 'xmpp.files-sharing.event' );
+        expect( XMPPEvents.FILE_SHARING_FILES_RECEIVED ).toBe( 'xmpp.files-sharing.list' );
+        expect( XMPPEvents.FILE_SHARING_FILE_ADDED ).toBe( 'xmpp.files-sharing.add' );
+        expect( XMPPEvents.FILE_SHARING_FILE_REMOVED ).toBe( 'xmpp.files-sharing.remove' );
         expect( XMPPEvents.FOCUS_DISCONNECTED ).toBe( 'xmpp.focus_disconnected' );
         expect( XMPPEvents.FOCUS_LEFT ).toBe( 'xmpp.focus_left' );
         expect( XMPPEvents.GRACEFUL_SHUTDOWN ).toBe( 'xmpp.graceful_shutdown' );

service/xmpp/XMPPEvents.ts

 
     ETHERPAD = 'xmpp.etherpad',
 
+    /**
+     * Event fired when we receive a message for files sharing.
+     */
+    FILE_SHARING_EVENT = 'xmpp.files-sharing.event',
+
+    /**
+     * Event emitted when a list file is received in the conference.
+     */
+    FILE_SHARING_FILES_RECEIVED = 'xmpp.files-sharing.list',
+
+    /**
+     * Event emitted when a file is added to the conference.
+     */
+    FILE_SHARING_FILE_ADDED = 'xmpp.files-sharing.add',
+
+    /**
+     * Event emitted when a file is removed from the conference.
+     */
+    FILE_SHARING_FILE_REMOVED = 'xmpp.files-sharing.remove',
+
     FOCUS_DISCONNECTED = 'xmpp.focus_disconnected',
 
     FOCUS_LEFT = 'xmpp.focus_left',