@webex/plugin-meetings 3.3.1-next.16 → 3.3.1-next.18

package/dist/types/media/MediaConnectionAwaiter.d.ts

@@ -9,8 +9,10 @@ export default class MediaConnectionAwaiter {
     private timer;
     private defer;
     private retried;
+    private iceConnected;
     private onTimeoutCallback;
-    private connectionStateCallback;
+    private peerConnectionStateCallback;
+    private iceConnectionStateCallback;
     private iceGatheringStateCallback;
     /**
      * @param {MediaConnectionAwaiterProps} mediaConnectionAwaiterProps
@@ -35,17 +37,29 @@ export default class MediaConnectionAwaiter {
      */
     private clearCallbacks;
     /**
-     * Listener for connection state change.
+     * On connection state change.
      *
      * @returns {void}
      */
-    connectionStateListenerCallback(): void;
+    connectionStateChange(): void;
+    /**
+     * Listener for peer connection state change.
+     *
+     * @returns {void}
+     */
+    peerConnectionStateHandler(): void;
+    /**
+     * Listener for ICE connection state change.
+     *
+     * @returns {void}
+     */
+    iceConnectionStateHandler(): void;
     /**
      * Listener for ICE gathering state change.
      *
      * @returns {void}
      */
-    iceGatheringStateListenerCallback(): void;
+    iceGatheringStateHandler(): void;
     /**
      * Function called when the timeout is reached.
      *

package/dist/types/meeting/connectionStateHandler.d.ts

@@ -0,0 +1,30 @@
+import { ConnectionState } from '@webex/internal-media-core';
+import EventsScope from '../common/events/events-scope';
+import { Enum } from '../constants';
+export declare const ConnectionStateEvent: {
+    readonly stateChanged: "connectionState:changed";
+};
+export type ConnectionStateEvent = Enum<typeof ConnectionStateEvent>;
+export interface ConnectionStateChangedEvent {
+    /**
+     * Current overall connection state
+     */
+    state: ConnectionState;
+}
+/**
+ * @class ConnectionStateHandler
+ */
+export declare class ConnectionStateHandler extends EventsScope {
+    private webrtcMediaConnection;
+    private mediaConnectionState;
+    /**
+     * @param {WebRTCMeeting} webrtcMediaConnection
+     */
+    constructor(webrtcMediaConnection: any);
+    /**
+     * Handler for connection state change.
+     *
+     * @returns {void}
+     */
+    private handleConnectionStateChange;
+}

package/dist/types/meeting/index.d.ts

@@ -456,6 +456,7 @@ export default class Meeting extends StatelessWebexPlugin {
     private sdpResponseTimer?;
     private hasMediaConnectionConnectedAtLeastOnce;
     private joinWithMediaRetryInfo?;
+    private connectionStateHandler?;
     /**
      * @param {Object} attrs
      * @param {Object} options

package/dist/webinar/index.js

@@ -62,7 +62,7 @@ var Webinar = _webexCore.WebexPlugin.extend({
   updateCanManageWebcast: function updateCanManageWebcast(canManageWebcast) {
     this.set('canManageWebcast', canManageWebcast);
   },
-  version: "3.3.1-next.16"
+  version: "3.3.1-next.18"
 });
 var _default = exports.default = Webinar;
 //# sourceMappingURL=index.js.map

package/package.json

@@ -43,13 +43,13 @@
     "@webex/eslint-config-legacy": "0.0.0",
     "@webex/jest-config-legacy": "0.0.0",
     "@webex/legacy-tools": "0.0.0",
-    "@webex/plugin-meetings": "3.3.1-next.16",
-    "@webex/plugin-rooms": "3.3.1-next.3",
-    "@webex/test-helper-chai": "3.3.1-next.2",
-    "@webex/test-helper-mocha": "3.3.1-next.2",
-    "@webex/test-helper-mock-webex": "3.3.1-next.2",
-    "@webex/test-helper-retry": "3.3.1-next.2",
-    "@webex/test-helper-test-users": "3.3.1-next.2",
+    "@webex/plugin-meetings": "3.3.1-next.18",
+    "@webex/plugin-rooms": "3.3.1-next.5",
+    "@webex/test-helper-chai": "3.3.1-next.4",
+    "@webex/test-helper-mocha": "3.3.1-next.4",
+    "@webex/test-helper-mock-webex": "3.3.1-next.4",
+    "@webex/test-helper-retry": "3.3.1-next.4",
+    "@webex/test-helper-test-users": "3.3.1-next.4",
     "chai": "^4.3.4",
     "chai-as-promised": "^7.1.1",
     "eslint": "^8.24.0",
@@ -61,21 +61,21 @@
     "typescript": "^4.7.4"
   },
   "dependencies": {
-    "@webex/common": "3.3.1-next.2",
-    "@webex/internal-media-core": "2.5.3",
-    "@webex/internal-plugin-conversation": "3.3.1-next.3",
-    "@webex/internal-plugin-device": "3.3.1-next.2",
-    "@webex/internal-plugin-llm": "3.3.1-next.4",
-    "@webex/internal-plugin-mercury": "3.3.1-next.3",
-    "@webex/internal-plugin-metrics": "3.3.1-next.2",
-    "@webex/internal-plugin-support": "3.3.1-next.3",
-    "@webex/internal-plugin-user": "3.3.1-next.2",
-    "@webex/internal-plugin-voicea": "3.3.1-next.16",
-    "@webex/media-helpers": "3.3.1-next.4",
-    "@webex/plugin-people": "3.3.1-next.3",
-    "@webex/plugin-rooms": "3.3.1-next.3",
+    "@webex/common": "3.3.1-next.4",
+    "@webex/internal-media-core": "2.6.0",
+    "@webex/internal-plugin-conversation": "3.3.1-next.5",
+    "@webex/internal-plugin-device": "3.3.1-next.4",
+    "@webex/internal-plugin-llm": "3.3.1-next.6",
+    "@webex/internal-plugin-mercury": "3.3.1-next.5",
+    "@webex/internal-plugin-metrics": "3.3.1-next.4",
+    "@webex/internal-plugin-support": "3.3.1-next.5",
+    "@webex/internal-plugin-user": "3.3.1-next.4",
+    "@webex/internal-plugin-voicea": "3.3.1-next.18",
+    "@webex/media-helpers": "3.3.1-next.6",
+    "@webex/plugin-people": "3.3.1-next.5",
+    "@webex/plugin-rooms": "3.3.1-next.5",
     "@webex/web-capabilities": "^1.3.0",
-    "@webex/webex-core": "3.3.1-next.2",
+    "@webex/webex-core": "3.3.1-next.4",
     "ampersand-collection": "^2.0.2",
     "bowser": "^2.11.0",
     "btoa": "^1.2.1",
@@ -92,5 +92,5 @@
   "//": [
     "TODO: upgrade jwt-decode when moving to node 18"
   ],
-  "version": "3.3.1-next.16"
+  "version": "3.3.1-next.18"
 }

package/src/media/MediaConnectionAwaiter.ts

@@ -15,8 +15,10 @@ export default class MediaConnectionAwaiter {
   private timer: any;
   private defer: Defer;
   private retried: boolean;
+  private iceConnected: boolean;
   private onTimeoutCallback: () => void;
-  private connectionStateCallback: () => void;
+  private peerConnectionStateCallback: () => void;
+  private iceConnectionStateCallback: () => void;
   private iceGatheringStateCallback: () => void;
 
   /**
@@ -26,9 +28,11 @@ export default class MediaConnectionAwaiter {
     this.webrtcMediaConnection = webrtcMediaConnection;
     this.defer = new Defer();
     this.retried = false;
+    this.iceConnected = false;
     this.onTimeoutCallback = this.onTimeout.bind(this);
-    this.connectionStateCallback = this.connectionStateListenerCallback.bind(this);
-    this.iceGatheringStateCallback = this.iceGatheringStateListenerCallback.bind(this);
+    this.peerConnectionStateCallback = this.peerConnectionStateHandler.bind(this);
+    this.iceConnectionStateCallback = this.iceConnectionStateHandler.bind(this);
+    this.iceGatheringStateCallback = this.iceGatheringStateHandler.bind(this);
   }
 
   /**
@@ -59,17 +63,24 @@ export default class MediaConnectionAwaiter {
       Event.ICE_GATHERING_STATE_CHANGED,
       this.iceGatheringStateCallback
     );
-    this.webrtcMediaConnection.off(Event.CONNECTION_STATE_CHANGED, this.connectionStateCallback);
+    this.webrtcMediaConnection.off(
+      Event.PEER_CONNECTION_STATE_CHANGED,
+      this.peerConnectionStateCallback
+    );
+    this.webrtcMediaConnection.off(
+      Event.ICE_CONNECTION_STATE_CHANGED,
+      this.iceConnectionStateCallback
+    );
   }
 
   /**
-   * Listener for connection state change.
+   * On connection state change.
    *
    * @returns {void}
    */
-  connectionStateListenerCallback(): void {
+  connectionStateChange(): void {
     LoggerProxy.logger.log(
-      `Media:MediaConnectionAwaiter#connectionStateListenerCallback --> connection state: ${this.webrtcMediaConnection.getConnectionState()}`
+      `Media:MediaConnectionAwaiter#connectionStateChange --> connection state: ${this.webrtcMediaConnection.getConnectionState()}`
     );
 
     if (!this.isConnected()) {
@@ -83,16 +94,50 @@ export default class MediaConnectionAwaiter {
     this.defer.resolve();
   }
 
+  /**
+   * Listener for peer connection state change.
+   *
+   * @returns {void}
+   */
+  peerConnectionStateHandler(): void {
+    const peerConnectionState = this.webrtcMediaConnection.getPeerConnectionState();
+
+    LoggerProxy.logger.log(
+      `Media:MediaConnectionAwaiter#peerConnectionStateHandler --> Peer connection state change -> ${peerConnectionState}`
+    );
+
+    this.connectionStateChange();
+  }
+
+  /**
+   * Listener for ICE connection state change.
+   *
+   * @returns {void}
+   */
+  iceConnectionStateHandler(): void {
+    const iceConnectionState = this.webrtcMediaConnection.getIceConnectionState();
+
+    LoggerProxy.logger.log(
+      `Media:MediaConnectionAwaiter#iceConnectionStateHandler --> ICE connection state change -> ${iceConnectionState}`
+    );
+
+    if (iceConnectionState === 'connected' && !this.iceConnected) {
+      this.iceConnected = true;
+    }
+
+    this.connectionStateChange();
+  }
+
   /**
    * Listener for ICE gathering state change.
    *
    * @returns {void}
    */
-  iceGatheringStateListenerCallback(): void {
+  iceGatheringStateHandler(): void {
     const iceGatheringState = this.webrtcMediaConnection.getIceGatheringState();
 
     LoggerProxy.logger.log(
-      `Media:MediaConnectionAwaiter#iceGatheringStateListenerCallback --> ICE gathering state change -> ${iceGatheringState}`
+      `Media:MediaConnectionAwaiter#iceGatheringStateHandler --> ICE gathering state change -> ${iceGatheringState}`
     );
 
     if (!this.isIceGatheringCompleted()) {
@@ -147,7 +192,9 @@ export default class MediaConnectionAwaiter {
 
     this.clearCallbacks();
 
-    this.defer.reject();
+    this.defer.reject({
+      iceConnected: this.iceConnected,
+    });
   }
 
   /**
@@ -160,7 +207,15 @@ export default class MediaConnectionAwaiter {
       return Promise.resolve();
     }
 
-    this.webrtcMediaConnection.on(Event.CONNECTION_STATE_CHANGED, this.connectionStateCallback);
+    this.webrtcMediaConnection.on(
+      Event.PEER_CONNECTION_STATE_CHANGED,
+      this.peerConnectionStateCallback
+    );
+
+    this.webrtcMediaConnection.on(
+      Event.ICE_CONNECTION_STATE_CHANGED,
+      this.iceConnectionStateCallback
+    );
 
     this.webrtcMediaConnection.on(
       Event.ICE_GATHERING_STATE_CHANGED,

package/src/meeting/connectionStateHandler.ts

@@ -0,0 +1,65 @@
+import {Event, ConnectionState} from '@webex/internal-media-core';
+import EventsScope from '../common/events/events-scope';
+import {Enum} from '../constants';
+
+export const ConnectionStateEvent = {
+  stateChanged: 'connectionState:changed',
+} as const;
+
+export type ConnectionStateEvent = Enum<typeof ConnectionStateEvent>;
+
+export interface ConnectionStateChangedEvent {
+  /**
+   * Current overall connection state
+   */
+  state: ConnectionState;
+}
+
+/**
+ * @class ConnectionStateHandler
+ */
+export class ConnectionStateHandler extends EventsScope {
+  private webrtcMediaConnection: any;
+
+  private mediaConnectionState: ConnectionState;
+
+  /**
+   * @param {WebRTCMeeting} webrtcMediaConnection
+   */
+  constructor(webrtcMediaConnection) {
+    super();
+
+    this.webrtcMediaConnection = webrtcMediaConnection;
+
+    this.webrtcMediaConnection.on(
+      Event.PEER_CONNECTION_STATE_CHANGED,
+      this.handleConnectionStateChange.bind(this)
+    );
+
+    this.webrtcMediaConnection.on(
+      Event.ICE_CONNECTION_STATE_CHANGED,
+      this.handleConnectionStateChange.bind(this)
+    );
+  }
+
+  /**
+   * Handler for connection state change.
+   *
+   * @returns {void}
+   */
+  private handleConnectionStateChange(): void {
+    const newConnectionState = this.webrtcMediaConnection.getConnectionState();
+
+    if (newConnectionState !== this.mediaConnectionState) {
+      this.mediaConnectionState = newConnectionState;
+      this.emit(
+        {
+          file: 'connectionStateHandler',
+          function: 'handleConnectionStateChange',
+        },
+        ConnectionStateEvent.stateChanged,
+        {state: this.mediaConnectionState}
+      );
+    }
+  }
+}

package/src/meeting/index.ts

@@ -153,6 +153,7 @@ import RecordingController from '../recording-controller';
 import ControlsOptionsManager from '../controls-options-manager';
 import PermissionError from '../common/errors/permission';
 import {LocusMediaRequest} from './locusMediaRequest';
+import {ConnectionStateHandler, ConnectionStateEvent} from './connectionStateHandler';
 
 const logRequest = (request: any, {logText = ''}) => {
   LoggerProxy.logger.info(`${logText} - sending request`);
@@ -680,6 +681,7 @@ export default class Meeting extends StatelessWebexPlugin {
   private sdpResponseTimer?: ReturnType<typeof setTimeout>;
   private hasMediaConnectionConnectedAtLeastOnce: boolean;
   private joinWithMediaRetryInfo?: {isRetry: boolean; prevJoinResponse?: any};
+  private connectionStateHandler?: ConnectionStateHandler;
 
   /**
    * @param {Object} attrs
@@ -1470,6 +1472,15 @@ export default class Meeting extends StatelessWebexPlugin {
      * @memberof Meeting
      */
     this.joinWithMediaRetryInfo = {isRetry: false, prevJoinResponse: undefined};
+
+    /**
+     * Connection state handler
+     * @instance
+     * @type {ConnectionStateHandler}
+     * @private
+     * @memberof Meeting
+     */
+    this.connectionStateHandler = undefined;
   }
 
   /**
@@ -5851,7 +5862,11 @@ export default class Meeting extends StatelessWebexPlugin {
       }
     });
 
-    this.mediaProperties.webrtcMediaConnection.on(Event.CONNECTION_STATE_CHANGED, (event) => {
+    this.connectionStateHandler = new ConnectionStateHandler(
+      this.mediaProperties.webrtcMediaConnection
+    );
+
+    this.connectionStateHandler.on(ConnectionStateEvent.stateChanged, (event) => {
       const connectionFailed = () => {
         Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.CONNECTION_FAILURE, {
           correlation_id: this.correlationId,
@@ -6269,6 +6284,8 @@ export default class Meeting extends StatelessWebexPlugin {
     try {
       await this.mediaProperties.waitForMediaConnectionConnected();
     } catch (error) {
+      const {iceConnected} = error;
+
       if (!this.hasMediaConnectionConnectedAtLeastOnce) {
         // Only send CA event for join flow if we haven't successfully connected media yet
         // @ts-ignore
@@ -6288,12 +6305,7 @@ export default class Meeting extends StatelessWebexPlugin {
                       this.mediaProperties.webrtcMediaConnection?.mediaConnection?.pc
                         ?.signalingState ||
                       'unknown',
-                    iceConnectionState:
-                      this.mediaProperties.webrtcMediaConnection?.multistreamConnection?.pc?.pc
-                        ?.iceConnectionState ||
-                      this.mediaProperties.webrtcMediaConnection?.mediaConnection?.pc
-                        ?.iceConnectionState ||
-                      'unknown',
+                    iceConnected,
                     turnServerUsed: this.turnServerUsed,
                   }),
                 }

package/test/unit/spec/media/MediaConnectionAwaiter.ts

@@ -19,6 +19,8 @@ describe('MediaConnectionAwaiter', () => {
       off: sinon.stub(),
       getConnectionState: sinon.stub().returns(ConnectionState.New),
       getIceGatheringState: sinon.stub().returns('new'),
+      getIceConnectionState: sinon.stub().returns('new'),
+      getPeerConnectionState: sinon.stub().returns('new'),
     };
 
     mediaConnectionAwaiter = new MediaConnectionAwaiter({
@@ -52,8 +54,11 @@ describe('MediaConnectionAwaiter', () => {
         .then(() => {
           promiseResolved = true;
         })
-        .catch(() => {
+        .catch((error) => {
           promiseRejected = true;
+
+          const {iceConnected} = error;
+          assert.equal(iceConnected, false);
         });
 
       await testUtils.flushPromises();
@@ -61,21 +66,68 @@ describe('MediaConnectionAwaiter', () => {
       assert.equal(promiseRejected, false);
 
       // check the right listener was registered
-      assert.calledTwice(mockMC.on);
-      assert.equal(mockMC.on.getCall(0).args[0], Event.CONNECTION_STATE_CHANGED);
-      assert.equal(mockMC.on.getCall(1).args[0], Event.ICE_GATHERING_STATE_CHANGED);
-      const listener = mockMC.on.getCall(1).args[1];
+      assert.calledThrice(mockMC.on);
+      assert.equal(mockMC.on.getCall(0).args[0], Event.PEER_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(1).args[0], Event.ICE_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(2).args[0], Event.ICE_GATHERING_STATE_CHANGED);
+      const iceGatheringListener = mockMC.on.getCall(2).args[1];
 
+      mockMC.getIceGatheringState.returns('complete');
+      iceGatheringListener();
+
+      await clock.tickAsync(ICE_AND_DTLS_CONNECTION_TIMEOUT);
+      await testUtils.flushPromises();
+
+      assert.equal(promiseResolved, false);
+      assert.equal(promiseRejected, true);
+
+      assert.calledThrice(mockMC.off);
+    });
+
+    it('rejects after timeout if dtls state is not connected', async () => {
+      mockMC.getConnectionState.returns(ConnectionState.Connecting);
+      mockMC.getIceGatheringState.returns('gathering');
+
+      let promiseResolved = false;
+      let promiseRejected = false;
+
+      mediaConnectionAwaiter
+        .waitForMediaConnectionConnected()
+        .then(() => {
+          promiseResolved = true;
+        })
+        .catch((error) => {
+          promiseRejected = true;
+
+          const {iceConnected} = error;
+          assert.equal(iceConnected, false);
+        });
+
+      await testUtils.flushPromises();
+      assert.equal(promiseResolved, false);
+      assert.equal(promiseRejected, false);
+
+      // check the right listener was registered
+      assert.calledThrice(mockMC.on);
+      assert.equal(mockMC.on.getCall(0).args[0], Event.PEER_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(1).args[0], Event.ICE_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(2).args[0], Event.ICE_GATHERING_STATE_CHANGED);
+      const listener = mockMC.on.getCall(1).args[1];
+      const iceConnectionListener = mockMC.on.getCall(1).args[1];
+      
       mockMC.getIceGatheringState.returns('complete');
       listener();
 
+      mockMC.getIceConnectionState.returns('connected');
+      iceConnectionListener();
+
       await clock.tickAsync(ICE_AND_DTLS_CONNECTION_TIMEOUT);
       await testUtils.flushPromises();
 
       assert.equal(promiseResolved, false);
       assert.equal(promiseRejected, true);
 
-      assert.calledTwice(mockMC.off);
+      assert.calledThrice(mockMC.off);
     });
 
     it('resolves after timeout if connection state reach connected/completed', async () => {
@@ -99,9 +151,10 @@ describe('MediaConnectionAwaiter', () => {
       assert.equal(promiseRejected, false);
 
       // check the right listener was registered
-      assert.calledTwice(mockMC.on);
-      assert.equal(mockMC.on.getCall(0).args[0], Event.CONNECTION_STATE_CHANGED);
-      assert.equal(mockMC.on.getCall(1).args[0], Event.ICE_GATHERING_STATE_CHANGED);
+      assert.calledThrice(mockMC.on);
+      assert.equal(mockMC.on.getCall(0).args[0], Event.PEER_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(1).args[0], Event.ICE_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(2).args[0], Event.ICE_GATHERING_STATE_CHANGED);
 
       mockMC.getConnectionState.returns(ConnectionState.Connected);
 
@@ -111,7 +164,7 @@ describe('MediaConnectionAwaiter', () => {
       assert.equal(promiseResolved, true);
       assert.equal(promiseRejected, false);
 
-      assert.calledTwice(mockMC.off);
+      assert.calledThrice(mockMC.off);
     });
 
     it(`resolves when media connection reaches "connected" state`, async () => {
@@ -137,9 +190,10 @@ describe('MediaConnectionAwaiter', () => {
       assert.equal(promiseRejected, false);
 
       // check the right listener was registered
-      assert.calledTwice(mockMC.on);
-      assert.equal(mockMC.on.getCall(0).args[0], Event.CONNECTION_STATE_CHANGED);
-      assert.equal(mockMC.on.getCall(1).args[0], Event.ICE_GATHERING_STATE_CHANGED);
+      assert.calledThrice(mockMC.on);
+      assert.equal(mockMC.on.getCall(0).args[0], Event.PEER_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(1).args[0], Event.ICE_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(2).args[0], Event.ICE_GATHERING_STATE_CHANGED);
       const listener = mockMC.on.getCall(0).args[1];
 
       // call the listener and pretend we are now connected
@@ -151,7 +205,7 @@ describe('MediaConnectionAwaiter', () => {
       assert.equal(promiseRejected, false);
 
       // check that listener was removed
-      assert.calledTwice(mockMC.off);
+      assert.calledThrice(mockMC.off);
 
       assert.calledOnce(clearTimeoutSpy);
     });
@@ -179,9 +233,10 @@ describe('MediaConnectionAwaiter', () => {
       assert.equal(promiseRejected, false);
 
       // check the right listener was registered
-      assert.calledTwice(mockMC.on);
-      assert.equal(mockMC.on.getCall(0).args[0], Event.CONNECTION_STATE_CHANGED);
-      assert.equal(mockMC.on.getCall(1).args[0], Event.ICE_GATHERING_STATE_CHANGED);
+      assert.calledThrice(mockMC.on);
+      assert.equal(mockMC.on.getCall(0).args[0], Event.PEER_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(1).args[0], Event.ICE_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(2).args[0], Event.ICE_GATHERING_STATE_CHANGED);
       const listener = mockMC.on.getCall(1).args[1];
 
       // call the listener and pretend we are now connected
@@ -197,7 +252,7 @@ describe('MediaConnectionAwaiter', () => {
       assert.equal(promiseRejected, false);
 
       // check that listener was removed
-      assert.calledTwice(mockMC.off);
+      assert.calledThrice(mockMC.off);
 
       assert.neverCalledWith(clearTimeoutSpy);
     });
@@ -228,10 +283,11 @@ describe('MediaConnectionAwaiter', () => {
       assert.calledOnce(setTimeoutSpy);
 
       // check the right listener was registered
-      assert.calledTwice(mockMC.on);
-      assert.equal(mockMC.on.getCall(0).args[0], Event.CONNECTION_STATE_CHANGED);
-      assert.equal(mockMC.on.getCall(1).args[0], Event.ICE_GATHERING_STATE_CHANGED);
-      const listener = mockMC.on.getCall(1).args[1];
+      assert.calledThrice(mockMC.on);
+      assert.equal(mockMC.on.getCall(0).args[0], Event.PEER_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(1).args[0], Event.ICE_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(2).args[0], Event.ICE_GATHERING_STATE_CHANGED);
+      const listener = mockMC.on.getCall(2).args[1];
 
       // call the listener and pretend we are now connected
       mockMC.getIceGatheringState.returns('complete');
@@ -249,7 +305,7 @@ describe('MediaConnectionAwaiter', () => {
       assert.equal(promiseRejected, false);
 
       // check that listener was removed
-      assert.calledTwice(mockMC.off);
+      assert.calledThrice(mockMC.off);
     });
 
     it(`reject with restart timer once if gathering state is not complete`, async () => {
@@ -276,9 +332,10 @@ describe('MediaConnectionAwaiter', () => {
       assert.equal(promiseRejected, false);
 
       // check the right listener was registered
-      assert.calledTwice(mockMC.on);
-      assert.equal(mockMC.on.getCall(0).args[0], Event.CONNECTION_STATE_CHANGED);
-      assert.equal(mockMC.on.getCall(1).args[0], Event.ICE_GATHERING_STATE_CHANGED);
+      assert.calledThrice(mockMC.on);
+      assert.equal(mockMC.on.getCall(0).args[0], Event.PEER_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(1).args[0], Event.ICE_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(2).args[0], Event.ICE_GATHERING_STATE_CHANGED);
 
       await clock.tickAsync(ICE_AND_DTLS_CONNECTION_TIMEOUT * 2);
       await testUtils.flushPromises();
@@ -287,7 +344,7 @@ describe('MediaConnectionAwaiter', () => {
       assert.equal(promiseRejected, true);
 
       // check that listener was removed
-      assert.calledTwice(mockMC.off);
+      assert.calledThrice(mockMC.off);
 
       assert.calledOnce(clearTimeoutSpy);
       assert.calledTwice(setTimeoutSpy);
@@ -317,11 +374,12 @@ describe('MediaConnectionAwaiter', () => {
       assert.equal(promiseRejected, false);
 
       // check the right listener was registered
-      assert.calledTwice(mockMC.on);
-      assert.equal(mockMC.on.getCall(0).args[0], Event.CONNECTION_STATE_CHANGED);
-      assert.equal(mockMC.on.getCall(1).args[0], Event.ICE_GATHERING_STATE_CHANGED);
+      assert.calledThrice(mockMC.on);
+      assert.equal(mockMC.on.getCall(0).args[0], Event.PEER_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(1).args[0], Event.ICE_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(2).args[0], Event.ICE_GATHERING_STATE_CHANGED);
       const connectionStateListener = mockMC.on.getCall(0).args[1];
-      const iceGatheringListener = mockMC.on.getCall(1).args[1];
+      const iceGatheringListener = mockMC.on.getCall(2).args[1];
 
       mockMC.getIceGatheringState.returns('complete');
       iceGatheringListener();
@@ -335,7 +393,7 @@ describe('MediaConnectionAwaiter', () => {
       assert.equal(promiseRejected, false);
 
       // check that listener was removed
-      assert.calledTwice(mockMC.off);
+      assert.calledThrice(mockMC.off);
 
       assert.calledTwice(clearTimeoutSpy);
       assert.calledTwice(setTimeoutSpy);