doc: replace documentation with the handbook

- Leave a link on doc/README,api,quick-install - Moved the cloud API swagger file to resources/ - Merged the coding conventions with CONTRIBUTING.md
2020-05-16 15:48:21 +02:00 · 2020-05-16 15:48:21 +02:00 · 7c4c8384fd
parent 262e855260
commit 7c4c8384fd
18 changed files with 99 additions and 1744 deletions
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@ -27,3 +27,99 @@ in the agreement, unfortunately, we cannot accept your contribution.
 - Maintain a clean list of commits, squash them if necessary.
 - Rebase your topic branch on top of the master branch before creating the pull
 request.
 ## Coding style
 ### Comments
 * Comments documenting the source code are required.
  * Comments from which documentation is automatically generated are **not**
    subject to case-by-case decisions. Such comments are used, for example, on
    types and their members. Examples of tools which automatically generate
    documentation from such comments include JSDoc, Javadoc, Doxygen.
  * Comments which are not automatically processed are strongly encouraged. They
    are subject to case-by-case decisions. Such comments are often observed in
    function bodies.
 * Comments should be formatted as proper English sentences. Such formatting pays
  attention to, for example, capitalization and punctuation.
 ### Duplication
 * Don't copy-paste source code. Reuse it.
 ### Formatting
 * Line length is limited to 120 characters.
 * Sort by alphabetical order in order to make the addition of new entities as
  easy as looking a word up in a dictionary. Otherwise, one risks duplicate
  entries (with conflicting values in the cases of key-value pairs). For
  example:
  * Within an `import` of multiple names from a module, sort the names in
    alphabetical order. (Of course, the default name stays first as required by
    the `import` syntax.)
    ````javascript
    import {
        DOMINANT_SPEAKER_CHANGED,
        JITSI_CLIENT_CONNECTED,
        JITSI_CLIENT_CREATED,
        JITSI_CLIENT_DISCONNECTED,
        JITSI_CLIENT_ERROR,
        JITSI_CONFERENCE_JOINED,
        MODERATOR_CHANGED,
        PEER_JOINED,
        PEER_LEFT,
        RTC_ERROR
    } from './actionTypes';
    ````
  * Within a group of imports (e.g. groups of imports delimited by an empty line
    may be: third-party modules, then project modules, and eventually the
    private files of a module), sort the module names in alphabetical order.
    ````javascript
    import React, { Component } from 'react';
    import { connect } from 'react-redux';
    ````
 ### Indentation
 * Align `switch` and `case`/`default`. Don't indent the `case`/`default` more
  than its `switch`.
  ````javascript
  switch (i) {
  case 0:
      ...
      break;
  default:
      ...
  }
  ````
 ### Naming
 * An abstraction should have one name within the project and across multiple
  projects. For example:
  * The instance of lib-jitsi-meet's `JitsiConnection` type should be named
    `connection` or `jitsiConnection` in jitsi-meet, not `client`.
  * The class `ReducerRegistry` should be defined in ReducerRegistry.js and its
    imports in other files should use the same name. Don't define the class
    `Registry` in ReducerRegistry.js and then import it as `Reducers` in other
    files.
 * The names of global constants (including ES6 module-global constants) should
  be written in uppercase with underscores to separate words. For example,
  `BACKGROUND_COLOR`.
 * The underscore character at the beginning of a name signals that the
  respective variable, function, property is non-public i.e. private, protected,
  or internal. In contrast, the lack of an underscore at the beginning of a name
  signals public API.
--- a/doc/README.md
+++ b/doc/README.md
@ -1,47 +1,3 @@
 # Documentation
-This document is the entrypoint to different guides, divided in three groups:
+The Jitsi documentation has been moved to [The Handbook](https://jitsi.github.io/handbook/).
 * User guide: these documents are designed to help users of the service, to better
 understand all the available features and how to use them.
 * Developer guide: these documents are designed to help developers who want to either
 integrate the Jitsi Meet API / SDK in their products or want to improve Jitsi Meet
 itself by developing new features or fixing bugs.
 * DevOps guide: these documents are designed for DevOps folks, system administrators
 or anyone who wishes to deploy and operate their own Jitsi Meet instance.
 ## User guide
 Work in progress.
 ## Developer guides
 ### Web
 * [iframe API](https://github.com/jitsi/jitsi-meet/blob/master/doc/api.md)
 * [Jitsi Meet development](https://github.com/jitsi/jitsi-meet/blob/master/doc/development.md)
 ### Mobile
 * [Building the mobile apps](https://github.com/jitsi/jitsi-meet/blob/master/doc/mobile.md)
 * [SDK usage examples](https://github.com/jitsi/jitsi-meet-sdk-samples)
 * [Enabling Dropbox support](https://github.com/jitsi/jitsi-meet/blob/master/doc/mobile-dropbox.md)
 * [Enabling Google authentication](https://github.com/jitsi/jitsi-meet/blob/master/doc/mobile-google-auth.md)
 ## DevOps guides
 * [Quick install](https://github.com/jitsi/jitsi-meet/blob/master/doc/quick-install.md)
 * [Docker install](https://github.com/jitsi/docker-jitsi-meet/blob/master/README.md)
 * [Google Calendar, MS Calendar, Dropbox integrations](https://github.com/jitsi/jitsi-meet/blob/master/doc/integrations.md)
 * [Video: Installing Jitsi Meet on your own Linux Server](https://jitsi.org/news/new-tutorial-installing-jitsi-meet-on-your-own-linux-server/)
 * [Video: How to Load Balance Jitsi Meet](https://jitsi.org/blog/tutorial-video-how-to-load-balance-jitsi-meet/)
 * [Video: Scaling Jitsi Meet in the Cloud](https://jitsi.org/blog/new-tutorial-video-scaling-jitsi-meet-in-the-cloud/)
 * [Configuring a video SIP gateway](https://github.com/jitsi/jitsi-meet/blob/master/doc/sipgw-config.md)
 * [Enabling speaker stats](https://github.com/jitsi/jitsi-meet/blob/master/doc/speakerstats-prosody.md)
 * [Enabling TURN](https://github.com/jitsi/jitsi-meet/blob/master/doc/turn.md)
 * [Networking FAQ](https://github.com/jitsi/jitsi-meet/blob/master/doc/faq.md)
 * [Cloud APIs](https://github.com/jitsi/jitsi-meet/blob/master/doc/cloud-api.md)
 * [Manual Installation](https://github.com/jitsi/jitsi-meet/blob/master/doc/manual-install.md)
 * [Scalable Installation](https://github.com/jitsi/jitsi-meet/blob/master/doc/scalable-installation.md)
--- a/doc/api.md
+++ b/doc/api.md
@ -1,631 +1,3 @@
 # Jitsi Meet API
-You can use the Jitsi Meet API to embed Jitsi Meet in to your application. You are also welcome to use it for embedding the globally distributed and highly available deployment on meet.jit.si itself. The only thing we ask for in that case is that you please DO NOT remove the jitsi.org logo from the top left corner.
+This document has been moved [here](https://jitsi.github.io/handbook/docs/dev-guide/dev-guide-iframe).
 ## Installation
 To embed Jitsi Meet in your application you need to add the Jitsi Meet API library:
 ```javascript
 <script src='https://meet.jit.si/external_api.js'></script>
 ```
 ## API
 ### `api = new JitsiMeetExternalAPI(domain, options)`
 The next step for embedding Jitsi Meet is to create the Jitsi Meet API object.
 Its constructor gets a number of options:
 * **domain**: domain used to build the conference URL, 'meet.jit.si' for
  example.
 * **options**: object with properties - the optional arguments:
    * **roomName**: (optional) name of the room to join.
    * **width**: (optional) width for the iframe which will be created. If a number is specified it's treated as pixel units. If a string is specified the format is number followed by 'px', 'em', 'pt' or '%'.
    * **height**: (optional) height for the iframe which will be created. If a number is specified it's treated as pixel units. If a string is specified the format is number followed by 'px', 'em', 'pt' or '%'.
    * **parentNode**: (optional) HTML DOM Element where the iframe will be added as a child.
    * **configOverwrite**: (optional) JS object with overrides for options defined in [config.js].
    * **interfaceConfigOverwrite**: (optional) JS object with overrides for options defined in [interface_config.js].
    * **noSSL**: (optional, defaults to true) Boolean indicating if the server should be contacted using HTTP or HTTPS.
    * **jwt**: (optional) [JWT](https://jwt.io/) token.
    * **onload**: (optional) handler for the iframe onload event.
    * **invitees**: (optional) Array of objects containing information about new participants that will be invited in the call.
    * **devices**: (optional) A map containing information about the initial devices that will be used in the call.
    * **userInfo**: (optional) JS object containing information about the participant opening the meeting, such as `email`.
 Example:
 ```javascript
 const domain = 'meet.jit.si';
 const options = {
    roomName: 'JitsiMeetAPIExample',
    width: 700,
    height: 700,
    parentNode: document.querySelector('#meet')
 };
 const api = new JitsiMeetExternalAPI(domain, options);
 ```
 You can set the initial media devices for the call:
 ```javascript
 const domain = 'meet.jit.si';
 const options = {
    ...
    devices: {
        audioInput: '<deviceLabel>',
        audioOutput: '<deviceLabel>',
        videoInput: '<deviceLabel>'
    },
    ...
 };
 const api = new JitsiMeetExternalAPI(domain, options);
 ```
 You can overwrite options set in [config.js] and [interface_config.js].
 For example, to enable the filmstrip-only interface mode, you can use:
 ```javascript
 const options = {
    ...
    interfaceConfigOverwrite: { filmStripOnly: true },
    ...
 };
 const api = new JitsiMeetExternalAPI(domain, options);
 ```
 You can also pass a jwt token to Jitsi Meet:
 ```javascript
 const options = {
    ...
    jwt: '<jwt_token>',
    noSsl: false,
    ...
 };
 const api = new JitsiMeetExternalAPI(domain, options);
 ```
 You can set the userInfo(email, display name) for the call:
 ```javascript
 var domain = "meet.jit.si";
 var options = {
    ...
    userInfo: {
        email: 'email@jitsiexamplemail.com',
        displayName: 'John Doe'
    }
 }
 var api = new JitsiMeetExternalAPI(domain, options);
 ```
 ### Controlling the embedded Jitsi Meet Conference
 Device management `JitsiMeetExternalAPI` methods:
 * **getAvailableDevices** - Retrieve a list of available devices.
 ```javascript
 api.getAvailableDevices().then(devices => {
    // devices = {
    //     audioInput: [{
    //         deviceId: 'ID'
    //         groupId: 'grpID'
    //         kind: 'audioinput'
    //         label: 'label'
    //     },....],
    //     audioOutput: [{
    //         deviceId: 'ID'
    //         groupId: 'grpID'
    //         kind: 'audioOutput'
    //         label: 'label'
    //     },....],
    //     videoInput: [{
    //         deviceId: 'ID'
    //         groupId: 'grpID'
    //         kind: 'videoInput'
    //         label: 'label'
    //     },....]
    // }
    ...
 });
 ```
 * **getCurrentDevices** - Retrieve a list with the devices that are currently selected.
 ```javascript
 api.getCurrentDevices().then(devices => {
    // devices = {
    //     audioInput: {
    //         deviceId: 'ID'
    //         groupId: 'grpID'
    //         kind: 'videoInput'
    //         label: 'label'
    //     },
    //     audioOutput: {
    //         deviceId: 'ID'
    //         groupId: 'grpID'
    //         kind: 'videoInput'
    //         label: 'label'
    //     },
    //     videoInput: {
    //         deviceId: 'ID'
    //         groupId: 'grpID'
    //         kind: 'videoInput'
    //         label: 'label'
    //     }
    // }
    ...
 });
 ```
 * **isDeviceChangeAvailable** - Resolves with true if the device change is available and with false if not.
 ```javascript
 // The accepted deviceType values are - 'output', 'input' or undefined.
 api.isDeviceChangeAvailable(deviceType).then(isDeviceChangeAvailable => {
    ...
 });
 ```
 * **isDeviceListAvailable** - Resolves with true if the device list is available and with false if not.
 ```javascript
 api.isDeviceListAvailable().then(isDeviceListAvailable => {
    ...
 });
 ```
 * **isMultipleAudioInputSupported** - Resolves with true if multiple audio input is supported and with false if not.
 ```javascript
 api.isMultipleAudioInputSupported().then(isMultipleAudioInputSupported => {
    ...
 });
 ```
 * **setAudioInputDevice** - Sets the audio input device to the one with the label or id that is passed.
 ```javascript
 api.setAudioInputDevice(deviceLabel, deviceId);
 ```
 * **setAudioOutputDevice** - Sets the audio output device to the one with the label or id that is passed.
 ```javascript
 api.setAudioOutputDevice(deviceLabel, deviceId);
 ```
 * **setVideoInputDevice** - Sets the video input device to the one with the label or id that is passed.
 ```javascript
 api.setVideoInputDevice(deviceLabel, deviceId);
 ```
 You can control the embedded Jitsi Meet conference using the `JitsiMeetExternalAPI` object by using `executeCommand`:
 ```javascript
 api.executeCommand(command, ...arguments);
 ```
 The `command` parameter is String object with the name of the command. The following commands are currently supported:
 * **displayName** - Sets the display name of the local participant. This command requires one argument - the new display name to be set.
 ```javascript
 api.executeCommand('displayName', 'New Nickname');
 ```
 * **password** - Sets the password for the room. This command requires one argument - the password name to be set.
 ```javascript
 api.executeCommand('password', 'The Password');
 ```
 * **sendTones** - Play touch tones.
 ```javascript
 api.executeCommand('sendTones', {
    tones: string, // The dial pad touch tones to play. For example, '12345#'.
    duration: number, // Optional. The number of milliseconds each tone should play. The default is 200.
    pause: number // Optional. The number of milliseconds between each tone. The default is 200.
 });
 ```
 * **subject** - Sets the subject of the conference. This command requires one argument - the new subject to be set.
 ```javascript
 api.executeCommand('subject', 'New Conference Subject');
 ```
 * **toggleAudio** - Mutes / unmutes the audio for the local participant. No arguments are required.
 ```javascript
 api.executeCommand('toggleAudio');
 ```
 * **toggleVideo** - Mutes / unmutes the video for the local participant. No arguments are required.
 ```javascript
 api.executeCommand('toggleVideo');
 ```
 * **toggleFilmStrip** - Hides / shows the filmstrip. No arguments are required.
 ```javascript
 api.executeCommand('toggleFilmStrip');
 ```
 * **toggleChat** - Hides / shows the chat. No arguments are required.
 ```javascript
 api.executeCommand('toggleChat');
 ```
 * **toggleShareScreen** - Starts / stops screen sharing. No arguments are required.
 ```javascript
 api.executeCommand('toggleShareScreen');
 ```
 * **toggleTileView** - Enter / exit tile view layout mode. No arguments are required.
 ```javascript
 api.executeCommand('toggleTileView');
 ```
 * **hangup** - Hangups the call. No arguments are required.
 ```javascript
 api.executeCommand('hangup');
 ```
 * **email** - Changes the local email address. This command requires one argument - the new email address to be set.
 ```javascript
 api.executeCommand('email', 'example@example.com');
 ```
 * **avatarUrl** - Changes the local avatar URL. This command requires one argument - the new avatar URL to be set.
 ```javascript
 api.executeCommand('avatarUrl', 'https://avatars0.githubusercontent.com/u/3671647');
 ```
 * **sendEndpointTextMessage** - Sends a text message to another participant through the datachannels.
 ```javascript
 api.executeCommand('receiverParticipantId', 'text');
 ```
 * **setVideoQuality** - Sets the send and receive video resolution. This command requires one argument - the resolution height to be set.
 ```javascript
 api.executeCommand('setVideoQuality', 720);
 ```
 You can also execute multiple commands using the `executeCommands` method:
 ```javascript
 api.executeCommands(commands);
 ```
 The `commands` parameter is an object with the names of the commands as keys and the arguments for the commands as values:
 ```javascript
 api.executeCommands({
    displayName: [ 'nickname' ],
    toggleAudio: []
 });
 ```
 You can add event listeners to the embedded Jitsi Meet using the `addEventListener` method.
 **NOTE: This method still exists but it is deprecated. JitsiMeetExternalAPI class extends [EventEmitter]. Use [EventEmitter] methods (`addListener` or `on`).**
 ```javascript
 api.addEventListener(event, listener);
 ```
 The `event` parameter is a String object with the name of the event.
 The `listener` parameter is a Function object with one argument that will be notified when the event occurs with data related to the event.
 The following events are currently supported:
 * **cameraError** - event notifications about Jitsi-Meet having failed to access the camera. The listener will receive an object with the following structure:
 ```javascript
 {
    type: string, // A constant representing the overall type of the error.
    message: string // Additional information about the error.
 }
 ```
 * **avatarChanged** - event notifications about avatar
 changes. The listener will receive an object with the following structure:
 ```javascript
 {
    id: string, // the id of the participant that changed his avatar.
    avatarURL: string // the new avatar URL.
 }
 ```
 * **audioAvailabilityChanged** - event notifications about audio availability status changes. The listener will receive an object with the following structure:
 ```javascript
 {
    available: boolean // new available status - boolean
 }
 ```
 * **audioMuteStatusChanged** - event notifications about audio mute status changes. The listener will receive an object with the following structure:
 ```javascript
 {
    muted: boolean // new muted status - boolean
 }
 ```
 * **endpointTextMessageReceived** - event notifications about a text message received through datachannels.
 The listener will receive an object with the following structure:
 ```javascript
 {
    senderInfo: {
        jid: string, // the jid of the sender
        id: string // the participant id of the sender
    },
    eventData: {
        name: string // the name of the datachannel event: `endpoint-text-message`
        text: string // the received text from the sender
    }
 }
 ```
 * **micError** - event notifications about Jitsi-Meet having failed to access the mic. The listener will receive an object with the following structure:
 ```javascript
 {
    type: string, // A constant representing the overall type of the error.
    message: string // Additional information about the error.
 }
 ```
 * **screenSharingStatusChanged** - receives event notifications about turning on/off the local user screen sharing. The listener will receive object with the following structure:
 ```javascript
 {
    on: boolean, //whether screen sharing is on
    details: {
        // From where the screen sharing is capturing, if known. Values which are
        // passed include 'window', 'screen', 'proxy', 'device'. The value undefined
        // will be passed if the source type is unknown or screen share is off.
        sourceType: string|undefined
    }
 }
 ```
 * **dominantSpeakerChanged** - receives event notifications about change in the dominant speaker. The listener will receive object with the following structure:
 ```javascript
 {
    id: string //participantId of the new dominant speaker
 }
 ```
 * **tileViewChanged** - event notifications about tile view layout mode being entered or exited. The listener will receive object with the following structure:
 ```javascript
 {
    enabled: boolean, // whether tile view is not displayed or not
 }
 ```
 * **incomingMessage** - Event notifications about incoming
 messages. The listener will receive an object with the following structure:
 ```javascript
 {
    from: string, // The id of the user that sent the message
    nick: string, // the nickname of the user that sent the message
    message: string // the text of the message
 }
 ```
 * **outgoingMessage** - Event notifications about outgoing
 messages. The listener will receive an object with the following structure:
 ```javascript
 {
    message: string // the text of the message
 }
 ```
 * **displayNameChange** - event notifications about display name
 changes. The listener will receive an object with the following structure:
 ```javascript
 {
    id: string, // the id of the participant that changed his display name
    displayname: string // the new display name
 }
 ```
 * **deviceListChanged** - event notifications about device list changes. The listener will receive an object with the following structure:
 ```javascript
 {
    devices: Object // the new list of available devices.
 }
 ```
 NOTE: The devices object has the same format as the getAvailableDevices result format.
 * **emailChange** - event notifications about email
 changes. The listener will receive an object with the following structure:
 ```javascript
 {
    id: string, // the id of the participant that changed his email
    email: string // the new email
 }
 ```
 * **feedbackSubmitted** - event notifications about conference feedback submission
 ```javascript
 {
    error: string // The error which occurred during submission, if any.
 }
 ```
 * **filmstripDisplayChanged** - event notifications about the visibility of the filmstrip being updated.
 ```javascript
 {
    visible: boolean // Whether or not the filmstrip is displayed or hidden.
 }
 ```
 * **participantJoined** - event notifications about new participants who join the room. The listener will receive an object with the following structure:
 ```javascript
 {
    id: string, // the id of the participant
    displayName: string // the display name of the participant
 }
 ```
 * **participantKickedOut** - event notifications about a participants being removed from the room. The listener will receive an object with the following structure:
 ```javascript
 {
    kicked: {
        id: string, // the id of the participant removed from the room
        local: boolean // whether or not the participant is the local particiapnt
    },
    kicker: {
        id: string // the id of the participant who kicked out the other participant
    }
 }
 ```
 * **participantLeft** - event notifications about participants that leave the room. The listener will receive an object with the following structure:
 ```javascript
 {
    id: string // the id of the participant
 }
 ```
 * **participantRoleChanged** - event notification fired when the role of the local user has changed (none, moderator, participant). The listener will receive an object with the following structure:
 ```javascript
 {
    id: string // the id of the participant
    role: string // the new role of the participant
 }
 ```
 * **passwordRequired** - event notifications fired when failing to join a room because it has a password.
 * **videoConferenceJoined** - event notifications fired when the local user has joined the video conference. The listener will receive an object with the following structure:
 ```javascript
 {
    roomName: string, // the room name of the conference
    id: string, // the id of the local participant
    displayName: string, // the display name of the local participant
    avatarURL: string // the avatar URL of the local participant
 }
 ```
 * **videoConferenceLeft** - event notifications fired when the local user has left the video conference. The listener will receive an object with the following structure:
 ```javascript
 {
    roomName: string // the room name of the conference
 }
 ```
 * **videoAvailabilityChanged** - event notifications about video availability status changes. The listener will receive an object with the following structure:
 ```javascript
 {
    available: boolean // new available status - boolean
 }
 ```
 * **videoMuteStatusChanged** - event notifications about video mute status changes. The listener will receive an object with the following structure:
 ```javascript
 {
    muted: boolean // new muted status - boolean
 }
 ```
 * **readyToClose** - event notification fired when Jitsi Meet is ready to be closed (hangup operations are completed).
 * **subjectChange** - event notifications about subject of conference changes.
 The listener will receive an object with the following structure:
 ```javascript
 {
    subject: string // the new subject
 }
 ```
 * **suspendDetected** - event notifications about detecting suspend event in host computer.
 You can also add multiple event listeners by using `addEventListeners`.
 This method requires one argument of type Object. The object argument must
 have the names of the events as keys and the listeners of the events as values.
 **NOTE: This method still exists but it is deprecated. JitsiMeetExternalAPI class extends [EventEmitter]. Use [EventEmitter] methods.**
 ```javascript
 function incomingMessageListener(object)
 {
 // ...
 }
 function outgoingMessageListener(object)
 {
 // ...
 }
 api.addEventListeners({
    incomingMessage: incomingMessageListener,
    outgoingMessage: outgoingMessageListener
 });
 ```
 If you want to remove a listener you can use `removeEventListener` method with argument the name of the event.
 **NOTE: This method still exists but it is deprecated. JitsiMeetExternalAPI class extends [EventEmitter]. Use [EventEmitter] methods( `removeListener`).**
 ```javascript
 api.removeEventListener('incomingMessage');
 ```
 If you want to remove more than one event you can use `removeEventListeners` method with an Array with the names of the events as an argument.
 **NOTE: This method still exists but it is deprecated. JitsiMeetExternalAPI class extends [EventEmitter]. Use [EventEmitter] methods.**
 ```javascript
 api.removeEventListeners([ 'incomingMessage', 'outgoingMessageListener' ]);
 ```
 You can get the number of participants in the conference with the following API function:
 ```javascript
 const numberOfParticipants = api.getNumberOfParticipants();
 ```
 You can get the avatar URL of a participant in the conference with the following API function:
 ```javascript
 const avatarURL = api.getAvatarURL(participantId);
 ```
 You can get the display name of a participant in the conference with the following API function:
 ```javascript
 const displayName = api.getDisplayName(participantId);
 ```
 You can get the email of a participant in the conference with the following API function:
 ```javascript
 const email = api.getEmail(participantId);
 ```
 You can get the iframe HTML element where Jitsi Meet is loaded with the following API function:
 ```javascript
 const iframe = api.getIFrame();
 ```
 You can check whether the audio is muted with the following API function:
 ```javascript
 api.isAudioMuted().then(muted => {
    ...
 });
 ```
 You can check whether the video is muted with the following API function:
 ```javascript
 api.isVideoMuted().then(muted => {
    ...
 });
 ```
 You can check whether the audio is available with the following API function:
 ```javascript
 api.isAudioAvailable().then(available => {
    ...
 });
 ```
 You can check whether the video is available with the following API function:
 ```javascript
 api.isVideoAvailable().then(available => {
    ...
 });
 ```
 You can invite new participants to the call with the following API function:
 ```javascript
 api.invite([ {...}, {...}, {...} ]).then(() => {
    // success
 }).catch(() => {
    // failure
 });
 ```
 **NOTE: The format of the invitees in the array depends on the invite service used for the deployment.**
 You can remove the embedded Jitsi Meet Conference with the following API function:
 ```javascript
 api.dispose();
 ```
 NOTE: It's a good practice to remove the conference before the page is unloaded.
 [config.js]: https://github.com/jitsi/jitsi-meet/blob/master/config.js
 [interface_config.js]: https://github.com/jitsi/jitsi-meet/blob/master/interface_config.js
 [EventEmitter]: https://nodejs.org/api/events.html
--- a/doc/cloud-api.md
+++ b/doc/cloud-api.md
@ -1,5 +0,0 @@
 # Jitsi Meet Cloud API
 The Jitsi Meet Cloud API is a specification for services which can support the integration of Jitsi Meet into other applications, for mapping conferences for dial-in support, and for supporting directory search and user invitations to conferences.
 The swagger for these services is provided in [cloud-api.swagger](cloud-api.swagger) in this same repository and directory.
--- a/doc/coding-style.md
+++ b/doc/coding-style.md
@ -1,93 +0,0 @@
 # Comments
 * Comments documenting the source code are required.
  * Comments from which documentation is automatically generated are **not**
    subject to case-by-case decisions. Such comments are used, for example, on
    types and their members. Examples of tools which automatically generate
    documentation from such comments include JSDoc, Javadoc, Doxygen.
  * Comments which are not automatically processed are strongly encouraged. They
    are subject to case-by-case decisions. Such comments are often observed in
    function bodies.
 * Comments should be formatted as proper English sentences. Such formatting pays
  attention to, for example, capitalization and punctuation.
 # Duplication
 * Don't copy-paste source code. Reuse it.
 # Formatting
 * Line length is limited to 80 characters.
 * Sort by alphabetical order in order to make the addition of new entities as
  easy as looking a word up in a dictionary. Otherwise, one risks duplicate
  entries (with conflicting values in the cases of key-value pairs). For
  example:
  * Within an `import` of multiple names from a module, sort the names in
    alphabetical order. (Of course, the default name stays first as required by
    the `import` syntax.)
    ````javascript
    import {
        DOMINANT_SPEAKER_CHANGED,
        JITSI_CLIENT_CONNECTED,
        JITSI_CLIENT_CREATED,
        JITSI_CLIENT_DISCONNECTED,
        JITSI_CLIENT_ERROR,
        JITSI_CONFERENCE_JOINED,
        MODERATOR_CHANGED,
        PEER_JOINED,
        PEER_LEFT,
        RTC_ERROR
    } from './actionTypes';
    ````
  * Within a group of imports (e.g. groups of imports delimited by an empty line
    may be: third-party modules, then project modules, and eventually the
    private files of a module), sort the module names in alphabetical order.
    ````javascript
    import React, { Component } from 'react';
    import { connect } from 'react-redux';
    ````
 # Indentation
 * Align `switch` and `case`/`default`. Don't indent the `case`/`default` more
  than its `switch`.
  ````javascript
  switch (i) {
  case 0:
      ...
      break;
  default:
      ...
  }
  ````
 # Naming
 * An abstraction should have one name within the project and across multiple
  projects. For example:
  * The instance of lib-jitsi-meet's `JitsiConnection` type should be named
    `connection` or `jitsiConnection` in jitsi-meet, not `client`.
  * The class `ReducerRegistry` should be defined in ReducerRegistry.js and its
    imports in other files should use the same name. Don't define the class
    `Registry` in ReducerRegistry.js and then import it as `Reducers` in other
    files.
 * The names of global constants (including ES6 module-global constants) should
  be written in uppercase with underscores to separate words. For example,
  `BACKGROUND_COLOR`.
 * The underscore character at the beginning of a name signals that the
  respective variable, function, property is non-public i.e. private, protected,
  or internal. In contrast, the lack of an underscore at the beginning of a name
  signals public API.
--- a/doc/development.md
+++ b/doc/development.md
@ -1,82 +0,0 @@
 # Developing Jitsi Meet
 ## Building the sources
 Node.js >= 12 and npm >= 6 are required.
 On Debian/Ubuntu systems, the required packages can be installed with:
 ```
 sudo apt-get install npm nodejs
 cd jitsi-meet
 npm install
 ```
 To build the Jitsi Meet application, just type
 ```
 make
 ```
 ### Working with the library sources (lib-jitsi-meet)
 By default the library is build from its git repository sources. The default dependency path in package.json is :
 ```json
 "lib-jitsi-meet": "jitsi/lib-jitsi-meet",
 ```
 To work with local copy you must change the path to:
 ```json
 "lib-jitsi-meet": "file:///Users/name/local-lib-jitsi-meet-copy",
 ```
 To make the project you must force it to take the sources as 'npm update':
 ```
 npm install lib-jitsi-meet --force && make
 ```
 Or if you are making only changes to the library:
 ```
 npm install lib-jitsi-meet --force && make deploy-lib-jitsi-meet
 ```
 Alternative way is to use [npm link](https://docs.npmjs.com/cli/link).
 It allows to link `lib-jitsi-meet` dependency to local source in few steps:
 ```bash
 cd lib-jitsi-meet
 #### create global symlink for lib-jitsi-meet package
 npm link
 cd ../jitsi-meet
 #### create symlink from the local node_modules folder to the global lib-jitsi-meet symlink
 npm link lib-jitsi-meet
 ```
 After changes in local `lib-jitsi-meet` repository, you can rebuild it with `npm run install` and your `jitsi-meet` repository will use that modified library.
 Note: when using node version 4.x, the make file of jitsi-meet do npm update which will delete the link. It is no longer the case with version 6.x.
 If you do not want to use local repository anymore you should run
 ```bash
 cd jitsi-meet
 npm unlink lib-jitsi-meet
 npm install
 ```
 ### Running with webpack-dev-server for development
 Use it at the CLI, type
 ```
 make dev
 ```
 By default the backend deployment used is `alpha.jitsi.net`. You can point the Jitsi-Meet app at a different backend by using a proxy server. To do this, set the WEBPACK_DEV_SERVER_PROXY_TARGET variable:
 ```
 export WEBPACK_DEV_SERVER_PROXY_TARGET=https://your-example-server.com
 make dev
 ```
 The app should be running at https://localhost:8080/
 #### Chrome Privacy Error
 Newer versions of Chrome may block localhost under https and show `NET::ERR_CERT_INVALID` on the page. To solve this open [chrome://flags/#allow-insecure-localhost](chrome://flags/#allow-insecure-localhost) and select Enable, then press Relaunch or quit and restart Chrome.
--- a/doc/faq.md
+++ b/doc/faq.md
@ -1,7 +0,0 @@
 **1. How to tell if my server instance is behind NAT?**
 A. In general, if the tool ifconfig (or ipconfig) shows the assigned IP address to be some local address (10.x.x.x or 192.x.x.x) but you know that its public IP address is different from that, the server is most probably behind NAT
 **2. Clients could communicate well in room created at meet.jit.si . The same clients still could connect to my self-hosted instance but can neither hear nor see one another. What's wrong?**
 A. Most probably, the server is behind NAT. See this [resolved question](https://community.jitsi.org/t/cannot-see-video-or-hear-audio-on-self-hosted-instance/). You need to follow the steps detailed [here](https://github.com/jitsi/jitsi-meet/blob/master/doc/quick-install.md#Advanced-configuration)
--- a/doc/integrations.md
+++ b/doc/integrations.md
@ -1,38 +0,0 @@
 Document describing enabling various jitsi-meet integrations.
 ## Creating the Google API client for Google Calendar and Youtube integration
 1. Log into a Google admin account.
 1. Go to Google cloud platform dashboard. https://console.cloud.google.com/apis/dashboard
 1. In the Select a Project dropdown, click New Project.
 1. Give the project a name.
 1. Proceed to the Credentials settings of the new project.
 1. In the Credentials tab of the Credentials settings, click Create Credentials and select the type OAuth client ID.
 1. Proceed with creating a Web application and add the domains (origins) on which the application will be hosted. Local development environments (http://localhost:8000 for example) can be added here.
 1. While still in the Google cloud platform dashboard, click the Library settings for the calendar project.
 1. Search for the Google Calendar API (used for calendar accessing), click its result, and enable it.
 1. Do the same for YouTube Data API v3
 ## Creating the Microsoft app for Microsoft Outlook integration
 1. Go to https://apps.dev.microsoft.com/
 1. Proceed through the "Add an app" flow. Once created, a page with several Graph Permissions fields should display.
 1. Under "Platforms" add "Web"
 1. Add a redirect URL for the Microsoft auth flow to visit once a user has confirmed authentication. Target domain if available is just 'yourdomain.com' (the deployment address) and the redirect URL is `https://yourdomain.com/static/msredirect.html`.
 1. Add Microsoft Graph delegated permissions, if this option is available: Calendars.Read, Calendars.ReadWrite, Calendars.Read.Shared, Calendars.ReadWrite.Shared.
 1. Check `Allow Implicit Flow` (and `Restrict token issuing to this app` if available).
 1. Save the changes.
 ## Creating the Dropbox app for Dropbox recording integration
 1. You need a Dropbox account (If you don't already have one, you can sign up for a free account [here](https://www.dropbox.com/register).)
 1. Create new App as described in [Getting Started Guide](https://www.dropbox.com/developers/reference/getting-started?_tk=guides_lp&_ad=guides2&_camp=get_started#app%20console) in App Console section.
 1. Choose
    1. 'Dropbox API - For apps that need to access files in Dropbox.' 
    1. 'App folder– Access to a single folder created specifically for your app.'
    1. Fill in the name of your app
 1. You need only, the newly created App key, goes in config.js in 
    ```
        dropbox: {
            appKey: '__dropbox_app_key__'
        }
    ```
 1. Add your Redirect URIs in the form `https://yourdeployment.com//static/oauth.html`
 1. Fill in Branding
--- a/doc/manual-install.md
+++ b/doc/manual-install.md
@ -1,270 +0,0 @@
 # Server Installation for Jitsi Meet
 :warning: **WARNING:** Manual installation is not recommended. We recommend following the [quick-install](https://github.com/jitsi/jitsi-meet/blob/master/doc/quick-install.md) document. The current document describes the steps that are needed to install a working deployment, but steps are easy to mess up, and the debian packages are more up-to-date, where this document is sometimes not updated to reflect latest changes.
 This describes configuring a server `jitsi.example.com` running Debian or a Debian Derivative. You will need to
 change references to that to match your host, and generate some passwords for
 `YOURSECRET1`, `YOURSECRET2` and `YOURSECRET3`.
 There are also some complete [example config files](https://github.com/jitsi/jitsi-meet/tree/master/doc/example-config-files/) available, mentioned in each section.
 There are additional configurations to be done for a [scalable installation](https://github.com/jitsi/jitsi-meet/tree/master/doc/scalable-installation.md)
 ## Network description
 This is how the network looks:
 ```
                   +                           +
                   |                           |
                   |                           |
                   v                           |
                  443                          |
               +-------+                       |
               |       |                       |
               | Nginx |                       |
               |       |                       |
               +--+-+--+                       |
                  | |                          |
 +------------+    | |    +--------------+      |
 |            |    | |    |              |      |
 | jitsi-meet +<---+ +--->+ prosody/xmpp |      |
 |            |files 5280 |              |      |
 +------------+           +--------------+      v
                     5222,5347^    ^5347   4443,10000
                +--------+    |    |    +-------------+
                |        |    |    |    |             |
                | jicofo +----^    ^----+ videobridge |
                |        |              |             |
                +--------+              +-------------+
 ```
 ## Install prosody
 ```sh
 apt-get install prosody
 ```
 ## Configure prosody
 Add config file in `/etc/prosody/conf.avail/jitsi.example.com.cfg.lua` :
 - add your domain virtual host section:
 ```
 VirtualHost "jitsi.example.com"
    authentication = "anonymous"
    ssl = {
        key = "/var/lib/prosody/jitsi.example.com.key";
        certificate = "/var/lib/prosody/jitsi.example.com.crt";
    }
    modules_enabled = {
        "bosh";
        "pubsub";
    }
    c2s_require_encryption = false
 ```
 - add domain with authentication for conference focus user:
 ```
 VirtualHost "auth.jitsi.example.com"
    ssl = {
        key = "/var/lib/prosody/auth.jitsi.example.com.key";
        certificate = "/var/lib/prosody/auth.jitsi.example.com.crt";
    }
    authentication = "internal_plain"
 ```
 - add focus user to server admins:
 ```
 admins = { "focus@auth.jitsi.example.com" }
 ```
 - and finally configure components:
 ```
 Component "conference.jitsi.example.com" "muc"
 Component "jitsi-videobridge.jitsi.example.com"
    component_secret = "YOURSECRET1"
 Component "focus.jitsi.example.com"
    component_secret = "YOURSECRET2"
 ```
 Add link for the added configuration
 ```sh
 ln -s /etc/prosody/conf.avail/jitsi.example.com.cfg.lua /etc/prosody/conf.d/jitsi.example.com.cfg.lua
 ```
 Generate certs for the domain:
 ```sh
 prosodyctl cert generate jitsi.example.com
 prosodyctl cert generate auth.jitsi.example.com
 ```
 Add auth.jitsi.example.com to the trusted certificates on the local machine:
 ```sh
 ln -sf /var/lib/prosody/auth.jitsi.example.com.crt /usr/local/share/ca-certificates/auth.jitsi.example.com.crt
 update-ca-certificates -f
 ```
 Note that the `-f` flag is necessary if there are symlinks left from a previous installation.
 Create conference focus user:
 ```sh
 prosodyctl register focus auth.jitsi.example.com YOURSECRET3
 ```
 Restart prosody XMPP server with the new config
 ```sh
 prosodyctl restart
 ```
 ## Install Nginx
 ```sh
 apt-get install nginx
 ```
 Add a new file `jitsi.example.com` in `/etc/nginx/sites-available` (see also the example config file):
 ```
 server_names_hash_bucket_size 64;
 server {
    listen 0.0.0.0:443 ssl http2;
    listen [::]:443 ssl http2;
    # tls configuration that is not covered in this guide
    # we recommend the use of https://certbot.eff.org/
    server_name jitsi.example.com;
    # set the root
    root /srv/jitsi-meet;
    index index.html;
    location ~ ^/([a-zA-Z0-9=\?]+)$ {
        rewrite ^/(.*)$ / break;
    }
    location / {
        ssi on;
    }
    # BOSH, Bidirectional-streams Over Synchronous HTTP
    # https://en.wikipedia.org/wiki/BOSH_(protocol)
    location /http-bind {
        proxy_pass      http://localhost:5280/http-bind;
        proxy_set_header X-Forwarded-For $remote_addr;
        proxy_set_header Host $http_host;
    }
    # external_api.js must be accessible from the root of the
    # installation for the electron version of Jitsi Meet to work
    # https://github.com/jitsi/jitsi-meet-electron
    location /external_api.js {
        alias /srv/jitsi-meet/libs/external_api.min.js;
    }
 }
 ```
 Add link for the added configuration
 ```sh
 cd /etc/nginx/sites-enabled
 ln -s ../sites-available/jitsi.example.com jitsi.example.com
 ```
 ## Install Jitsi Videobridge
 Visit https://download.jitsi.org/jitsi-videobridge/linux to determine the current build number, download and unzip it:
 ```sh
 wget https://download.jitsi.org/jitsi-videobridge/linux/jitsi-videobridge-linux-{arch-buildnum}.zip
 unzip jitsi-videobridge-linux-{arch-buildnum}.zip
 ```
 Install JRE if missing:
 ```
 apt-get install openjdk-8-jre
 ```
 _NOTE: When installing on older Debian releases keep in mind that you need JRE >= 1.7._
 Create `~/.sip-communicator/sip-communicator.properties` in the home folder of the user that will be starting Jitsi Videobridge:
 ```sh
 mkdir -p ~/.sip-communicator
 cat > ~/.sip-communicator/sip-communicator.properties << EOF
 org.jitsi.impl.neomedia.transform.srtp.SRTPCryptoContext.checkReplay=false
 # The videobridge uses 443 by default with 4443 as a fallback, but since we're already
 # running nginx on 443 in this example doc, we specify 4443 manually to avoid a race condition
 org.jitsi.videobridge.TCP_HARVESTER_PORT=4443
 EOF
 ```
 Start the videobridge with:
 ```sh
 ./jvb.sh --host=localhost --domain=jitsi.example.com --port=5347 --secret=YOURSECRET1 &
 ```
 Or autostart it by adding the line in `/etc/rc.local`:
 ```sh
 /bin/bash /root/jitsi-videobridge-linux-{arch-buildnum}/jvb.sh --host=localhost --domain=jitsi.example.com --port=5347 --secret=YOURSECRET1 </dev/null >> /var/log/jvb.log 2>&1
 ```
 ## Install Jitsi Conference Focus (jicofo)
 Install JDK and Maven if missing:
 ```
 apt-get install openjdk-8-jdk maven
 ```
 _NOTE: When installing on older Debian releases keep in mind that you need JDK >= 1.7._
 Clone source from Github repo:
 ```sh
 git clone https://github.com/jitsi/jicofo.git
 ```
 Build the package.
 ```sh
 cd jicofo
 mvn package -DskipTests -Dassembly.skipAssembly=false
 ```
 Run jicofo:
 ```sh
 =======
 unzip target/jicofo-1.1-SNAPSHOT-archive.zip
 cd jicofo-1.1-SNAPSHOT-archive'
 ./jicofo.sh --host=localhost --domain=jitsi.example.com --secret=YOURSECRET2 --user_domain=auth.jitsi.example.com --user_name=focus --user_password=YOURSECRET3
 ```
 ## Deploy Jitsi Meet
 Checkout and configure Jitsi Meet:
 ```sh
 cd /srv
 git clone https://github.com/jitsi/jitsi-meet.git
 cd jitsi-meet
 npm install
 make
 ```
 _NOTE: When installing on older distributions keep in mind that you need Node.js >= 12 and npm >= 6._
 Edit host names in `/srv/jitsi-meet/config.js` (see also the example config file):
 ```
 var config = {
    hosts: {
        domain: 'jitsi.example.com',
        muc: 'conference.jitsi.example.com',
        bridge: 'jitsi-videobridge.jitsi.example.com',
        focus: 'focus.jitsi.example.com'
    },
    useNicks: false,
    bosh: '//jitsi.example.com/http-bind', // FIXME: use xep-0156 for that
    //chromeExtensionId: 'diibjkoicjeejcmhdnailmkgecihlobk', // Id of desktop streamer Chrome extension
    //minChromeExtVersion: '0.1' // Required version of Chrome extension
 };
 ```
 Verify that nginx config is valid and reload nginx:
 ```sh
 nginx -t && nginx -s reload
 ```
 ## Running behind NAT
 Jitsi Videobridge can run behind a NAT, provided that both required ports are routed (forwarded) to the machine that it runs on. By default these ports are `TCP/4443` and `UDP/10000`.
 If you do not route these two ports, Jitsi Meet will only work with video for two people, breaking upon 3 or more people trying to show video.
 `TCP/443` is required for the webserver which can be running on another machine than the Jitsi Videobrige is running on.
 The following extra lines need to be added to the file `~/.sip-communicator/sip-communicator.properties` (in the home directory of the user running the videobridge):
 ```
 org.ice4j.ice.harvest.NAT_HARVESTER_LOCAL_ADDRESS=<Local.IP.Address>
 org.ice4j.ice.harvest.NAT_HARVESTER_PUBLIC_ADDRESS=<Public.IP.Address>
 ```
 # Hold your first conference
 You are now all set and ready to have your first meet by going to http://jitsi.example.com
 ## Enabling recording
 [Jibri](https://github.com/jitsi/jibri) is a set of tools for recording and/or streaming a Jitsi Meet conference.
--- a/doc/mobile-dropbox.md
+++ b/doc/mobile-dropbox.md
@ -1,28 +0,0 @@
 # Setting up Dropbox integration
 1. Create a Dropbox app.
 2. Add the following to ```ios/app/src/Info.plist``` by replacing `<APP_KEY>`
   with your own Dropbox app key (which can be found in the
   [App Console](https://www.dropbox.com/developers/apps)):
 ```
 <key>CFBundleURLTypes</key>
 <array>
  <dict>
    <key>CFBundleURLName</key>
    <string></string>
    <key>CFBundleURLSchemes</key>
    <array>
      <string>db-<APP_KEY></string>
    </array>
  </dict>
 </array>
 <key>LSApplicationQueriesSchemes</key>
 <array>
  <string>dbapi-2</string>
  <string>dbapi-8-emm</string>
 </array>
 ```
 **NOTE:** Both Android and iOS builds of the apps will parse the Dropbox app key
 from ```ios/app/src/Info.plist```.
 **NOTE:** See [Dropbox developer guide](https://www.dropbox.com/developers/reference/developer-guide) for more information
--- a/doc/mobile-google-auth.md
+++ b/doc/mobile-google-auth.md
@ -1,22 +0,0 @@
 # Setting up Google Authentication
 - Create a Firebase project here: https://firebase.google.com/. You'll need a
 signed Android build for that, that can be a debug self-signed build too, just
 retrieve the signing hash. The key hash of an already signed ap can be obtained
 as follows (on macOS): ```keytool -list -printcert -jarfile the-app.apk```
 - Place the generated ```google-services.json``` file in ```android/app```
 for Android and the ```GoogleService-Info.plist``` into ```ios/app``` for
 iOS (you can stop at that step, no need for the driver and the code changes they
 suggest in the wizard).
 - You may want to exclude these files in YOUR GIT config (do not exclude them in
 the ```.gitignore``` of the application itself!).
 - Your web client ID is auto generated during the Firebase project
 creation. Find them in the Google Developer console
 (https://console.developers.google.com/)
 - Make sure your config reflects this ID by setting
 ```googleApiApplicationClientID``` in config.js.
 - Add your iOS client ID (the REVERSED_CLIENT_ID in the plist file) as an
 application URL schema into ```ios/app/src/Info.plist```
 (replacing placeholder).
 - Enable YouTube API access on the developer console (see above) to enable live
 streaming.
--- a/doc/mobile.md
+++ b/doc/mobile.md
@ -1,109 +0,0 @@
 # Jitsi Meet apps for Android and iOS
 Jitsi Meet can be built as a standalone app for Android or iOS. It uses the
 [React Native] framework.
 **If you want to rebuild the SDK yourself look in [Android README] or [iOS README].**
 First make sure the [React Native dependencies] are installed.
 **NOTE**: This document assumes the app is being built on a macOS system. GNU/Linux is also
 supported for building the Android app and Windows **is not supported at alll**.
 **NOTE**: Node 12.X and npm 6.X are recommended for building.
 ## iOS
 1. Install some extra dependencies
  - Install ios-deploy globally (in case you want to use the React Native CLI
    to deploy the app to the device)
    ```bash
    npm install -g ios-deploy
    ```
  - Install main dependencies:
    ```bash
    npm install
    ```
  - Install the required pods (CocoaPods must be installled first, it can
    be done with Homebrew: `brew install cocoapods`)
    ```bash
    cd ios
    pod install
    cd ..
    ```
 2. Build the app
    There are 2 ways to build the app: using the CLI or using Xcode.
    Using the CLI:
    ```bash
    react-native run-ios --device
    ```
    When the app is launched from the CLI the output can be checked with the
    following command:
    ```bash
    react-native log-ios
    ```
    Using Xcode
    - Open **ios/jitsi-meet.xcworkspace** in Xcode. Make sure it's the workspace
      file!
    - Select your device from the top bar and hit the "play" button.
    When the app is launched from Xcode the Debug console will show the output
    logs the application creates.
 3. Other remarks
    It's likely you'll need to change the bundle ID for deploying to a device.
    This can be changed in the "General" tab.  Under "Identity" set
    "Bundle Identifier" to a different value, and adjust the "Team" in the
    "Signing" section to match your own.
 ## Android
 The [React Native dependencies] page has very detailed information on how to
 setup [Android Studio] and the required components for getting the necessary
 build environment.  Make sure you follow it closely.
 1. Building the app
    The app can be built using the CLI utility as follows:
    ```bash
    react-native run-android
    ```
    It will be launched on the connected Android device.
 ## Debugging
 The official documentation on [debugging] is quite extensive and specifies the
 preferred method for debugging.
 **NOTE**: When using Chrome Developer Tools for debugging the JavaScript source
 code is being interpreted by Chrome's V8 engine, instead of JSCore which React
 Native uses. It's important to keep this in mind due to potential differences in
 supported JavaScript features.
 [Android README]: https://github.com/jitsi/jitsi-meet/blob/master/android/README.md
 [iOS README]: https://github.com/jitsi/jitsi-meet/blob/master/ios/README.md
 [Android Studio]: https://developer.android.com/studio/index.html
 [debugging]: https://facebook.github.io/react-native/docs/debugging.html
 [React Native]: https://facebook.github.io/react-native/
 [React Native dependencies]: https://facebook.github.io/react-native/docs/getting-started.html#installing-dependencies
--- a/doc/quick-install.md
+++ b/doc/quick-install.md
@ -1,162 +1,3 @@
 # Jitsi Meet quick install
-This guide helps you  ___host your own Jitsi server___. If you want to have a video conference without setting up any infrastructure, use https://meet.jit.si instead.
+This document has been moved [here](https://jitsi.github.io/handbook/docs/devops-guide/devops-guide-quickstart).
 This document describes the required steps for a quick Jitsi Meet installation on a Debian based GNU/Linux system. Debian 9 (Stretch) or later, and Ubuntu 18.04 (Bionic Beaver) or later are supported out-of-the-box.
 On Ubuntu systems, Jitsi requires dependencies from Ubuntu's `universe` package repository.  To ensure this is enabled, run `apt-add-repository universe` at the command-line.
 _Note_: Many of the installation steps require elevated privileges. If you are logged in using a regular user account, you may need to temporarily increase your permissions (for example, by using `sudo` for individual commands).
 ## Basic Jitsi Meet install
 ### Set up the Fully Qualified Domain Name (FQDN) (optional)
 If the machine used to host the Jitsi Meet instance has a FQDN (for example `meet.example.org`) already set up in DNS, `/etc/hostname` must contain this FQDN; if this is not the case yet, [change the hostname](https://wiki.debian.org/HowTo/ChangeHostname).
 Then add the same FQDN in the `/etc/hosts` file, associating it with the loopback address:
    127.0.0.1 localhost meet.example.org
 Finally on the same machine test that you can ping the FQDN with: `ping "$(hostname)"`-
 ### Add the Jitsi package repository
 ```sh
 echo 'deb https://download.jitsi.org stable/' | sudo tee /etc/apt/sources.list.d/jitsi-stable.list
 wget -qO -  https://download.jitsi.org/jitsi-key.gpg.key | sudo apt-key add -
 ```
 ### Open ports in your firewall
 Open the following ports in your firewall, to allow traffic to the machine running jitsi:
 - 80 TCP
 - 443 TCP
 - 10000 UDP
 ### Install Jitsi Meet
 _Note_: The installer will check if [Nginx](https://nginx.org/) or [Apache](https://httpd.apache.org/) is present (in that order) and configure a virtualhost within the web server it finds to serve Jitsi Meet. If none of the above is found it then defaults to Nginx.
 If you are already running Nginx on port 443 on the same machine turnserver configuration will be skipped as it will conflict with your current port 443.
 ```sh
 # Ensure support is available for apt repositories served via HTTPS
 sudo apt install apt-transport-https
 # Retrieve the latest package versions across all repositories
 sudo apt update
 # Perform jitsi-meet installation
 sudo apt install jitsi-meet
 ```
 During the installation, you will be asked to enter the hostname of the Jitsi Meet instance. If you have a [FQDN](https://en.wikipedia.org/wiki/Fully_qualified_domain_name) for the instance already set up in DNS, enter it there. If you don't have a resolvable hostname, you can enter the IP address of the machine (if it is static or doesn't change).
 This hostname (or IP address) will be used for virtualhost configuration inside the Jitsi Meet and also, you and your correspondents will be using it to access the web conferences.
 ### Generate a Let's Encrypt certificate (optional, recommended)
 In order to have encrypted communications, you need a [TLS certificate](https://en.wikipedia.org/wiki/Transport_Layer_Security). The easiest way is to use [Let's Encrypt](https://letsencrypt.org/).
 _Note_: Jitsi Meet mobile apps *require* a valid certificate signed by a trusted [Certificate Authority](https://en.wikipedia.org/wiki/Certificate_authority) (such as a Let's Encrypt certificate) and will not be able to connect to your server if you choose a self-signed certificate.
 Simply run the following in your shell:
 ```sh
 sudo /usr/share/jitsi-meet/scripts/install-letsencrypt-cert.sh
 ```
 Note that this script uses the [HTTP-01 challenge type](https://letsencrypt.org/docs/challenge-types/) and thus your instance needs to be accessible from the public internet. If you want to use a different challenge type, don't use this script and instead choose ___I want to use my own certificate___ during jitsi-meet installation.
 #### Advanced configuration
 If the installation is on a machine [behind NAT](https://github.com/jitsi/jitsi-meet/blob/master/doc/faq.md) jitsi-videobridge should configure itself automatically on boot. If three way call does not work further configuration of jitsi-videobridge is needed in order for it to be accessible from outside.
 Provided that all required ports are routed (forwarded) to the machine that it runs on. By default these ports are (TCP/443 or TCP/4443 and UDP/10000).
 The following extra lines need to be added to the file `/etc/jitsi/videobridge/sip-communicator.properties`:
 ```
 org.ice4j.ice.harvest.NAT_HARVESTER_LOCAL_ADDRESS=<Local.IP.Address>
 org.ice4j.ice.harvest.NAT_HARVESTER_PUBLIC_ADDRESS=<Public.IP.Address>
 ```
 And comment the existing `org.ice4j.ice.harvest.STUN_MAPPING_HARVESTER_ADDRESSES`.
 See [the documentation of ice4j](https://github.com/jitsi/ice4j/blob/master/doc/configuration.md)
 for details.
 Default deployments on systems using systemd will have low default values for maximum processes and open files. If the used bridge will expect higher number of participants the default values need to be adjusted (the default values are good for less than 100 participants).
 To update the values edit `/etc/systemd/system.conf` and make sure you have the following values if values are smaller, if not do not update.
 ```
 DefaultLimitNOFILE=65000
 DefaultLimitNPROC=65000
 DefaultTasksMax=65000
 ```
 To check values just run :
 ```
 systemctl show --property DefaultLimitNPROC
 systemctl show --property DefaultLimitNOFILE
 systemctl show --property DefaultTasksMax
 ```
 To load the values and check them look [here](#systemd-details) for details.
 By default, anyone who has access to your jitsi instance will be able to start a conference: if your server is open to the world, anyone can have a chat with anyone else. If you want to limit the ability to start a conference to registered users, set up a "secure domain". Follow the instructions at https://github.com/jitsi/jicofo#secure-domain.
 ### Confirm that your installation is working
 Launch a web browser (Chrome, Chromium or latest Opera) and enter the hostname or IP address from the previous step into the address bar.
 If you used a self-signed certificate (as opposed to using Let's Encrypt), your web browser will ask you to confirm that you trust the certificate.
 You should see a web page prompting you to create a new meeting.  Make sure that you can successfully create a meeting and that other participants are able to join the session.
 If this all worked, then congratulations!  You have an operational Jitsi conference service.
 ## Adding sip-gateway to Jitsi Meet
 ### Install Jigasi
 Jigasi is a server-side application acting as a gateway to Jitsi Meet conferences. It allows regular [SIP](https://en.wikipedia.org/wiki/Session_Initiation_Protocol) clients to join meetings and provides transcription capabilities.
 ```sh
 sudo apt install jigasi
 ```
 During the installation, you will be asked to enter your SIP account and password. This account will be used to invite the other SIP participants.
 ### Reload Jitsi Meet
 Launch again a browser with the Jitsi Meet URL and you'll see a telephone icon on the right end of the toolbar. Use it to invite SIP accounts to join the current conference.
 Enjoy!
 ## Uninstall
 ```sh
 sudo apt purge jigasi jitsi-meet jitsi-meet-web-config jitsi-meet-prosody jitsi-meet-turnserver jitsi-meet-web jicofo jitsi-videobridge2
 ```
 Sometimes the following packages will fail to uninstall properly:
 - jigasi
 - jitsi-videobridge
 When this happens, just run the uninstall command a second time and it should be ok.
 The reason for the failure is that sometimes the uninstall script is faster than the process that stops the daemons. The second run of the uninstall command fixes this, as by then the jigasi or jitsi-videobridge daemons are already stopped.
 #### Systemd details
 To reload the systemd changes on a running system execute `sudo systemctl daemon-reload` and `sudo systemctl restart jitsi-videobridge2`.
 To check the tasks part execute `sudo systemctl status jitsi-videobridge2` and you should see `Tasks: XX (limit: 65000)`.
 To check the files and process part execute ```cat /proc/`cat /var/run/jitsi-videobridge/jitsi-videobridge.pid`/limits``` and you should see:
 ```
 Max processes             65000                65000                processes
 Max open files            65000                65000                files
 ```
 ## Debugging problems
 If you run into problems, one thing to try is using a different web browser. Some versions of some browsers are known to have issues with Jitsi Meet. You can also visit https://test.webrtc.org to test your browser's [WebRTC](https://en.wikipedia.org/wiki/WebRTC) support.
 Another place to look is the various log files:
 ```
 /var/log/jitsi/jvb.log
 /var/log/jitsi/jicofo.log
 /var/log/prosody/prosody.log
 ```
--- a/doc/scalable-installation.md
+++ b/doc/scalable-installation.md
@ -1,166 +0,0 @@
 # Scalable Jitsi installation
 A single server Jitsi installation is good for a limited size of concurrent conferences.
 The first limiting factor is the videobridge component, that handles the actual video and audio traffic.
 It is easy to scale the video bridges horizontally by adding as many as needed.
 In a cloud based environment, additionally the bridges can be scaled up or down as needed.
 *NB*: The [Youtube Tutorial on Scaling](https://www.youtube.com/watch?v=LyGV4uW8km8) is outdated and describes an old configuration method.
 *NB*: Building a scalable infrastructure is not a task for beginning Jitsi Administrators.
 The instructions assume that you have installed a single node version successfully, and that
 you are comfortable installing, configuring and debugging Linux software.
 This is not a step-by-step guide, but will show you, which packages to install and which
 configurations to change. Use the [manual install](https://github.com/jitsi/jitsi-meet/blob/master/doc/manual-install.md) for
 details on how to setup Jitsi on a single host.
 It is highly recommended to use configuration management tools like Ansible or Puppet to manage the
 installation and configuration.
 ## Architecture (Single Jitsi-Meet, multiple videobridges)
 A first step is to split the functions of the central jitsi-meet instance (with nginx, prosody and jicofo) and
 videobridges.
 A simplified diagram (with open network ports) of an installation with one Jitsi-Meet instance and three
 videobridges that are load balanced looks as follows. Each box is a server/VM.
 ```
               +                                       +
               |                                       |
               |                                       |
               v                                       v
          80, 443 TCP                          443 TCP, 10000 UDP
       +--------------+                     +---------------------+
       |  nginx       |  5222, 5347 TCP     |                     |
       |  jitsi-meet  |<-------------------+|  jitsi-videobridge  |
       |  prosody     |         |           |                     |
       |  jicofo      |         |           +---------------------+
       +--------------+         |
                                |           +---------------------+
                                |           |                     |
                                +----------+|  jitsi-videobridge  |
                                |           |                     |
                                |           +---------------------+
                                |
                                |           +---------------------+
                                |           |                     |
                                +----------+|  jitsi-videobridge  |
                                            |                     |
                                            +---------------------+
 ```
 ## Machine Sizing
 The Jitsi-Meet server will generally not have that much load (unless you have many) conferences
 going at the same time. A 4 CPU, 8 GB machine will probably be fine.
 The videobridges will have more load. 4 or 8 CPU with 8 GB RAM seems to be a good configuration.
 ### Installation of Jitsi-Meet
 Assuming that the installation will run under the following FQDN: `meet.example.com` and you have
 SSL cert and key in `/etc/ssl/meet.example.com.{crt,key}`
 Set the following DebConf variables prior to installing the packages.
 (We are not installing the `jitsi-meet` package which would handle that for us)
 Install the `debconf-utils` package
 ```
 $ cat << EOF | sudo debconf-set-selections
 jitsi-videobridge	jitsi-videobridge/jvb-hostname	string	meet.example.com
 jitsi-meet	jitsi-meet/jvb-serve	boolean	false
 jitsi-meet-prosody	jitsi-videobridge/jvb-hostname	string	meet.example.com
 jitsi-meet-web-config	jitsi-meet/cert-choice	select	I want to use my own certificate
 jitsi-meet-web-config	jitsi-meet/cert-path-crt	string	/etc/ssl/meet.example.com.crt
 jitsi-meet-web-config	jitsi-meet/cert-path-key	string	/etc/ssl/meet.example.com.key
 EOF
 ```
 On the jitsi-meet server, install the following packages:
 * `nginx`
 * `prosody`
 * `jicofo`
 * `jitsi-meet-web`
 * `jitsi-meet-prosody`
 * `jitsi-meet-web-config`
 ### Installation of Videobridge(s)
 For simplicities sake, set the same `debconf` variables as above and install
 * `jitsi-videobridge2`
 ### Configuration of jitsi-meet
 #### Firewall
 Open the following ports:
 Open to world:
 * 80 TCP
 * 443 TCP
 Open to the videobridges only
 * 5222 TCP (for Prosody)
 * 5347 TCP (for Jicofo)
 #### NGINX
 Create the `/etc/nginx/sites-available/meet.example.com.conf` as usual
 #### Prosody
 Follow the steps in the [manual install](https://github.com/jitsi/jitsi-meet/blob/master/doc/manual-install.md) for setup tasks
 You will need to adapt the following files (see the files in `example-config-files/scalable`)
 * `/etc/prosody/prosody.cfg.lua`
 * `/etc/prosody/conf.avail/meet.example.com.cfg.lua`
 #### Jitsi-Meet
 Adapt `/usr/share/jitsi-meet/config.js` and `/usr/share/jitsi-meet/interface-config.js` to your specific needs
 #### Jicofo
 You will need to adapt the following files (see the files in `example-config-files/scalable`)
 * `/etc/jitsi/jicofo/config` (hostname, jicofo_secret, jicofo_password)
 * `/etc/jitsi/jicofo/sip-communicator.properties` (hostname)
 ### Configuration of the Videobridge
 #### Firewall
 Open the following ports:
 Open to world:
 * 443 TCP
 * 10000 UDP
 #### jitsi-videobridge2
 You will need to adapt the following files (see the files in `example-config-files/scalable`)
 Each videobridge will have to have it's own, unique nickname
 * `/etc/jitsi/videobridge/config` (hostname, password)
 * `/etc/jitsi/jicofo/sip-communicator.properties` (hostname of jitsi-meet, nickname of videobridge, vb_password)
 With the latest stable (April 2020) videobridge, it is no longer necessary to set public and private IP
 adresses in the `sip-communicator.properties` as the bridge will figure out the correct configuration by itself.
 ## Testing
 After restarting all services (`prosody`, `jicofo` and all the `jitsi-videobridge2`) you can see in
 `/var/log/prosody/prosody.log` and
 `/var/log/jitsi/jicofo.log` that the videobridges connect to Prososy and that Jicofo picks them up.
 When a new conference starts, Jicofo picks a videobridge and schedules the conference on it.
--- a/doc/sipgw-config.md
+++ b/doc/sipgw-config.md
@ -1,53 +0,0 @@
 # Configuring sipgw jibri with jitsi-meet
 This document describes how you can configure jitsi-meet to use sipgw jibri and enable rooms in 'Add people dialog'
 You will need a working deployment of jibri configured to use a regular sip video device, for more info check out the [jibri documentation](https://github.com/jitsi/jibri/blob/master/README.md).
 This feature is available for non-guests of the system, so this relies on setting in config.js ``enableUserRolesBasedOnToken: true`` and providing a jwt token when accessing the conference.
 * Jicofo configuration:
 edit /etc/jitsi/jicofo/sip-communicator.properties (or similar), set the appropriate MUC to look for the Jibri Controllers. This should be the same MUC as is referenced in jibri's config.json file. Restart Jicofo after setting this property.
 ```
  org.jitsi.jicofo.jibri.SIP_BREWERY=TheSipBrewery@conference.yourdomain.com
 ```
 * Jitsi Meet configuration:
 - config.js: add 
 ```
  enableUserRolesBasedOnToken: true,
  peopleSearchQueryTypes: ['conferenceRooms'],
  peopleSearchUrl: 'https://api.yourdomain.com/testpath/searchpeople',
 ```
 The combination of the above settings and providing a jwt token will enable a button under invite option which will show the dialog 'Add people'.
 ## People search service
 When searching in the dialog, a request for results is made to the `peopleSearchUrl` service.
 The request is in the following format:
 ```
 https://api.yourdomain.com/testpath/searchpeople?query=testroomname&queryTypes=[%22conferenceRooms%22]&jwt=somejwt
 ```
 The parameters are:
 - query - The text entered by the user.
 - queryTypes - What type of results we want people, rooms, conferenceRooms. This is the value from config.js `peopleSearchQueryTypes`
 - jwt - The token used by the user to access the conference.
 The response of the service is a json in the following format:
 ```
 [
   {
       "id": "address@sip.domain.com",
       "name": "Some room name",
       "type": "videosipgw"
   },
  {
      "id": "address2@sip.domain.com",
      "name": "Some room name2",
      "type": "videosipgw"
  }
 ]
 ```
 Type should be `videosipgw`, `name` is the name shown to the user and `id` is the sip address to be called by the sipgw jibri.
--- a/doc/speakerstats-prosody.md
+++ b/doc/speakerstats-prosody.md
@ -1,22 +0,0 @@
 # Enabling speakerstats prosody module
 To enable the speaker stats we need to enable speakerstats module under the main
 virtual host, this is to enable the advertising the speaker stats component, 
 which address needs to be specified in `speakerstats_component` option.
 We need to also enable the component with the address specified in `speakerstats_component`.
 The component needs also to have the option with the muc component address in
 `muc_component` option.
 ```lua
 VirtualHost "jitsi.example.com"
    speakerstats_component = "speakerstats.jitsi.example.com"
    modules_enabled = {
        "speakerstats";
    }
 Component "speakerstats.jitsi.example.com" "speakerstats_component"
    muc_component = "conference.jitsi.example.com"
 Component "conference.jitsi.example.com" "muc"
 ```
--- a/doc/turn.md
+++ b/doc/turn.md
@ -1,15 +0,0 @@
 One-to-one calls should avoid going throught the JVB for optimal performance and for optimal resource usage. This is why we've added the peer-to-peer mode where the two participants connect directly to each other. Unfortunately, a direct connection is not always possible between the participants. In those cases you can use a TURN server to relay the traffic (n.b. the JVB does much more than just relay the traffic, so this is not the same as using the JVB to "relay" the traffic).
 This document describes how to enable TURN server support in one-to-one calls in Jitsi Meet, even though it gives some hints how to configure [prosody](prosody.im) and [coTURN](https://github.com/coturn/coturn), it assumes a properly configured TURN server and a proprely configured XMPP server.
 One way to configure TURN support in meet with a static configuration. You can simply fill out the `p2p.stunServers` option with appropriate values, e.g.:
    [
        { urls: 'turn:turn.example.com1', credential: 'user', password: 'pass' },
    ]
 This technique doesn't require any special configuration on the XMPP server, but it exposes the credentials to your TURN server and other people can use your bandwidth freely, so while it's simple to implement, it's not recommended.
 This [draft](https://tools.ietf.org/html/draft-uberti-behave-turn-rest-00) escribes a proposed standard REST API for obtaining access to TURN services via ephemeral (i.e. time-limited) credentials. These credentials are vended by a web service over HTTP, and then supplied to and checked by a TURN server using the standard TURN protocol. The usage of ephemeral credentials ensures that access to the TURN server can be controlled even if the credentials can be discovered by the user.
 Jitsi Meet can fetch the TURN credentials from the XMPP server via [XEP-0215](https://xmpp.org/extensions/xep-0215.html). You can enable this functionality by setting `p2p.useStunTurn: true` in config.js. By properly configuring a common shared secret on your TURN server and your XMPP server, the XMPP server can deliver appropriate credentials and TURN urls to Jitsi Meet. coTURN natively supports shared secret authentication (--use-auth-secret-) and in prosody, you can use the [mod_turncredentials](https://modules.prosody.im/mod_turncredentials.html) module.
--- a/resources/cloud-api.swagger
+++ b/resources/cloud-api.swagger