feat(e2ee): makes olm sessions initialisation lazy

JitsiConference.js

     try {
         jingleSession.initialize(this.room, this.rtc, {
             ...this.options.config,
-            enableInsertableStreams: this._isE2EEEnabled()
+            enableInsertableStreams: this.isE2EEEnabled()
         });
     } catch (error) {
         GlobalOnErrorHandler.callErrorHandler(error);
         this.room,
         this.rtc, {
             ...this.options.config,
-            enableInsertableStreams: this._isE2EEEnabled()
+            enableInsertableStreams: this.isE2EEEnabled()
         });
 
     logger.info('Starting CallStats for P2P connection...');
         this.room,
         this.rtc, {
             ...this.options.config,
-            enableInsertableStreams: this._isE2EEEnabled()
+            enableInsertableStreams: this.isE2EEEnabled()
         });
 
     logger.info('Starting CallStats for P2P connection...');
  *
  * @returns {boolean}
  */
-JitsiConference.prototype._isE2EEEnabled = function() {
+JitsiConference.prototype.isE2EEEnabled = function() {
     return this._e2eEncryption && this._e2eEncryption.isEnabled();
 };
 

modules/e2ee/E2EEncryption.js

 import * as JitsiConferenceEvents from '../../JitsiConferenceEvents';
 import RTCEvents from '../../service/RTC/RTCEvents';
 import browser from '../browser';
+import Deferred from '../util/Deferred';
 
 import E2EEContext from './E2EEContext';
 import { OlmAdapter } from './OlmAdapter';
         this._enabled = false;
         this._initialized = false;
         this._key = undefined;
+        this._enabling = undefined;
 
         this._e2eeCtx = new E2EEContext();
         this._olmAdapter = new OlmAdapter(conference);
             return;
         }
 
+        this._enabling && await this._enabling;
+
+        this._enabling = new Deferred();
+
         this._enabled = enabled;
 
+        if (enabled) {
+            await this._olmAdapter.initSessions();
+        }
+
+        this.conference.setLocalParticipantProperty('e2ee.enabled', enabled);
+
         if (!this._initialized && enabled) {
             // Need to re-create the peerconnections in order to apply the insertable streams constraint.
             // TODO: this was necessary due to some audio issues when indertable streams are used
         this._key = enabled ? this._generateKey() : false;
 
         // Send it to others using the E2EE olm channel.
-        this._olmAdapter.updateKey(this._key).then(index => {
-            // Set our key so we begin encrypting.
-            this._e2eeCtx.setKey(this.conference.myUserId(), this._key, index);
-        });
+        const index = await this._olmAdapter.updateKey(this._key);
+
+        // Set our key so we begin encrypting.
+        this._e2eeCtx.setKey(this.conference.myUserId(), this._key, index);
+
+        this._enabling.resolve();
     }
 
     /**
 
         this._key = new Uint8Array(newKey);
 
-        const index = await this._olmAdapter.updateCurrentKey(this._key);
+        const index = this._olmAdapter.updateCurrentKey(this._key);
 
         this._e2eeCtx.setKey(this.conference.myUserId(), this._key, index);
     }

modules/e2ee/OlmAdapter.js

 import * as JitsiConferenceEvents from '../../JitsiConferenceEvents';
 import Deferred from '../util/Deferred';
 import Listenable from '../util/Listenable';
-import { JITSI_MEET_MUC_TYPE } from '../xmpp/xmpp';
+import { FEATURE_E2EE, JITSI_MEET_MUC_TYPE } from '../xmpp/xmpp';
 
 const logger = getLogger(__filename);
 
         this._key = undefined;
         this._keyIndex = -1;
         this._reqs = new Map();
+        this._sessionInitialization = undefined;
 
         if (OlmAdapter.isSupported()) {
             this._bootstrapOlm();
 
             this._conf.on(JitsiConferenceEvents.ENDPOINT_MESSAGE_RECEIVED, this._onEndpointMessageReceived.bind(this));
-            this._conf.on(JitsiConferenceEvents.CONFERENCE_JOINED, this._onConferenceJoined.bind(this));
             this._conf.on(JitsiConferenceEvents.CONFERENCE_LEFT, this._onConferenceLeft.bind(this));
             this._conf.on(JitsiConferenceEvents.USER_LEFT, this._onParticipantLeft.bind(this));
+            this._conf.on(JitsiConferenceEvents.PARTICIPANT_PROPERTY_CHANGED,
+                this._onParticipantPropertyChanged.bind(this));
         } else {
             this._init.reject(new Error('Olm not supported'));
         }
     }
 
     /**
-     * Indicates if olm is supported on the current platform.
-     *
-     * @returns {boolean}
+     * Starts new olm sessions with every other participant that has the participantId "smaller" the localParticipantId.
      */
-    static isSupported() {
-        return typeof window.Olm !== 'undefined';
+    async initSessions() {
+        if (this._sessionInitialization) {
+            throw new Error('OlmAdapte initSessions called multiple times');
+        } else {
+            this._sessionInitialization = new Deferred();
+
+            await this._init;
+
+            const promises = [];
+            const localParticipantId = this._conf.myUserId();
+
+            for (const participant of this._conf.getParticipants()) {
+                const participantFeatures = await participant.getFeatures();
+
+                if (participantFeatures.has(FEATURE_E2EE) && localParticipantId < participant.getId()) {
+                    promises.push(this._sendSessionInit(participant));
+                }
+            }
+
+            await Promise.allSettled(promises);
+
+            // TODO: retry failed ones.
+
+            this._sessionInitialization.resolve();
+            this._sessionInitialization = undefined;
+        }
     }
 
     /**
-     * Updates the current participant key and distributes it to all participants in the conference
-     * by sending a key-info message.
+     * Indicates if olm is supported on the current platform.
      *
-     * @param {Uint8Array|boolean} key - The new key.
-     * @returns {number}
+     * @returns {boolean}
      */
-    async updateCurrentKey(key) {
-        this._key = key;
-
-        return this._keyIndex;
+    static isSupported() {
+        return typeof window.Olm !== 'undefined';
     }
 
     /**
             const olmData = this._getParticipantOlmData(participant);
 
             // TODO: skip those who don't support E2EE.
-
             if (!olmData.session) {
                 logger.warn(`Tried to send key to participant ${pId} but we have no session`);
 
         return this._keyIndex;
     }
 
+    /**
+     * Updates the current participant key.
+     * @param {Uint8Array|boolean} key - The new key.
+     * @returns {number}
+    */
+    updateCurrentKey(key) {
+        this._key = key;
+
+        return this._keyIndex;
+    }
+
     /**
      * Internal helper to bootstrap the olm library.
      *
         return participant[kOlmData];
     }
 
-    /**
-     * Handles the conference joined event. Upon joining a conference, the participant
-     * who just joined will start new olm sessions with every other participant.
-     *
-     * @private
-     */
-    async _onConferenceJoined() {
-        logger.debug('Conference joined');
-
-        await this._init;
-
-        const promises = [];
-
-        // Establish a 1-to-1 Olm session with every participant in the conference.
-        // We are forcing the last user to join the conference to start the exchange
-        // so we can send some pre-established secrets in the ACK.
-        for (const participant of this._conf.getParticipants()) {
-            promises.push(this._sendSessionInit(participant));
-        }
-
-        await Promise.allSettled(promises);
-
-        // TODO: retry failed ones.
-        // TODO: skip participants which don't support E2EE.
-    }
-
     /**
      * Handles leaving the conference, cleaning up olm sessions.
      *
                 };
 
                 this._sendMessage(ack, pId);
-
                 this.eventEmitter.emit(OlmAdapterEvents.PARTICIPANT_E2EE_CHANNEL_READY, pId);
             }
             break;
             break;
         }
         }
-
     }
 
     /**
         }
     }
 
+    /**
+    * Handles an update in a participant's presence property.
+    *
+    * @param {JitsiParticipant} participant - The participant.
+    * @param {string} name - The name of the property that changed.
+    * @param {*} oldValue - The property's previous value.
+    * @param {*} newValue - The property's new value.
+    * @private
+    */
+    async _onParticipantPropertyChanged(participant, name, oldValue, newValue) {
+        switch (name) {
+        case 'e2ee.enabled':
+            if (newValue && this._conf.isE2EEEnabled()) {
+                const localParticipantId = this._conf.myUserId();
+                const participantId = participant.getId();
+                const participantFeatures = await participant.getFeatures();
+
+                if (participantFeatures.has(FEATURE_E2EE) && localParticipantId < participantId) {
+                    if (this._sessionInitialization) {
+                        await this._sessionInitialization;
+                    }
+                    await this._sendSessionInit(participant);
+
+                    const olmData = this._getParticipantOlmData(participant);
+                    const uuid = uuidv4();
+                    const data = {
+                        [JITSI_MEET_MUC_TYPE]: OLM_MESSAGE_TYPE,
+                        olm: {
+                            type: OLM_MESSAGE_TYPES.KEY_INFO,
+                            data: {
+                                ciphertext: this._encryptKeyInfo(olmData.session),
+                                uuid
+                            }
+                        }
+                    };
+
+                    this._sendMessage(data, participantId);
+                }
+            }
+            break;
+        }
+    }
+
     /**
      * Builds and sends an error message to the target participant.
      *