@wazo/sdk 0.38.22 → 0.39.0-beta.2

package/src/simple/room/{Room.js → Room.ts}

@@ -1,59 +1,91 @@
-// @flow
 import type { Message } from 'sip.js/lib/api/message';
 import sdpParser from 'sdp-transform';
-
+import { Invitation, Inviter } from 'sip.js';
 import type CallSession from '../../domain/CallSession';
 import getApiClient from '../../service/getApiClient';
 import Emitter from '../../utils/Emitter';
 import Wazo from '../index';
-import Participant from './Participant';
+import Participant, { RawParticipant } from './Participant';
 import RemoteParticipant from './RemoteParticipant';
 import IssueReporter from '../../service/IssueReporter';
 import LocalParticipant from './LocalParticipant';
 
 export const SIGNAL_TYPE_PARTICIPANT_UPDATE = 'signal/PARTICIPANT_UPDATE';
 export const SIGNAL_TYPE_PARTICIPANT_REQUEST = 'signal/PARTICIPANT_REQUEST';
-
 const logger = IssueReporter.loggerFor('sdk-room');
 
 class Room extends Emitter {
-  callSession: ?CallSession;
+  callSession: CallSession | null | undefined;
+
   name: string;
+
   extension: string;
-  sourceId: ?number;
-  meetingUuid: ?string;
+
+  sourceId: number | null | undefined;
+
+  meetingUuid: string | null | undefined;
+
   participants: Participant[];
-  callId: ?string;
+
+  callId: string | null | undefined;
+
   connected: boolean;
-  localParticipant: ?Participant;
-  _callIdStreamIdMap: Object;
-  _unassociatedVideoStreams: Object;
-  _unassociatedParticipants: Object;
-  _boundOnParticipantJoined: Function;
-  _boundOnParticipantLeft: Function;
-  _boundOnMessage: Function;
-  _boundOnChat: Function;
-  _boundOnSignal: Function;
-  _boundSaveLocalVideoStream: Function;
-  _boundOnReinvite: Function;
-  audioStream: ?any;
-  extra: Object;
+
+  localParticipant: Participant | null | undefined;
+
+  _callIdStreamIdMap: Record<string, any>;
+
+  _unassociatedVideoStreams: Record<string, any>;
+
+  _unassociatedParticipants: Record<string, any>;
+
+  _boundOnParticipantJoined: (...args: Array<any>) => any;
+
+  _boundOnParticipantLeft: (...args: Array<any>) => any;
+
+  _boundOnMessage: (...args: Array<any>) => any;
+
+  _boundOnChat: (...args: Array<any>) => any;
+
+  _boundOnSignal: (...args: Array<any>) => any;
+
+  _boundSaveLocalVideoStream: (...args: Array<any>) => any;
+
+  _boundOnReinvite: (...args: Array<any>) => any;
+
+  audioStream: any | null | undefined;
+
+  extra: Record<string, any>;
+
   // video tag representing the room audio stream
   roomAudioElement: any;
 
   CONFERENCE_USER_PARTICIPANT_JOINED: string;
+
   CONFERENCE_USER_PARTICIPANT_LEFT: string;
+
   MEETING_USER_PARTICIPANT_JOINED: string;
+
   MEETING_USER_PARTICIPANT_LEFT: string;
+
   ON_SHARE_SCREEN_ENDED: string;
+
   ON_MESSAGE: string;
+
   ON_CHAT: string;
+
   ON_SIGNAL: string;
+
   ON_AUDIO_STREAM: string;
+
   ON_VIDEO_STREAM: string;
+
   ON_REMOVE_STREAM: string;
+
   ON_DISCONNECTED: string;
+
   ON_JOINED: string;
+
   ON_VIDEO_INPUT_CHANGE: string;
 
   /**
@@ -65,17 +97,14 @@ class Room extends Emitter {
    * @param meetingUuid string
    * @param extra Object
    */
-  constructor(
-    callSession: CallSession,
-    extension: string,
-    sourceId: ?number,
-    callId: ?string,
-    meetingUuid: ?string,
-    extra: Object = {},
-  ) {
+  constructor(callSession: CallSession, extension: string, sourceId: number | null | undefined, callId: string | null | undefined, meetingUuid: string | null | undefined, extra: Record<string, any> = {}) {
     super();
-    logger.info('room initialized', { callId, extension, sourceId, meetingUuid });
-
+    logger.info('room initialized', {
+      callId,
+      extension,
+      sourceId,
+      meetingUuid,
+    });
     // Represents the room callSession
     this.callSession = callSession;
     this.extension = extension;
@@ -91,12 +120,10 @@ class Room extends Emitter {
     this._unassociatedVideoStreams = {};
     // Participant not yet associated to a stream, [participant.callId = label in setDescription]: Participant
     this._unassociatedParticipants = {};
-
     // The shared audio stream of the room
     this.audioStream = null;
     // Extra values passed to local participant
     this.extra = extra;
-
     // Sugar syntax for `room.EVENT_NAME`
     this.CONFERENCE_USER_PARTICIPANT_JOINED = Wazo.Websocket.CONFERENCE_USER_PARTICIPANT_JOINED;
     this.CONFERENCE_USER_PARTICIPANT_LEFT = Wazo.Websocket.CONFERENCE_USER_PARTICIPANT_LEFT;
@@ -106,14 +133,12 @@ class Room extends Emitter {
     this.ON_MESSAGE = Wazo.Phone.ON_MESSAGE;
     this.ON_CHAT = Wazo.Phone.ON_CHAT;
     this.ON_SIGNAL = Wazo.Phone.ON_SIGNAL;
-
     this.ON_AUDIO_STREAM = Wazo.Phone.ON_AUDIO_STREAM;
     this.ON_VIDEO_STREAM = Wazo.Phone.ON_VIDEO_STREAM;
     this.ON_REMOVE_STREAM = Wazo.Phone.ON_REMOVE_STREAM;
     this.ON_VIDEO_INPUT_CHANGE = Wazo.Phone.ON_VIDEO_INPUT_CHANGE;
     this.ON_DISCONNECTED = 'room/ON_DISCONNECTED';
     this.ON_JOINED = 'room/ON_JOINED';
-
     this._boundOnParticipantJoined = this._onParticipantJoined.bind(this);
     this._boundOnParticipantLeft = this._onParticipantLeft.bind(this);
     this._boundOnMessage = this._onMessage.bind(this);
@@ -121,7 +146,6 @@ class Room extends Emitter {
     this._boundOnSignal = this._onSignal.bind(this);
     this._boundSaveLocalVideoStream = this._saveLocalVideoStream.bind(this);
     this._boundOnReinvite = this._onReinvite.bind(this);
-
     this.unbind();
 
     this._bindEvents();
@@ -139,12 +163,24 @@ class Room extends Emitter {
    * @param meeting ?Meeting
    * @returns {Promise<Room>}
    */
-  static async connect({ extension, constraints, audioOnly = false, extra, room, meeting }: Object) {
-    logger.info('connecting to room', { extension, audioOnly, room: !!room });
+  static async connect({
+    extension,
+    constraints,
+    audioOnly = false,
+    extra,
+    room,
+    meeting,
+  }: Record<string, any>) {
+    logger.info('connecting to room', {
+      extension,
+      audioOnly,
+      room: !!room,
+    });
 
     if (!room) {
-      await Wazo.Phone.connect({ media: constraints });
-
+      await Wazo.Phone.connect({
+        media: constraints,
+      });
       const withCamera = constraints && !!constraints.video;
 
       if (withCamera) {
@@ -152,17 +188,20 @@ class Room extends Emitter {
       }
 
       // Call_created is triggered before call_accepted, so we have to listen for it here.
-      Wazo.Websocket.once(Wazo.Websocket.CALL_CREATED, ({ data }) => {
-        logger.info('room call received via WS', { callId: data.call_id });
+      Wazo.Websocket.once(Wazo.Websocket.CALL_CREATED, ({
+        data,
+      }) => {
+        logger.info('room call received via WS', {
+          callId: data.call_id,
+        });
+
         if (room) {
           room.setCallId(data.call_id);
         }
       });
-
       const callSession = await Wazo.Phone.call(extension, withCamera, null, audioOnly, true);
       // eslint-disable-next-line no-param-reassign
-      room = new Room(callSession, extension, null, null, extra);
-
+      room = new Room(callSession as CallSession, extension, null, null, extra);
       // Wait for the call to be accepted
       await new Promise((resolve, reject) => {
         Wazo.Phone.once(Wazo.Phone.ON_CALL_ACCEPTED, resolve);
@@ -180,8 +219,7 @@ class Room extends Emitter {
       // Retrieve conference sources
       const contacts = await getApiClient().dird.fetchConferenceContacts(sources.items[0]);
       // Retrieve conference
-      const conference = contacts.find(contact => contact.numbers.find(number => number.number === extension));
-
+      const conference = contacts?.find(contact => contact.numbers?.find(number => number.number === extension));
       logger.info('connected to room', {
         sourceId: conference ? conference.sourceId : null,
         name: conference ? conference.name : null,
@@ -196,7 +234,6 @@ class Room extends Emitter {
         uuid: meeting.uuid,
         name: meeting.name,
       });
-
       room.setMeetingUuid(meeting.uuid);
       room.setName(meeting.name);
     }
@@ -206,24 +243,21 @@ class Room extends Emitter {
 
   static disconnect() {
     logger.info('static disconnection to room');
-
     Wazo.Phone.disconnect();
   }
 
   async disconnect() {
     logger.info('disconnection to room called');
-
-    await Wazo.Phone.hangup(this.callSession);
+    await Wazo.Phone.hangup(this.callSession as CallSession);
     this.callSession = null;
     this.eventEmitter.emit(this.ON_DISCONNECTED, this);
     this.connected = false;
     this.unbind();
-
     Wazo.Phone.off(this.ON_MESSAGE, this._boundOnMessage);
     Wazo.Phone.off(this.ON_CHAT, this._boundOnChat);
     Wazo.Phone.off(this.ON_SIGNAL, this._boundOnSignal);
     Wazo.Phone.off(this.ON_VIDEO_INPUT_CHANGE, this._boundSaveLocalVideoStream);
-    Wazo.Phone.phone.off(Wazo.Phone.phone.client.ON_REINVITE, this._boundOnReinvite);
+    Wazo.Phone.phone?.off(Wazo.Phone.phone.client.ON_REINVITE, this._boundOnReinvite);
     Wazo.Websocket.off(this.CONFERENCE_USER_PARTICIPANT_JOINED, this._boundOnParticipantJoined);
     Wazo.Websocket.off(this.CONFERENCE_USER_PARTICIPANT_LEFT, this._boundOnParticipantLeft);
     Wazo.Websocket.off(this.MEETING_USER_PARTICIPANT_JOINED, this._boundOnParticipantJoined);
@@ -231,19 +265,23 @@ class Room extends Emitter {
   }
 
   setSourceId(sourceId: number) {
-    logger.info('set room source id', { sourceId });
-
+    logger.info('set room source id', {
+      sourceId,
+    });
     this.sourceId = sourceId;
   }
 
   setMeetingUuid(meetingUuid: string) {
-    logger.info('set meeting uuid', { meetingUuid });
-
+    logger.info('set meeting uuid', {
+      meetingUuid,
+    });
     this.meetingUuid = meetingUuid;
   }
 
   setCallId(callId: string) {
-    logger.info('set room call id', { callId });
+    logger.info('set room call id', {
+      callId,
+    });
 
     if (callId) {
       this.callId = callId;
@@ -251,8 +289,9 @@ class Room extends Emitter {
   }
 
   setName(name: string) {
-    logger.info('set room name', { name });
-
+    logger.info('set room name', {
+      name,
+    });
     this.name = name;
   }
 
@@ -269,10 +308,12 @@ class Room extends Emitter {
     return Wazo.Phone.sendSignal(content);
   }
 
-  async startScreenSharing(constraints: Object) {
-    logger.info('start room screen sharing', { constraints });
+  async startScreenSharing(constraints: Record<string, any>) {
+    logger.info('start room screen sharing', {
+      constraints,
+    });
+    const screensharingStream = await Wazo.Phone.startScreenSharing(constraints, this.callSession as CallSession);
 
-    const screensharingStream = await Wazo.Phone.startScreenSharing(constraints, this.callSession);
     if (!screensharingStream) {
       console.warn('screensharing stream is null (likely due to user cancellation)');
       return null;
@@ -283,22 +324,20 @@ class Room extends Emitter {
     return screensharingStream;
   }
 
-  async stopScreenSharing(restoreLocalStream: boolean = true) {
+  async stopScreenSharing(restoreLocalStream = true) {
     logger.info('stop room screen sharing');
-
-    await Wazo.Phone.stopScreenSharing(this.callSession, restoreLocalStream);
+    await Wazo.Phone.stopScreenSharing(this.callSession as CallSession, restoreLocalStream);
 
     if (this.localParticipant) {
       this._updateLocalParticipantStream();
-      // $FlowFixMe
+
       this.localParticipant.onStopScreensharing();
     }
   }
 
   turnCameraOff() {
     logger.info('turn room camera off');
-
-    Wazo.Phone.turnCameraOff(this.callSession);
+    Wazo.Phone.turnCameraOff(this.callSession as CallSession);
 
     if (this.localParticipant) {
       this.localParticipant.onVideoMuted();
@@ -307,8 +346,7 @@ class Room extends Emitter {
 
   turnCameraOn() {
     logger.info('turn room camera on');
-
-    Wazo.Phone.turnCameraOn(this.callSession);
+    Wazo.Phone.turnCameraOn(this.callSession as CallSession);
 
     if (this.localParticipant) {
       this.localParticipant.onVideoUnMuted();
@@ -317,17 +355,13 @@ class Room extends Emitter {
 
   mute() {
     logger.info('mute room');
-
-    Wazo.Phone.mute(this.callSession);
-
+    Wazo.Phone.mute(this.callSession as CallSession);
     this.sendMuteStatus();
   }
 
   unmute() {
     logger.info('unmute room');
-
-    Wazo.Phone.unmute(this.callSession);
-
+    Wazo.Phone.unmute(this.callSession as CallSession);
     this.sendUnMuteStatus();
   }
 
@@ -345,8 +379,7 @@ class Room extends Emitter {
 
   hold() {
     logger.info('hold room');
-
-    Wazo.Phone.hold(this.callSession, true);
+    Wazo.Phone.hold(this.callSession as CallSession);
 
     if (this.localParticipant) {
       this.localParticipant.onHold();
@@ -355,26 +388,23 @@ class Room extends Emitter {
 
   async resume() {
     logger.info('resume room');
-
-    const newStream = await Wazo.Phone.resume(this.callSession, true);
+    const newStream = await Wazo.Phone.resume(this.callSession as CallSession);
 
     if (this.localParticipant) {
       // Update local participant stream (useful when resuming a shreenshared conference)
       this._updateLocalParticipantStream();
 
-      // $FlowFixMe
       this.localParticipant.onResume();
 
-      // $FlowFixMe
       if (!newStream && this.localParticipant.screensharing) {
-        // $FlowFixMe
         this.localParticipant.onStopScreensharing();
       }
     }
   }
 
   _updateLocalParticipantStream() {
-    const localStream = Wazo.Phone.getLocalStream(this.callSession);
+    const localStream = Wazo.Phone.getLocalStream(this.callSession as CallSession);
+
     if (this.localParticipant && localStream) {
       const localWazoStream = new Wazo.Stream(localStream);
       this.localParticipant.resetStreams([localWazoStream]);
@@ -382,27 +412,29 @@ class Room extends Emitter {
   }
 
   sendDTMF(tone: string) {
-    logger.info('send room DTMF', { tone });
-
-    Wazo.Phone.sendDTMF(tone, this.callSession);
+    logger.info('send room DTMF', {
+      tone,
+    });
+    Wazo.Phone.sendDTMF(tone, this.callSession as CallSession);
   }
 
-  async sendReinvite(newConstraints: Object = null) {
-    logger.info('send room reinvite', { callId: this.callSession ? this.callSession.getId() : null, newConstraints });
+  async sendReinvite(newConstraints: Record<string, any> | null = null) {
+    logger.info('send room reinvite', {
+      callId: this.callSession ? this.callSession.getId() : null,
+      newConstraints,
+    });
     const wasScreensharing = this.localParticipant && this.localParticipant.screensharing;
-
     Wazo.Phone.on(Wazo.Phone.ON_SHARE_SCREEN_STARTED, () => {
       if (Wazo.Phone.phone && Wazo.Phone.phone.currentScreenShare) {
         this._onScreenSharing();
       }
     });
-
-    const response = await Wazo.Phone.phone.sendReinvite(this.callSession, newConstraints, true);
+    const response = await Wazo.Phone.phone?.sendReinvite(this.callSession, newConstraints, true);
 
     if (this.localParticipant && newConstraints && newConstraints.video) {
-      const localVideoStream = Wazo.Phone.phone.getLocalVideoStream(this.callSession);
+      const localVideoStream = Wazo.Phone.phone?.getLocalVideoStream(this.callSession as CallSession);
+
       if (localVideoStream) {
-        // $FlowFixMe
         this._associateStreamTo(localVideoStream, this.localParticipant);
       }
     } else if (this.localParticipant && wasScreensharing && newConstraints && !newConstraints.video) {
@@ -414,53 +446,57 @@ class Room extends Emitter {
   }
 
   hasALocalVideoTrack() {
-    return Wazo.Phone.hasALocalVideoTrack(this.callSession);
+    return Wazo.Phone.hasALocalVideoTrack(this.callSession as CallSession);
   }
 
   getLocalStream() {
-    return Wazo.Phone.getLocalStream(this.callSession);
+    return Wazo.Phone.getLocalStream(this.callSession as CallSession);
   }
 
   getRemoteStream() {
-    return Wazo.Phone.getRemoteStream(this.callSession);
+    return Wazo.Phone.getRemoteStream(this.callSession as CallSession);
   }
 
   getRemoteVideoStream() {
-    return Wazo.Phone.getRemoteVideoStream(this.callSession);
+    return Wazo.Phone.getRemoteVideoStream(this.callSession as CallSession);
   }
 
   _bindEvents() {
     if (!Wazo.Phone.phone || !Wazo.Phone.phone.currentSipSession) {
       return;
     }
+
     // Retrieve mapping
-    Wazo.Phone.phone.currentSipSession.sessionDescriptionHandler.on('setDescription', ({ type, sdp: rawSdp }) => {
+    // @ts-ignore
+    Wazo.Phone.phone.currentSipSession.sessionDescriptionHandler.on('setDescription', ({
+      type,
+      sdp: rawSdp,
+    }: any) => {
       if (type !== 'offer') {
         return;
       }
 
       this._mapMsid(rawSdp);
     });
-
     // Listen to REINVITE to ba able to map msid after upgrading to video in a  audio only conference
     // This allow to map msid with the non parsed (eg without the `stripVideo` modifier) SDP
     Wazo.Phone.phone.on(Wazo.Phone.phone.client.ON_REINVITE, this._boundOnReinvite);
-
     this.on(this.ON_AUDIO_STREAM, stream => {
       logger.info('on room audio stream');
-
       this.audioStream = stream;
+
       if (!this.roomAudioElement) {
-        const sessionId = Wazo.Phone.phone.getSipSessionId(Wazo.Phone.phone.currentSipSession);
-        this.roomAudioElement = Wazo.Phone.phone.createAudioElementFor(sessionId);
+        const sessionId = Wazo.Phone.phone?.getSipSessionId(Wazo.Phone.phone?.currentSipSession as Inviter | Invitation);
+        this.roomAudioElement = Wazo.Phone.phone?.createAudioElementFor(sessionId as string);
         this.roomAudioElement.srcObject = stream;
       } else {
         this.roomAudioElement.srcObject = stream;
       }
     });
-
     this.on(this.ON_VIDEO_STREAM, (stream, streamId, event, sipSession) => {
-      logger.info('on room video stream', { streamId });
+      logger.info('on room video stream', {
+        streamId,
+      });
 
       this._mapMsid(sipSession.body.body);
 
@@ -468,17 +504,17 @@ class Room extends Emitter {
       this._unassociatedVideoStreams[streamId] = stream;
 
       const callId = this._getCallIdFromTrackId(streamId);
+
       const participant = callId ? this._getParticipantFromCallId(callId) : null;
+
       if (participant) {
         this.__associateStreams(participant);
       }
     });
-
     this.on(this.ON_REMOVE_STREAM, stream => {
       logger.info('on room remove stream');
+      const participant = this.participants.find(someParticipant => someParticipant.streams.find(someStream => someStream && someStream.id === stream.id));
 
-      const participant = this.participants.find(someParticipant =>
-        someParticipant.streams.find(someStream => someStream && someStream.id === stream.id));
       if (!participant) {
         return;
       }
@@ -497,6 +533,7 @@ class Room extends Emitter {
 
   _onReinvite(session: any, inviteRequest: any) {
     const body = inviteRequest.body || inviteRequest.message.body;
+
     if (body) {
       this._mapMsid(body);
 
@@ -507,19 +544,29 @@ class Room extends Emitter {
     }
   }
 
-  _mapMsid(rawSdp: String) {
+  _mapMsid(rawSdp: string) {
     const sdp = sdpParser.parse(rawSdp);
-    const labelMsidArray = sdp.media.filter(media => !!media.label).map(({ label, msid }) => ({
+    const labelMsidArray = sdp.media.filter((media: any) => !!media.label).map(({
+      label,
+      msid,
+    }: any) => ({
       label: String(label),
       streamId: msid.split(' ')[0],
       trackId: msid.split(' ')[1],
     }));
-
-    labelMsidArray.forEach(({ label, streamId, trackId }) => {
-      this._callIdStreamIdMap[String(label)] = { streamId, trackId };
-
+    labelMsidArray.forEach(({
+      label,
+      streamId,
+      trackId,
+    }) => {
+      this._callIdStreamIdMap[String(label)] = {
+        streamId,
+        trackId,
+      };
       const callId = String(label);
+
       const participant = this._unassociatedParticipants[callId] || this._getParticipantFromCallId(callId);
+
       if (participant) {
         this.__associateStreams(participant);
       }
@@ -529,41 +576,47 @@ class Room extends Emitter {
   _transferEvents() {
     Wazo.Websocket.on(this.CONFERENCE_USER_PARTICIPANT_JOINED, this._boundOnParticipantJoined);
     Wazo.Websocket.on(this.CONFERENCE_USER_PARTICIPANT_LEFT, this._boundOnParticipantLeft);
-
     Wazo.Websocket.on(this.MEETING_USER_PARTICIPANT_JOINED, this._boundOnParticipantJoined);
     Wazo.Websocket.on(this.MEETING_USER_PARTICIPANT_LEFT, this._boundOnParticipantLeft);
-
     // Phone events
     Wazo.Phone.on(this.ON_MESSAGE, this._boundOnMessage);
     Wazo.Phone.on(this.ON_CHAT, this._boundOnChat);
     Wazo.Phone.on(this.ON_SIGNAL, this._boundOnSignal);
     Wazo.Phone.on(this.ON_VIDEO_INPUT_CHANGE, this._boundSaveLocalVideoStream);
-
-    [this.ON_AUDIO_STREAM, this.ON_VIDEO_STREAM, this.ON_REMOVE_STREAM].forEach(event =>
-      Wazo.Phone.on(event, (...args) => this.eventEmitter.emit.apply(this.eventEmitter, [event, ...args])));
+    [this.ON_AUDIO_STREAM, this.ON_VIDEO_STREAM, this.ON_REMOVE_STREAM].forEach(event => Wazo.Phone.on(event, (...args) => this.eventEmitter.emit.apply(this.eventEmitter, [event, ...args])));
   }
 
-  _onMessage(message: Message): ?Object {
+  _onMessage(message: Message): Record<string, any> | null | undefined {
+    // @ts-ignore
     if (message.method !== 'MESSAGE') {
       return null;
     }
-    let body;
+
+    let body: any;
+
     try {
+      // @ts-ignore
       body = JSON.parse(message.body);
-    } catch (e) {
+    } catch (e: any) {
       return null;
     }
 
     switch (body.type) {
-      case 'ConfbridgeTalking': {
+      case 'ConfbridgeTalking':
+      {
         // Update participant
         const channel = body.channels[0];
-        const { id: callId, talking_status: talkingStatus } = channel;
+        const {
+          id: callId,
+          talking_status: talkingStatus,
+        } = channel;
         const isTalking = talkingStatus === 'on';
         const participantIdx = this.participants.findIndex(participant => participant.callId === callId);
+
         if (participantIdx === -1) {
           return;
         }
+
         this.participants[participantIdx].onTalking(isTalking);
         break;
       }
@@ -572,33 +625,44 @@ class Room extends Emitter {
     }
 
     this.eventEmitter.emit(this.ON_MESSAGE, body);
-
     return body;
   }
 
-  _onChat(content: Object) {
+  _onChat(content: Record<string, any>) {
     this.eventEmitter.emit(this.ON_CHAT, content);
   }
 
-  _onSignal(content: Object) {
-    const { type } = content;
+  _onSignal(content: Record<string, any>) {
+    const {
+      type,
+    } = content;
 
     switch (type) {
       // we're receiving a external update
-      case SIGNAL_TYPE_PARTICIPANT_UPDATE: {
-        const { status } = content;
-        const participant: ?Participant = this._getParticipantFromCallId(status.callId);
+      case SIGNAL_TYPE_PARTICIPANT_UPDATE:
+      {
+        const {
+          status,
+        } = content;
+
+        const participant: Participant | null | undefined = this._getParticipantFromCallId(status.callId);
 
         if (participant) {
           // we're receiving, so no need to broadcast
           participant.updateStatus(status, false);
         }
+
         break;
       }
 
       // this is a request to broadcast our current status
-      case SIGNAL_TYPE_PARTICIPANT_REQUEST: {
-        const { callId, origin } = content;
+      case SIGNAL_TYPE_PARTICIPANT_REQUEST:
+      {
+        const {
+          callId,
+          origin,
+        } = content;
+
         // callId is null, someone's requesting everyone's state;
         // or callId is set and matches ours;
         if (this.localParticipant && (!callId || callId === this.localParticipant.callId)) {
@@ -606,18 +670,27 @@ class Room extends Emitter {
         }
 
         // might as well update the requester's status
-        const requester: ?Participant = this._getParticipantFromCallId(origin.callId);
+        const requester: Participant | null | undefined = this._getParticipantFromCallId(origin.callId);
+
         if (requester) {
           // @FIXME?: when need to trigger an update on join-in; this is a bit of a hack
-          logger.info('trigger room requester status', { origin });
+          logger.info('trigger room requester status', {
+            origin,
+          });
           requester.triggerUpdate('REQUESTER_UPDATE');
         }
+
         break;
       }
 
-      case Wazo.Phone.ON_MESSAGE_TRACK_UPDATED: {
-        const { callId, update } = content;
+      case Wazo.Phone.ON_MESSAGE_TRACK_UPDATED:
+      {
+        const {
+          callId,
+          update,
+        } = content;
         const participantIdx = this.participants.findIndex(p => p.callId === callId);
+
         if (participantIdx !== -1) {
           this.participants[participantIdx] = this._onParticipantTrackUpdate(this.participants[participantIdx], update);
         }
@@ -625,7 +698,8 @@ class Room extends Emitter {
         break;
       }
 
-      default: {
+      default:
+      {
         console.warn('uncaught signal', content);
       }
     }
@@ -633,61 +707,65 @@ class Room extends Emitter {
     this.eventEmitter.emit(Wazo.Phone.ON_SIGNAL, content);
   }
 
-  async _onParticipantJoined(payload: Object) {
+  async _onParticipantJoined(payload: Record<string, any>) {
     const participant = payload.data;
     const session = Wazo.Auth.getSession();
-    let participants = [];
+    let participants: Participant[] = [];
 
     // When we join the room, we can call `getConferenceParticipantsAsUser`, not before.
-    if (participant.user_uuid === session.uuid) {
+    if (participant.user_uuid === session?.uuid) {
       logger.info('room current user joined');
-
       // Retrieve participants via an API calls
       const conferenceId = this.sourceId || payload.data.conference_id;
       let response;
+
       try {
         if (this.meetingUuid) {
-          logger.info('fetching meeting participants', { meetingUuid: this.meetingUuid });
+          logger.info('fetching meeting participants', {
+            meetingUuid: this.meetingUuid,
+          });
           response = await getApiClient().calld.getMeetingParticipantsAsUser(this.meetingUuid);
         } else {
-          logger.info('fetching conference participants', { conferenceId });
+          logger.info('fetching conference participants', {
+            conferenceId,
+          });
           response = await getApiClient().calld.getConferenceParticipantsAsUser(conferenceId);
         }
-      } catch (e) {
+      } catch (e: any) {
         logger.error('room participants fetching, error', e);
       }
+
       if (response) {
-        logger.info('conference participants fetched', { nb: response.items.length });
-        participants = response.items.map(item => {
+        logger.info('conference participants fetched', {
+          nb: response.items.length,
+        });
+        participants = response.items.map((item: RawParticipant) => {
           const isMe = item.call_id === this.callId;
-
-          return isMe && item.call_id
-            ? new Wazo.LocalParticipant(this, item, this.extra)
-            : new Wazo.RemoteParticipant(this, item);
+          return isMe && item.call_id ? new Wazo.LocalParticipant(this, item, this.extra) : new Wazo.RemoteParticipant(this, item);
         });
-
         this.participants = participants;
+        const localParticipant = participants.find((someParticipant: any) => someParticipant instanceof Wazo.LocalParticipant);
 
-        const localParticipant = participants.find(someParticipant => someParticipant instanceof Wazo.LocalParticipant);
         if (!this.localParticipant && localParticipant) {
           this._onLocalParticipantJoined(localParticipant);
         }
 
-        participants.forEach(someParticipant => this._isParticipantJoining(someParticipant));
+        participants.forEach((someParticipant: Participant) => this._isParticipantJoining(someParticipant));
         this.eventEmitter.emit(this.ON_JOINED, localParticipant, participants);
       }
 
       return this.participants;
     }
 
-    const remoteParticipant: ?RemoteParticipant = !this.participants.some(p => p.callId === participant.call_id)
-      ? new Wazo.RemoteParticipant(this, participant)
-      : null;
-
-    logger.info('other room user joined', { callId: participant.call_id, remoteParticipant: !!remoteParticipant });
+    const remoteParticipant: RemoteParticipant | null | undefined = !this.participants.some(p => p.callId === participant.call_id) ? new Wazo.RemoteParticipant(this, participant) : null;
+    logger.info('other room user joined', {
+      callId: participant.call_id,
+      remoteParticipant: !!remoteParticipant,
+    });
 
     if (remoteParticipant) {
       this.participants.push(remoteParticipant);
+
       this._isParticipantJoining(remoteParticipant);
     }
 
@@ -698,12 +776,12 @@ class Room extends Emitter {
     this.localParticipant = localParticipant;
 
     const localVideoStream = this._getLocalVideoStream();
+
     if (localVideoStream) {
       this._saveLocalVideoStream(localVideoStream);
     }
 
     this.connected = true;
-
     localParticipant.broadcastStatus(null, true);
 
     // we're in the room, now let's request everyone's status
@@ -717,6 +795,7 @@ class Room extends Emitter {
 
   _isParticipantJoining(participant: Participant) {
     this.__associateStreams(participant);
+
     // @VALIDATE: no need to publicize ourselves, no?
     if (participant instanceof RemoteParticipant) {
       this.eventEmitter.emit(this.CONFERENCE_USER_PARTICIPANT_JOINED, participant);
@@ -724,7 +803,9 @@ class Room extends Emitter {
   }
 
   _saveLocalVideoStream(stream: MediaStream) {
-    const { localParticipant } = this;
+    const {
+      localParticipant,
+    } = this;
 
     if (!localParticipant) {
       return;
@@ -740,33 +821,32 @@ class Room extends Emitter {
     return videoStream;
   }
 
-  _onParticipantLeft(payload: Object) {
-    const leftParticipant = this.participants.find(participant =>
-      participant && participant.callId === payload.data.call_id);
+  _onParticipantLeft(payload: Record<string, any>) {
+    const leftParticipant = this.participants.find(participant => participant && participant.callId === payload.data.call_id);
 
     // Trigger Participant.ON_DISCONNECT event
     if (leftParticipant) {
       leftParticipant.onDisconnect();
     }
 
-    this.participants = this.participants.filter(participant =>
-      participant && participant.callId !== payload.data.call_id);
+    this.participants = this.participants.filter(participant => participant && participant.callId !== payload.data.call_id);
     this.eventEmitter.emit(this.CONFERENCE_USER_PARTICIPANT_LEFT, leftParticipant);
   }
 
   _onParticipantTrackUpdate(oldParticipant: Participant, update: string): Participant {
     const newParticipant = oldParticipant;
-
-    const { trackId, streamId } = this._callIdStreamIdMap[newParticipant.callId] || {};
+    const {
+      trackId,
+      streamId,
+    } = this._callIdStreamIdMap[newParticipant.callId] || {};
+    // @ts-ignore
     const pc = Wazo.Phone.phone.currentSipSession.sessionDescriptionHandler.peerConnection;
     // Can't use `getReceivers` here because on FF we make the mapping based on the streamId
-    const stream = pc.getRemoteStreams().find(someStream =>
-      someStream.id === streamId || someStream.getTracks().some(track => track.id === trackId));
+    const stream = pc.getRemoteStreams().find((someStream: any) => someStream.id === streamId || someStream.getTracks().some((track: any) => track.id === trackId));
 
     if (update === 'downgrade') {
       newParticipant.resetStreams([]);
       newParticipant.onStreamUnSubscribed(stream);
-
       return newParticipant;
     }
 
@@ -780,18 +860,23 @@ class Room extends Emitter {
 
   // Associate audio/video streams to the participant and triggers events on it
   __associateStreams(participant: Participant) {
-    const { trackId } = this._callIdStreamIdMap[participant.callId] || {};
+    const {
+      trackId,
+    } = this._callIdStreamIdMap[participant.callId] || {};
+
     if (!trackId) {
       this._unassociatedParticipants[participant.callId] = participant;
-
       return;
     }
+
     if (!trackId || !participant || !this.localParticipant || participant.callId === this.localParticipant.callId) {
       return;
     }
 
     const streamId = this._getStreamIdFrTrackId(trackId);
-    const key = this._getUnassociatedMapIdFromTrackIdOrStreamId(trackId, streamId);
+
+    const key: any = this._getUnassociatedMapIdFromTrackIdOrStreamId(trackId, streamId);
+
     const stream = this._unassociatedVideoStreams[key];
 
     if (stream) {
@@ -803,7 +888,7 @@ class Room extends Emitter {
     }
   }
 
-  _getUnassociatedMapIdFromTrackIdOrStreamId(trackId: string, streamId: ?string) {
+  _getUnassociatedMapIdFromTrackIdOrStreamId(trackId: string, streamId: string | null | undefined) {
     // Find by trackId
     if (trackId in this._unassociatedVideoStreams) {
       return trackId;
@@ -815,14 +900,12 @@ class Room extends Emitter {
     }
 
     // Find in all the streams by streamId (used on FF where we can't map by trackId)
-    const idx = Object.values(this._unassociatedVideoStreams).findIndex((stream: Object) =>
-      stream && stream.id === streamId);
+    const idx = Object.values(this._unassociatedVideoStreams).findIndex((stream: Record<string, any>) => stream && stream.id === streamId);
     return idx === -1 ? null : Object.keys(this._unassociatedVideoStreams)[idx];
   }
 
   _getStreamIdFrTrackId(trackId: string) {
-    const mapping: Object = Object.values(this._callIdStreamIdMap).find((map: Object) => map.trackId === trackId);
-
+    const mapping: Record<string, any> = Object.values(this._callIdStreamIdMap).find((map: Record<string, any>) => map.trackId === trackId);
     return mapping ? mapping.streamId : null;
   }
 
@@ -830,7 +913,6 @@ class Room extends Emitter {
     const stream = new Wazo.Stream(rawStream, participant);
     participant.streams.push(stream);
     participant.videoStreams.push(stream);
-
     participant.onStreamSubscribed(stream);
   }
 
@@ -843,8 +925,9 @@ class Room extends Emitter {
   }
 
   _getLocalVideoStream() {
-    return Wazo.Phone.getLocalVideoStream(this.callSession);
+    return Wazo.Phone.getLocalVideoStream(this.callSession as CallSession);
   }
+
 }
 
 export default Room;