feat(TS) Migrate `modules\RTC\JitsiLocalTrack.ts` to TS (#2840)

* added interfaces and initialise TS def

* add proper typings avoiding any

* fixing linting errors

---------

Co-authored-by: naman9271 <naman9271@gmail.com>

JitsiConference.js

    *
    * @param {JitsiLocalTrack} localtrack - The track associated with the local source signaled to the bridge.
    * @returns {void}
-   * @private
+   * @public
    */
     _sendBridgeVideoTypeMessage(localtrack) {
         let videoType = !localtrack || localtrack.isMuted() ? BridgeVideoType.NONE : localtrack.getVideoType();
    * @param {JitsiLocalTrack} localTrack - The local track.
    * @param {boolean} isMuted - Whether the track is muted.
    * @return {boolean} <tt>true</tt> when presence was changed, <tt>false</tt> otherwise.
-   * @private
+   * @public
    */
     _setTrackMuteStatus(mediaType, localTrack, isMuted) {
         let presenceChanged = false;

modules/RTC/JitsiLocalTrack.js → modules/RTC/JitsiLocalTrack.ts

 import { getLogger } from '@jitsi/logger';
 
+import JitsiConference from '../../JitsiConference';
 import JitsiTrackError from '../../JitsiTrackError';
 import {
     TRACK_IS_DISPOSED,
 
 import JitsiTrack from './JitsiTrack';
 import RTCUtils from './RTCUtils';
+import TraceablePeerConnection from './TraceablePeerConnection';
 
 const logger = getLogger('modules/RTC/JitsiLocalTrack');
 
+export interface IStreamEffect {
+    isEnabled: (track: JitsiLocalTrack) => boolean;
+    isMuted?: () => boolean;
+    setMuted?: (muted: boolean) => void;
+    startEffect: (stream: MediaStream) => MediaStream;
+    stopEffect: () => void;
+}
+
+export interface ITrackMetadata {
+    displaySurface?: string;
+    timestamp: number;
+}
+
+export interface ITrackConstraints {
+    [key: string]: any;
+    height?: any;
+    width?: any;
+}
+
+export interface ITrackInfo {
+    constraints: ITrackConstraints;
+    deviceId: string;
+    effects?: IStreamEffect[];
+    facingMode?: CameraFacingMode;
+    mediaType: MediaType;
+    rtcId: number;
+    sourceId?: string;
+    sourceType?: string;
+    stream: MediaStream;
+    track: MediaStreamTrack;
+    videoType?: VideoType;
+}
+
+export interface IStreamInfo {
+    stream: MediaStream;
+    track: MediaStreamTrack;
+    videoType?: VideoType;
+}
+
 /**
  * Represents a single media track(either audio or video).
  * One <tt>JitsiLocalTrack</tt> corresponds to one WebRTC MediaStreamTrack.
  */
 export default class JitsiLocalTrack extends JitsiTrack {
+    private _setEffectInProgress: boolean;
+    private _constraints: ITrackConstraints;
+    private _prevSetMuted: Promise<void>;
+    private _facingMode?: CameraFacingMode;
+    private _trackEnded: boolean;
+    private _hasSentData: boolean;
+    private _testDataSent: boolean;
+    private _realDeviceId?: string;
+    private _sourceName?: string;
+    private _ssrc?: number;
+    private _trackMutedTS: number;
+    private _onDeviceListWillChange: (devices: MediaDeviceInfo[]) => void;
+    private _onAudioOutputDeviceChanged?: () => void;
+    private _streamEffect?: IStreamEffect;
+    private _originalStream?: MediaStream;
+    private _stopStreamInProgress: boolean;
+    private _effectEnabled?: boolean;
+    public metadata: ITrackMetadata;
+    public rtcId: number;
+    public sourceId?: string;
+    public sourceType?: string;
+    public deviceId: string;
+    public resolution?: number;
+    public maxEnabledResolution?: number;
+    public conference: JitsiConference | null;
+
     /**
      * Constructs a new JitsiLocalTrack instance.
      *
         track,
         videoType,
         effects = []
-    }) {
+    }: ITrackInfo) {
         super(
             /* conference */ null,
             stream,
 
         this._trackMutedTS = 0;
 
-        this._onDeviceListWillChange = devices => {
+        this._onDeviceListWillChange = (devices: MediaDeviceInfo[]) => {
             const oldRealDeviceId = this._realDeviceId;
 
             this._setRealDeviceIdFromDeviceList(devices);
      * @private
      * @returns {Promise}
      */
-    _addStreamToConferenceAsUnmute() {
+    private _addStreamToConferenceAsUnmute(): Promise<void> {
         if (!this.conference) {
             return Promise.resolve();
         }
         // are changed. This would help to separate XMPP from the RTC module.
         return new Promise((resolve, reject) => {
             this.conference._addLocalTrackToPc(this)
-                .then(resolve, error => reject(new Error(error)));
+                .then(resolve, (error: any) => reject(new Error(error)));
         });
     }
 
      * @private
      * @returns {void}
      */
-    _fireNoDataFromSourceEvent() {
+    private _fireNoDataFromSourceEvent(): void {
         const value = !this.isReceivingData();
 
         this.emit(NO_DATA_FROM_SOURCE, value);
      * @private
      * @returns {void}
      */
-    _initNoDataFromSourceHandlers() {
+    private _initNoDataFromSourceHandlers(): void {
         if (!this._isNoDataFromSourceEventsEnabled()) {
             return;
         }
      * @private
      * @returns {boolean} - True if no data from source events are enabled for this JitsiLocalTrack and false otherwise.
      */
-    _isNoDataFromSourceEventsEnabled() {
+    private _isNoDataFromSourceEventsEnabled(): boolean {
         // Disable the events for screen sharing.
         return !this.isVideoTrack() || this.videoType !== VideoType.DESKTOP;
     }
      * @private
      * @returns {Promise}
      */
-    _queueSetMuted(muted) {
+    private _queueSetMuted(muted: boolean): Promise<void> {
         const setMuted = this._setMuted.bind(this, muted);
 
         this._prevSetMuted = this._prevSetMuted.then(setMuted, setMuted);
      * @private
      * @returns {Promise}
      */
-    _removeStreamFromConferenceAsMute(successCallback, errorCallback) {
+    private _removeStreamFromConferenceAsMute(successCallback: () => void, errorCallback: (error: Error) => void): void {
         if (!this.conference) {
             successCallback();
 
         }
         this.conference._removeLocalTrackFromPc(this).then(
             successCallback,
-            error => errorCallback(new Error(error)));
+            (error: any) => errorCallback(new Error(error)));
     }
 
     /**
      * @private
      * @returns {void}
      */
-    _sendMuteStatus(mute) {
+    private _sendMuteStatus(mute: boolean): void {
         if (this.conference) {
             this.conference._setTrackMuteStatus(this.getType(), this, mute) && this.conference.room.sendPresence();
         }
      * @private
      * @returns {Promise}
      */
-    _setMuted(muted) {
+    private _setMuted(muted: boolean): Promise<void> {
         if (this.isMuted() === muted && this.videoType !== VideoType.DESKTOP) {
             return Promise.resolve();
         }
             return Promise.reject(new JitsiTrackError(TRACK_IS_DISPOSED));
         }
 
-        let promise = Promise.resolve();
+        let promise: Promise<void | IStreamInfo[]> = Promise.resolve();
 
         // A function that will print info about muted status transition
         const logMuteInfo = () => logger.info(`Mute ${this}: ${muted}`);
             // If we have a stream effect that implements its own mute functionality, prioritize it before
             // normal mute e.g. the stream effect that implements system audio sharing has a custom
             // mute state in which if the user mutes, system audio still has to go through.
-            if (this._streamEffect && this._streamEffect.setMuted) {
+            if (this._streamEffect?.setMuted) {
                 this._streamEffect.setMuted(muted);
             } else if (this.track) {
                 this.track.enabled = !muted;
                 = RTCUtils.obtainAudioAndVideoPermissions({
 
                     ...streamOptions,
-                    constraints: { video: this._constraints } });
+                    constraints: { video: this._constraints } } as any) as Promise<IStreamInfo[]>;
 
-            promise = promise.then(streamsInfo => {
+            promise = promise.then((streamsInfo: IStreamInfo[]) => {
                 const streamInfo = streamsInfo.find(info => info.track.kind === this.getType());
 
                 if (streamInfo) {
                 this._sendMuteStatus(muted);
 
                 // Send the videoType message to the bridge.
-                this.isVideoTrack() && this.conference && this.conference._sendBridgeVideoTypeMessage(this);
+                this.isVideoTrack() && this.conference?._sendBridgeVideoTypeMessage(this);
                 this.emit(TRACK_MUTE_CHANGED, this);
             });
     }
      * @private
      * @returns {void}
      */
-    _setRealDeviceIdFromDeviceList(devices) {
+    private _setRealDeviceIdFromDeviceList(devices: MediaDeviceInfo[]): void {
         const track = this.getTrack();
         const kind = `${track.kind}input`;
 
         }
     }
 
-    /**
-     * Sets the stream property of JitsiLocalTrack object and sets all stored handlers to it.
-     *
-     * @param {MediaStream} stream - The new MediaStream.
-     * @private
-     * @returns {void}
-     */
-    _setStream(stream) {
-        super._setStream(stream);
-    }
-
     /**
      * Starts the effect process and returns the modified stream.
      *
      * @private
      * @returns {void}
      */
-    _startStreamEffect(effect) {
+    private _startStreamEffect(effect: IStreamEffect): void {
         this._streamEffect = effect;
         this._originalStream = this.stream;
         this._setStream(this._streamEffect.startEffect(this._originalStream));
      * @private
      * @returns {void}
      */
-    _stopStreamEffect() {
+    private _stopStreamEffect(): void {
         if (this._streamEffect) {
             this._streamEffect.stopEffect();
             this._setStream(this._originalStream);
      *
      * @returns {void}
      */
-    _switchCamera() {
+    private _switchCamera(): void {
         if (this.isVideoTrack()
                 && this.videoType === VideoType.CAMERA
                 && typeof this.track._switchCamera === 'function') {
      * @private
      * @returns {void}
      */
-    _switchStreamEffect(effect) {
+    private _switchStreamEffect(effect?: IStreamEffect): void {
         if (this._streamEffect) {
             this._stopStreamEffect();
             this._streamEffect = undefined;
         }
     }
 
+    /**
+     * Sets the stream property of JitsiLocalTrack object and sets all stored handlers to it.
+     *
+     * @param {MediaStream} stream - The new MediaStream.
+     * @private
+     * @returns {void}
+     */
+    protected _setStream(stream: MediaStream | null): void {
+        super._setStream(stream);
+    }
+
+
     /**
      * @inheritdoc
      *
      * @extends JitsiTrack#dispose
      * @returns {Promise}
      */
-    async dispose() {
+    async dispose(): Promise<void> {
         if (this.disposed) {
             return;
         }
         // Remove the effect instead of stopping it so that the original stream is restored
         // on both the local track and on the peerconnection.
         if (this._streamEffect) {
-            await this.setEffect();
+            await this.setEffect(undefined);
         }
 
         if (this.conference) {
      *
      * @returns {CameraFacingMode|undefined}
      */
-    getCameraFacingMode() {
+    getCameraFacingMode(): CameraFacingMode | undefined {
         if (this.isVideoTrack() && this.videoType === VideoType.CAMERA) {
             // MediaStreamTrack#getSettings() is not implemented in many
             // browsers, so we need feature checking here. Progress on the
             const trackSettings = this.track.getSettings?.();
 
             if (trackSettings && 'facingMode' in trackSettings) {
-                return trackSettings.facingMode;
+                return trackSettings.facingMode as CameraFacingMode;
             }
 
             if (typeof this._facingMode !== 'undefined') {
      *
      * @returns {Number}
      */
-    getCaptureResolution() {
+    getCaptureResolution(): number {
         if (this.videoType === VideoType.CAMERA || !browser.isWebKitBased()) {
-            return this.resolution;
+            return this.resolution!;
         }
 
         return this.getHeight();
      *
      * @returns {string}
      */
-    getDeviceId() {
+    getDeviceId(): string {
         return this._realDeviceId || this.deviceId;
     }
 
      *
      * @returns {Number} the duration of the track in seconds
      */
-    getDuration() {
+    getDuration(): number {
         return (Date.now() / 1000) - (this.metadata.timestamp / 1000);
     }
 
      * @returns {string} the id of the participants. It corresponds to the
      * Colibri endpoint id/MUC nickname in case of Jitsi-meet.
      */
-    getParticipantId() {
-        return this.conference && this.conference.myUserId();
+    getParticipantId(): string {
+        return this.conference?.myUserId();
     }
 
     /**
      *
      * @returns {string | null} source name
      */
-    getSourceName() {
+    getSourceName(): string | null {
         return this._sourceName;
     }
 
      * Returns the primary SSRC associated with the track.
      * @returns {number}
      */
-    getSsrc() {
+    getSsrc(): number | null {
         return this._ssrc;
     }
 
      *
      * @returns {boolean}
      */
-    isEnded() {
+    isEnded(): boolean {
         if (this.isVideoTrack() && this.isMuted()) {
             // If a video track is muted the readyState will be ended, that's why we need to rely only on the
             // _trackEnded flag.
      *
      * @returns {boolean} <tt>true</tt>
      */
-    isLocal() {
+    isLocal(): boolean {
         return true;
     }
 
      *
      * @returns {boolean} <tt>true</tt> - if the stream is muted and <tt>false</tt> otherwise.
      */
-    isMuted() {
+    isMuted(): boolean {
         // this.stream will be null when we mute local video on Chrome
         if (!this.stream) {
             return true;
         }
 
         // If currently used stream effect has its own muted state, use that.
-        if (this._streamEffect && this._streamEffect.isMuted) {
+        if (this._streamEffect?.isMuted) {
             return this._streamEffect.isMuted();
         }
 
-        return !this.track || !this.track.enabled;
+        return !this.track?.enabled;
     }
 
     /**
      *
      * @returns {boolean} true if the stream is receiving data and false this otherwise.
      */
-    isReceivingData() {
+    isReceivingData(): boolean {
         if (this.isVideoTrack()
             && (this.isMuted() || this._stopStreamInProgress || this.videoType === VideoType.DESKTOP)) {
             return true;
      *
      * @returns {Promise}
      */
-    mute() {
+    mute(): Promise<void> {
         return this._queueSetMuted(true);
     }
 
      * @param {number} bytesSent - The new value.
      * @returns {void}
      */
-    onByteSentStatsReceived(tpc, bytesSent) {
+    onByteSentStatsReceived(tpc: TraceablePeerConnection, bytesSent: number): void {
         if (bytesSent > 0) {
             this._hasSentData = true;
         }
      * @param conference - JitsiConference object.
      * @returns {void}
      */
-    setConference(conference) {
+    setConference(conference: JitsiConference): void {
         this.conference = conference;
     }
 
      * @param {Object} effect - Represents the effect instance to be used.
      * @returns {Promise}
      */
-    setEffect(effect) {
+    setEffect(effect?: IStreamEffect): Promise<void> {
         if (typeof this._streamEffect === 'undefined' && typeof effect === 'undefined') {
             return Promise.resolve();
         }
             .then(() => {
                 this._setEffectInProgress = false;
             })
-            .catch(error => {
+            .catch((error: any) => {
                 // Any error will be not recovarable and will trigger CONFERENCE_FAILED event. But let's try to cleanup
                 // everyhting related to the effect functionality.
                 this._setEffectInProgress = false;
      *
      * @param {string} name The source name.
      */
-    setSourceName(name) {
+    setSourceName(name: string): void {
         this._sourceName = name;
     }
 
      *
      * @param {number} ssrc The SSRC.
      */
-    setSsrc(ssrc) {
+    setSsrc(ssrc: number): void {
         if (isValidNumber(ssrc)) {
             this._ssrc = ssrc;
         }
      *
      * @returns {void}
      */
-    stopStream() {
+    stopStream(): void {
         /**
          * Indicates that we are executing {@link #stopStream} i.e.
          * {@link RTCUtils#stopMediaStream} for the <tt>MediaStream</tt>
      *
      * @return {string}
      */
-    toString() {
+    toString(): string {
         return `LocalTrack[${this.rtcId},${this.getType()}]`;
     }
 
      *
      * @returns {Promise}
      */
-    unmute() {
+    unmute(): Promise<void> {
         return this._queueSetMuted(false);
     }
 }

modules/RTC/JitsiTrack.js

 
     /**
      * Unregisters all event handlers bound to the underlying media stream/track
-     * @private
+     * @public
      */
     _unregisterHandlers() {
         if (!this.stream) {