fix(transport): Code style issues and enableLegacyFormat param bug

Improves naming.
Fixing typos.
enableLegacyFormat param was working like disableLegacyFormat.
Improves the structure of transport/index.js

modules/API/API.js

 import * as JitsiMeetConferenceEvents from '../../ConferenceEvents';
-import { transport } from '../transport';
+import { getJitsiMeetTransport } from '../transport';
 
 import { API_ID } from './constants';
 
  */
 let initialScreenSharingState = false;
 
+/**
+ * The transport instance used for communication with external apps.
+ *
+ * @type {Transport}
+ */
+const transport = getJitsiMeetTransport();
+
 /**
  * Initializes supported commands.
  *

modules/API/constants.js

 /**
  * JitsiMeetExternalAPI id - unique for a webpage.
  */
-export const API_ID = getConfigParamsFromUrl().jitsi_meet_external_api_id;
+export const API_ID
+    = typeof getConfigParamsFromUrl === 'function'
+        ? getConfigParamsFromUrl().jitsi_meet_external_api_id : undefined;

modules/API/external/external_api.js

 import EventEmitter from 'events';
 
-import PostMessageTransportBackend
-    from '../../transport/PostMessageTransportBackend';
-import Transport from '../../transport/Transport';
+import {
+    PostMessageTransportBackend,
+    Transport
+} from '../../transport';
 
 const logger = require('jitsi-meet-logger').getLogger(__filename);
 
         this._createIFrame(Math.max(height, MIN_HEIGHT),
             Math.max(width, MIN_WIDTH));
         this._transport = new Transport({
-            transport: new PostMessageTransportBackend({
+            backend: new PostMessageTransportBackend({
                 postisOptions: {
                     scope: `jitsi_meet_external_api_${id}`,
                     window: this.frame.contentWindow

modules/remotecontrol/Receiver.js

     PERMISSIONS_ACTIONS,
     REMOTE_CONTROL_EVENT_TYPE
 } from "../../service/remotecontrol/Constants";
-import { transport } from '../transport';
+import { getJitsiMeetTransport } from '../transport';
 
 import RemoteControlParticipant from "./RemoteControlParticipant";
 
 const ConferenceEvents = JitsiMeetJS.events.conference;
 const logger = require("jitsi-meet-logger").getLogger(__filename);
 
+/**
+ * The transport instance used for communication with external apps.
+ *
+ * @type {Transport}
+ */
+const transport = getJitsiMeetTransport();
+
 /**
  * This class represents the receiver party for a remote controller session.
  * It handles "remote-control-event" events and sends them to the

modules/transport/PostMessageTransportBackend.js

 };
 
 /**
- * The list of methods of incomming postis messages that we have to support for
- * backward compatability for the users that are directly sending messages to
+ * The list of methods of incoming postis messages that we have to support for
+ * backward compatibility for the users that are directly sending messages to
  * Jitsi Meet (without using external_api.js)
  *
  * @type {string[]}
 
 /**
  * The list of methods of outgoing postis messages that we have to support for
- * backward compatability for the users that are directly listening to the
+ * backward compatibility for the users that are directly listening to the
  * postis messages send by Jitsi Meet(without using external_api.js).
  *
  * @type {string[]}
             ...postisOptions
         });
 
+        /**
+         * If true PostMessageTransportBackend will process and send data using
+         * the legacy format and in the same time the current format. Otherwise
+         * all data received that is using the legacy format will be ignored and
+         * no data with the legacy format will be sent.
+         *
+         * @type {boolean}
+         */
         this._enableLegacyFormat = enableLegacyFormat;
 
-        if (!this._enableLegacyFormat) {
-            // backward compatability
+        if (this._enableLegacyFormat) {
+            // backward compatibility
             LEGACY_INCOMING_METHODS.forEach(method =>
                 this.postis.listen(
                     method,
     }
 
     /**
-     * Handles incomming legacy postis data.
+     * Handles incoming legacy postis data.
      *
      * @param {string} method - The method property from postis data object.
      * @param {Any} params - The params property from postis data object.
             params: data
         });
 
-        if (!this._enableLegacyFormat) {
+        if (this._enableLegacyFormat) {
             // For the legacy use case we don't need any new fields defined in
             // Transport class. That's why we are passing only the original
             // object passed by the consumer of the Transport class which is

modules/transport/Transport.js

 } from './constants';
 
 /**
- * Stores the currnet transport that have to be used.
+ * Stores the currnet transport backend that have to be used. Also implements
+ * request/response mechanism.
  */
 export default class Transport {
     /**
      * Creates new instance.
      *
      * @param {Object} options - Optional parameters for configuration of the
-     * transport.
+     * transport backend.
      */
-    constructor({ transport } = {}) {
+    constructor({ backend } = {}) {
+        /**
+         * The request ID counter used for the id property of the request. This
+         * property is used to match the responses with the request.
+         *
+         * @type {number}
+         */
         this._requestID = 0;
 
+        /**
+         * Maps an IDs of the requests and handlers that will process the
+         * responses of those requests.
+         *
+         * @type {Map<number, Function>}
+         */
         this._responseHandlers = new Map();
 
+        /**
+         * Maps an event name and listener that have been added to the Transport
+         * instance.
+         *
+         * @type {Map<string, Function>}
+         */
         this._listeners = new Map();
 
+        /**
+         * A set with the events and requests that were received but not
+         * processed by any listener. They are later passed on every new
+         * listener until they are processed.
+         *
+         * @type {Set<Object>}
+         */
         this._unprocessedMessages = new Set();
 
+        /**
+         * Alias.
+         */
         this.addListener = this.on;
 
-        if (transport) {
-            this.setTransport(transport);
+        if (backend) {
+            this.setBackend(backend);
         }
     }
 
     /**
-     * Disposes the current transport.
+     * Disposes the current transport backend.
      *
      * @returns {void}
      */
-    _disposeTransport() {
-        if (this._transport) {
-            this._transport.dispose();
-            this._transport = null;
+    _disposeBackend() {
+        if (this._backend) {
+            this._backend.dispose();
+            this._backend = null;
         }
     }
 
     /**
-     * Handles incomming data from the transport.
+     * Handles incoming data from the transport backend.
      *
      * @param {Object} data - The data.
      * @returns {void}
                 handler(data);
                 this._responseHandlers.delete(data.id);
             }
-
-            return;
-        }
-
-        if (data.type === MESSAGE_TYPE_REQUEST) {
+        } else if (data.type === MESSAGE_TYPE_REQUEST) {
             this.emit('request', data.data, (result, error) => {
-                this._transport.send({
+                this._backend.send({
                     type: MESSAGE_TYPE_RESPONSE,
                     error,
                     id: data.id,
         this._responseHandlers.clear();
         this._unprocessedMessages.clear();
         this.removeAllListeners();
-        this._disposeTransport();
+        this._disposeBackend();
     }
 
     /**
      * the order they were registered, passing the supplied arguments to each.
      *
      * @param {string} eventName -  The name of the event.
-     * @returns {boolean} True if the event had listeners, false otherwise.
+     * @returns {boolean} True if the event has been processed by any listener,
+     * false otherwise.
      */
     emit(eventName, ...args) {
         const listenersForEvent = this._listeners.get(eventName);
     /**
      * Removes all listeners, or those of the specified eventName.
      *
-     * @param {string} eventName - The name of the event.
+     * @param {string} [eventName] - The name of the event. If this parameter is
+     * not specified all listeners will be removed.
      * @returns {Transport} References to the instance of Transport class, so
      * that calls can be chained.
      */
      * @returns {void}
      */
     sendEvent(data = {}) {
-        if (this._transport) {
-            this._transport.send({
+        if (this._backend) {
+            this._backend.send({
                 type: MESSAGE_TYPE_EVENT,
                 data
             });
      * @returns {Promise}
      */
     sendRequest(data) {
-        if (!this._transport) {
-            return Promise.reject(new Error('No transport defined!'));
+        if (!this._backend) {
+            return Promise.reject(new Error('No transport backend defined!'));
         }
 
         this._requestID++;
                 }
             });
 
-            this._transport.send({
+            this._backend.send({
                 type: MESSAGE_TYPE_REQUEST,
                 data,
                 id
     }
 
     /**
-     * Changes the current transport.
+     * Changes the current backend transport.
      *
-     * @param {Object} transport - The new transport that will be used.
+     * @param {Object} backend - The new transport backend that will be used.
      * @returns {void}
      */
-    setTransport(transport) {
-        this._disposeTransport();
+    setBackend(backend) {
+        this._disposeBackend();
 
-        this._transport = transport;
-        this._transport.setReceiveCallback(this._onDataReceived.bind(this));
+        this._backend = backend;
+        this._backend.setReceiveCallback(this._onDataReceived.bind(this));
     }
 }

modules/transport/index.js

-import { API_ID } from '../API';
+// FIXME: change to '../API' when we update to webpack2. If we do this now all
+// files from API modules will be included in external_api.js.
+import { API_ID } from '../API/constants';
 import { getJitsiMeetGlobalNS } from '../util/helpers';
 
 import Transport from './Transport';
 import PostMessageTransportBackend from './PostMessageTransportBackend';
 
+export {
+    Transport,
+    PostMessageTransportBackend
+};
+
 /**
  * Option for the default low level transport.
  *
     postisOptions.scope = `jitsi_meet_external_api_${API_ID}`;
 }
 
-export const transport = new Transport({
-    transport: new PostMessageTransportBackend({
-        enableLegacyFormat: true,
-        postisOptions
-    })
-});
+/**
+ * The instance of Transport class that will be used by Jitsi Meet.
+ *
+ * @type {Transport}
+ */
+let transport;
+
+/**
+ * Returns the instance of Transport class that will be used by Jitsi Meet.
+ *
+ * @returns {Transport}
+ */
+export function getJitsiMeetTransport() {
+    if (!transport) {
+        transport = new Transport({
+            backend: new PostMessageTransportBackend({
+                enableLegacyFormat: true,
+                postisOptions
+            })
+        });
+    }
+
+    return transport;
+}
 
 /**
  * Sets the transport to passed transport.
  *
- * @param {Object} newTransport - The new transport.
+ * @param {Object} externalTransportBackend - The new transport.
  * @returns {void}
  */
-getJitsiMeetGlobalNS().useNewExternalTransport = function(newTransport) {
-    transport.setTransport(newTransport);
+getJitsiMeetGlobalNS().setExternalTransportBackend = function(
+    externalTransportBackend) {
+    transport.setBackend(externalTransportBackend);
 };

modules/util/helpers.js

  * we store everything that needs to be global (for some reason).
  */
 export function getJitsiMeetGlobalNS() {
-    if(!window.JitsiMeetGlobalNS) {
-        window.JitsiMeetGlobalNS = { };
+    if(!window.JitsiMeetJS) {
+        window.JitsiMeetJS = { };
     }
-    return window.JitsiMeetGlobalNS;
+    if(!window.JitsiMeetJS.app) {
+        window.JitsiMeetJS.app = { };
+    }
+    return window.JitsiMeetJS.app;
 }

react/index.web.js

 import React from 'react';
 import ReactDOM from 'react-dom';
 
-import { transport } from '../modules/transport';
+import { getJitsiMeetTransport } from '../modules/transport';
 
 import config from './config';
 import { App } from './features/app';
         APP.logCollectorStarted = false;
     }
     APP.API.dispose();
-    transport.dispose();
+    getJitsiMeetTransport().dispose();
 });