feat(jaas) add simple zero-config mechanism for JaaS users

Technically anyone can use it as long as they provide connection
options, but we don't need any of that for JaaS.

JitsiConference.js

  * @param replaceParticipant {boolean} whether the current join replaces
  * an existing participant with same jwt from the meeting.
  */
-JitsiConference.prototype.join = function(password, replaceParticipant = false) {
+JitsiConference.prototype.join = function(password = '', replaceParticipant = false) {
     if (this.room) {
         this.room.join(password, replaceParticipant).then(() => this._maybeSetSITimeout());
     }

JitsiMeetJS.ts

 import Logger from '@jitsi/logger';
+import { merge } from 'lodash-es';
 
+import JitsiConference from './JitsiConference';
 import * as JitsiConferenceErrors from './JitsiConferenceErrors';
 import * as JitsiConferenceEvents from './JitsiConferenceEvents';
 import JitsiConnection from './JitsiConnection';
 import * as JitsiConnectionErrors from './JitsiConnectionErrors';
-import * as JitsiConnectionEvents from './JitsiConnectionEvents';
+import { JitsiConnectionEvents } from './JitsiConnectionEvents';
 import JitsiMediaDevices from './JitsiMediaDevices';
 import * as JitsiMediaDevicesEvents from './JitsiMediaDevicesEvents';
 import JitsiTrackError from './JitsiTrackError';
 import * as JitsiTrackErrors from './JitsiTrackErrors';
 import * as JitsiTrackEvents from './JitsiTrackEvents';
 import * as JitsiTranscriptionStatus from './JitsiTranscriptionStatus';
+import JitsiLocalTrack from './modules/RTC/JitsiLocalTrack';
 import RTC from './modules/RTC/RTC';
 import RTCStats from './modules/RTCStats/RTCStats';
 import * as RTCStatsEvents from './modules/RTCStats/RTCStatsEvents';
 import LocalStatsCollector from './modules/statistics/LocalStatsCollector';
 import runPreCallTest, { IIceServer, IPreCallResult } from './modules/statistics/PreCallTest';
 import Statistics from './modules/statistics/statistics';
+import Deferred from './modules/util/Deferred';
 import ScriptUtil from './modules/util/ScriptUtil';
 import * as VideoSIPGWConstants from './modules/videosipgw/VideoSIPGWConstants';
 import AudioMixer from './modules/webaudio/AudioMixer';
     videoType?: VideoType;
 }
 
+export interface IJoinConferenceOptions {
+    conferenceOptions?: any;
+    connectionOptions?: any;
+    jaas?: {
+        release?: boolean;
+        useStaging?: boolean;
+    };
+    tracks?: JitsiLocalTrack[];
+}
+
 /**
  * The public API of the Jitsi Meet library (a.k.a. {@code JitsiMeetJS}).
  */
         return Statistics.audioLevelsEnabled && LocalStatsCollector.isLocalStatsSupported();
     },
 
+    /**
+     * Simple way to create a {JitsiConference}. All options are optional and sane defaults
+     * will be chosen for JaaS users.
+     *
+     * @param roomName - The name of the conference.
+     * @param appId - The application id (also known as tenant).
+     * @param token - The token (JWT) to use for authentication.
+     * @param options - The options to use for joining the conference.
+     */
+    async joinConference(
+            roomName: string,
+            appId: string = '',
+            token: string | null = null,
+            options: IJoinConferenceOptions = {}): Promise<JitsiConference> {
+        const d = new Deferred();
+        let connectionOptions = options.connectionOptions ?? {};
+
+        // Provide a solid default config in case of JaaS.
+        if (appId.startsWith('vpaas-magic-cookie')) {
+            // Initialize RTCStats logging.
+            Logger.addGlobalTransport(RTCStats.getDefaultLogCollector());
+
+            const useStage = options.jaas?.useStaging ?? false;
+            const jaasDomain = useStage ? 'staging.8x8.vc' : '8x8.vc';
+            const opts = {
+                hosts: {
+                    domain: jaasDomain,
+                    muc: `conference.${appId}.${jaasDomain}`
+                },
+                conferenceRequestUrl: `https://${jaasDomain}/${appId}/conference-request/v1?room=${roomName}`,
+                serviceUrl: `wss://${jaasDomain}/${appId}/xmpp-websocket?room=${roomName}`,
+                websocketKeepAliveUrl: `https://${jaasDomain}/${appId}/_unlock?room=${roomName}`,
+                analytics: {
+                    rtcstatsEnabled: true,
+                    rtcstatsEndpoint: `wss://rtcstats-server-${useStage ? 'pilot' : '8x8'}.jitsi.net/`,
+                    rtcstatsSendSdp: true,
+                },
+            };
+
+            connectionOptions = merge(connectionOptions, opts);
+        }
+
+        const conn = new JitsiConnection(appId, token, connectionOptions);
+
+        function cleanupListeners() {
+            conn.removeEventListener(
+                JitsiConnectionEvents.CONNECTION_ESTABLISHED, onConnectionEstablished);
+            conn.removeEventListener(
+                JitsiConnectionEvents.CONNECTION_FAILED, onConnectionFailed);
+        }
+
+        function onConnectionEstablished() {
+            cleanupListeners();
+
+            const conf = conn.initJitsiConference(roomName, options.conferenceOptions ?? {});
+
+            d.resolve(conf);
+
+            // Make sure this runs after the promise was resolved so that local track events can be
+            // listened to.
+            queueMicrotask(() => {
+                for (const track of options.tracks || []) {
+                    conf.addTrack(track);
+                }
+
+                conf.join();
+
+                // Default to receiving 720p for everyone.
+                conf.setReceiverConstraints({
+                    lastN: -1,
+                    defaultConstraints: { maxHeight: 720 },
+                });
+            });
+        }
+
+        function onConnectionFailed(error: string) {
+            cleanupListeners();
+            d.reject(error);
+        }
+
+        conn.addEventListener(
+            JitsiConnectionEvents.CONNECTION_ESTABLISHED, onConnectionEstablished);
+        conn.addEventListener(
+            JitsiConnectionEvents.CONNECTION_FAILED, onConnectionFailed);
+        conn.connect({ name: roomName });
+
+        return d as unknown as Promise<JitsiConference>;
+    },
+
     /**
      * Informs lib-jitsi-meet about the current network status.
      *

modules/RTCStats/RTCStats.ts

     /**
      * Creates a new log collector with the default log storage.
      */
-    getDefaultLogCollector(maxEntryLength) {
+    getDefaultLogCollector(maxEntryLength: number = 10000) {
         if (!this._defaultLogCollector) {
             // If undefined is passed  as maxEntryLength LogCollector will default to 10000 bytes
             this._defaultLogCollector = new Logger.LogCollector(new DefaultLogStorage(this), { maxEntryLength });