@webex/plugin-meetings 3.0.0-beta.1 → 3.0.0-beta.2

package/test/unit/spec/meeting/index.js

@@ -20,7 +20,9 @@ import {
   _SIP_URI_,
   _MEETING_ID_,
   LOCUSINFO,
+  PC_BAIL_TIMEOUT,
 } from '@webex/plugin-meetings/src/constants';
+import {MediaConnection as MC} from '@webex/internal-media-core';
 import * as StatsAnalyzerModule from '@webex/plugin-meetings/src/statsAnalyzer';
 import EventsScope from '@webex/plugin-meetings/src/common/events/events-scope';
 import Meetings, {CONSTANTS} from '@webex/plugin-meetings';
@@ -32,7 +34,6 @@ import LocusInfo from '@webex/plugin-meetings/src/locus-info';
 import MediaProperties from '@webex/plugin-meetings/src/media/properties';
 import MeetingUtil from '@webex/plugin-meetings/src/meeting/util';
 import Media from '@webex/plugin-meetings/src/media/index';
-import PeerConnectionManager from '@webex/plugin-meetings/src/peer-connection-manager';
 import ReconnectionManager from '@webex/plugin-meetings/src/reconnection-manager';
 import MediaUtil from '@webex/plugin-meetings/src/media/util';
 import LoggerProxy from '@webex/plugin-meetings/src/common/logs/logger-proxy';
@@ -178,7 +179,6 @@ describe('plugin-meetings', () => {
     TriggerProxy.trigger = sinon.stub().returns(true);
     Metrics.postEvent = sinon.stub();
     Metrics.initialSetup(null, webex);
-    MediaUtil.createPeerConnection = sinon.stub().returns({});
     MediaUtil.createMediaStream = sinon.stub().returns(true);
 
     uuid1 = uuid.v4();
@@ -222,7 +222,6 @@ describe('plugin-meetings', () => {
           assert.equal(meeting.userId, uuid1);
           assert.equal(meeting.resource, uuid2);
           assert.equal(meeting.deviceUrl, uuid3);
-          assert.equal(meeting.roapSeq, -1);
           assert.deepEqual(meeting.meetingInfo, {});
           assert.instanceOf(meeting.members, Members);
           assert.instanceOf(meeting.roap, Roap);
@@ -909,22 +908,25 @@ describe('plugin-meetings', () => {
           applyClientStateLocally: sinon.stub().returns(Promise.resolve(true))
         };
 
+        let fakeMediaConnection;
+
         beforeEach(() => {
+          fakeMediaConnection = {
+            close: sinon.stub(),
+            getConnectionState: sinon.stub().returns(MC.ConnectionState.Connected),
+            initiateOffer: sinon.stub().resolves({}),
+            on: sinon.stub(),
+          };
           meeting.mediaProperties.setMediaDirection = sinon.stub().returns(true);
-          meeting.mediaProperties.waitForIceConnectedState = sinon.stub().resolves();
+          meeting.mediaProperties.waitForMediaConnectionConnected = sinon.stub().resolves();
           meeting.mediaProperties.getCurrentConnectionType = sinon.stub().resolves('udp');
           meeting.audio = muteStateStub;
           meeting.video = muteStateStub;
-          Media.attachMedia = sinon.stub().returns(Promise.resolve([test1, test2]));
+          Media.createMediaConnection = sinon.stub().returns(fakeMediaConnection);
           meeting.setMercuryListener = sinon.stub().returns(true);
-          meeting.setRemoteStream = sinon.stub().returns(true);
+          meeting.setupMediaConnectionListeners = sinon.stub();
           meeting.setMercuryListener = sinon.stub();
-          meeting.roap.sendRoapMediaRequest = sinon.stub().returns(new Promise((resolve) => {
-            meeting.mediaProperties.peerConnection.connectionState = CONSTANTS.CONNECTION_STATE.CONNECTED;
-            resolve();
-          }));
           meeting.roap.doTurnDiscovery = sinon.stub().resolves({turnServerInfo: {}, turnDiscoverySkippedReason: undefined});
-          PeerConnectionManager.setContentSlides = sinon.stub().returns(true);
         });
 
         it('should have #addMedia', () => {
@@ -932,16 +934,17 @@ describe('plugin-meetings', () => {
         });
 
         it('should reject promise if meeting is not active', async () => {
-          await meeting.addMedia().catch((err) => {
-            assert.instanceOf(err, MeetingNotActiveError);
-          });
+          const result = await assert.isRejected(meeting.addMedia());
+
+          assert.instanceOf(result, MeetingNotActiveError);
         });
 
         it('should reject promise if user already in left state', async () => {
           meeting.meetingState = 'ACTIVE';
-          await meeting.addMedia().catch((err) => {
-            assert.instanceOf(err, UserNotJoinedError);
-          });
+          meeting.locusInfo.parsedLocus = {self: {state: 'LEFT'}};
+          const result = await assert.isRejected(meeting.addMedia());
+
+          assert.instanceOf(result, UserNotJoinedError);
         });
 
         it('should reject promise if user is in lobby ', async () => {
@@ -960,24 +963,29 @@ describe('plugin-meetings', () => {
 
         it('should reset the statsAnalyzer to null if addMedia throws an error', async () => {
           meeting.meetingState = 'ACTIVE';
-          meeting.statsAnalyzer = true;
-          await meeting.addMedia().catch((err) => {
-            assert.exists(err);
-            assert.isNull(meeting.statsAnalyzer);
-            assert(Metrics.sendBehavioralMetric.calledOnce);
-            assert.calledWith(
-              Metrics.sendBehavioralMetric,
-              BEHAVIORAL_METRICS.ADD_MEDIA_FAILURE, {
-                correlation_id: meeting.correlationId,
-                locus_id: meeting.locusUrl.split('/').pop(),
-                reason: err.message,
-                stack: err.stack,
-                code: err.code,
-                turnDiscoverySkippedReason: undefined,
-                turnServerUsed: true
-              }
-            );
+          // setup the mock to return an incomplete object - this will cause addMedia to fail
+          // because some methods (like on() or initiateOffer()) are missing
+          Media.createMediaConnection = sinon.stub().returns({
+            close: sinon.stub(),
           });
+          // set a statsAnalyzer on the meeting so that we can check that it gets reset to null
+          meeting.statsAnalyzer = {stopAnalyzer: sinon.stub().resolves()};
+          const error = await assert.isRejected(meeting.addMedia());
+
+          assert.isNull(meeting.statsAnalyzer);
+          assert(Metrics.sendBehavioralMetric.calledOnce);
+          assert.calledWith(
+            Metrics.sendBehavioralMetric,
+            BEHAVIORAL_METRICS.ADD_MEDIA_FAILURE, {
+              correlation_id: meeting.correlationId,
+              locus_id: meeting.locusUrl.split('/').pop(),
+              reason: error.message,
+              stack: error.stack,
+              code: error.code,
+              turnDiscoverySkippedReason: undefined,
+              turnServerUsed: true
+            }
+          );
         });
 
         it('checks metrics called with skipped reason config', async () => {
@@ -1000,37 +1008,44 @@ describe('plugin-meetings', () => {
           });
         });
 
-        it('should reset the peerConnection to null if addMedia throws an error', async () => {
+        it('should reset the webrtcMediaConnection to null if addMedia throws an error', async () => {
           meeting.meetingState = 'ACTIVE';
-          meeting.mediaProperties.peerConnection = true;
-          await meeting.addMedia().catch((err) => {
-            assert.exists(err);
-            assert.isNull(meeting.mediaProperties.peerConnection);
-            assert(Metrics.sendBehavioralMetric.calledOnce);
-            assert.calledWith(
-              Metrics.sendBehavioralMetric,
-              BEHAVIORAL_METRICS.ADD_MEDIA_FAILURE, {
-                correlation_id: meeting.correlationId,
-                locus_id: meeting.locusUrl.split('/').pop(),
-                reason: err.message,
-                stack: err.stack,
-                turnDiscoverySkippedReason: undefined,
-                turnServerUsed: true
-              }
-            );
+          // setup the mock so that a media connection is created, but its initiateOffer() method fails
+          Media.createMediaConnection = sinon.stub().returns({
+            initiateOffer: sinon.stub().throws(new Error('fake error')),
+            close: sinon.stub(),
           });
+          const result = await assert.isRejected(meeting.addMedia());
+
+          assert.instanceOf(result, Error);
+          assert.isNull(meeting.mediaProperties.webrtcMediaConnection);
+
+          assert(Metrics.sendBehavioralMetric.calledOnce);
+          assert.calledWith(
+            Metrics.sendBehavioralMetric,
+            BEHAVIORAL_METRICS.ADD_MEDIA_FAILURE, sinon.match({
+              correlation_id: meeting.correlationId,
+              locus_id: meeting.locusUrl.split('/').pop(),
+              reason: result.message,
+              turnDiscoverySkippedReason: undefined,
+              turnServerUsed: true
+            })
+          );
         });
 
         it('should work the second time addMedia is called in case the first time fails', async () => {
           meeting.meetingState = 'ACTIVE';
 
-          try {
-            await meeting.addMedia();
-            assert.fail('addMedia should have thrown an exception.');
-          }
-          catch (err) {
-            assert.exists(err);
-          }
+          // setup the mock to cause addMedia() to fail
+          Media.createMediaConnection = sinon.stub().returns({
+            initiateOffer: sinon.stub().throws(new Error('fake error')),
+            close: sinon.stub(),
+          });
+
+          await assert.isRejected(meeting.addMedia());
+
+          // reset the mock to a good one, that doesn't fail
+          Media.createMediaConnection = sinon.stub().returns(fakeMediaConnection);
 
           try {
             await meeting.addMedia({
@@ -1044,12 +1059,11 @@ describe('plugin-meetings', () => {
 
         it('if an error occurs after media request has already been sent, and the user waits until the server kicks them out, a UserNotJoinedError should be thrown when attempting to addMedia again', async () => {
           meeting.meetingState = 'ACTIVE';
-          meeting.roap.sendRoapMediaRequest = sinon.stub().returns(new Promise((resolve) => {
-            meeting.mediaProperties.peerConnection.connectionState = CONSTANTS.CONNECTION_STATE.CONNECTED;
-            resolve();
-          }).then(() => {
-            throw new Error('sample error thrown');
-          }));
+          // setup the mock to cause addMedia() to fail
+          Media.createMediaConnection = sinon.stub().returns({
+            initiateOffer: sinon.stub().throws(new Error('fake error')),
+            close: sinon.stub(),
+          });
           await meeting.addMedia().catch((err) => {
             assert.exists(err);
           });
@@ -1062,21 +1076,16 @@ describe('plugin-meetings', () => {
 
         it('if an error occurs after media request has already been sent, and the user does NOT wait until the server kicks them out, the user should be able to addMedia successfully', async () => {
           meeting.meetingState = 'ACTIVE';
-          meeting.roap.sendRoapMediaRequest = sinon.stub().returns(new Promise((resolve) => {
-            meeting.mediaProperties.peerConnection.connectionState = CONSTANTS.CONNECTION_STATE.CONNECTED;
-            resolve();
-          }).then(() => {
-            throw new Error('sample error thrown');
-          }));
+          // setup the mock to cause addMedia() to fail
+          Media.createMediaConnection = sinon.stub().returns({
+            initiateOffer: sinon.stub().throws(new Error('fake error')),
+            close: sinon.stub(),
+          });
           await meeting.addMedia().catch((err) => {
             assert.exists(err);
           });
 
-          meeting.mediaProperties.peerConnection = {};
-          meeting.roap.sendRoapMediaRequest = sinon.stub().returns(new Promise((resolve) => {
-            meeting.mediaProperties.peerConnection.connectionState = CONSTANTS.CONNECTION_STATE.CONNECTED;
-            resolve();
-          }));
+          Media.createMediaConnection = sinon.stub().returns(fakeMediaConnection);
           await meeting.addMedia().catch((err) => {
             assert.fail('No error should appear: ', err);
           });
@@ -1086,7 +1095,6 @@ describe('plugin-meetings', () => {
           meeting.roap.doTurnDiscovery = sinon.stub().resolves({turnServerInfo: undefined, turnDiscoverySkippedReason: undefined});
 
           meeting.meetingState = 'ACTIVE';
-          MediaUtil.createPeerConnection.resetHistory();
           const media = meeting.addMedia({
             mediaSettings: {}
           });
@@ -1096,12 +1104,10 @@ describe('plugin-meetings', () => {
           assert.calledOnce(meeting.roap.doTurnDiscovery);
           assert.calledWith(meeting.roap.doTurnDiscovery, meeting, false);
           assert.calledOnce(meeting.mediaProperties.setMediaDirection);
-          assert.calledOnce(Media.attachMedia);
+          assert.calledOnce(Media.createMediaConnection);
+          assert.calledWith(Media.createMediaConnection, sinon.match.any, sinon.match({turnServerInfo: undefined}));
           assert.calledOnce(meeting.setMercuryListener);
-          assert.calledOnce(meeting.setRemoteStream);
-          assert.calledOnce(meeting.roap.sendRoapMediaRequest);
-          assert.calledOnce(MediaUtil.createPeerConnection);
-          assert.calledWith(MediaUtil.createPeerConnection, undefined);
+          assert.calledOnce(fakeMediaConnection.initiateOffer);
           /* statsAnalyzer is initiated inside of addMedia so there isn't
           * a good way to mock it without mocking the constructor
           */
@@ -1113,7 +1119,7 @@ describe('plugin-meetings', () => {
           const FAKE_TURN_PASSWORD = 'some-password';
 
           meeting.meetingState = 'ACTIVE';
-          MediaUtil.createPeerConnection.resetHistory();
+          Media.createMediaConnection.resetHistory();
 
 
           meeting.roap.doTurnDiscovery = sinon.stub().resolves({
@@ -1132,31 +1138,39 @@ describe('plugin-meetings', () => {
           await media;
           assert.calledOnce(meeting.roap.doTurnDiscovery);
           assert.calledWith(meeting.roap.doTurnDiscovery, meeting, false);
-          assert.calledOnce(MediaUtil.createPeerConnection);
-          assert.calledWith(MediaUtil.createPeerConnection, {
-            url: FAKE_TURN_URL,
-            username: FAKE_TURN_USER,
-            password: FAKE_TURN_PASSWORD
-          });
+          assert.calledOnce(Media.createMediaConnection);
+          assert.calledWith(Media.createMediaConnection, sinon.match.any, sinon.match({
+            turnServerInfo: {
+              url: FAKE_TURN_URL,
+              username: FAKE_TURN_USER,
+              password: FAKE_TURN_PASSWORD
+            }
+          }));
+          assert.calledOnce(fakeMediaConnection.initiateOffer);
         });
 
-        it('should attach the media and return promise', async () => {
-          meeting.roap.doTurnDiscovery = sinon.stub().resolves({turnServerInfo: undefined, turnDiscoverySkippedReason: undefined});
+        it('should attach the media and return WebExMeetingsErrors when connection does not reach CONNECTED state', async () => {
           meeting.meetingState = 'ACTIVE';
-          meeting.mediaProperties.peerConnection.connectionState = 'DISCONNECTED';
+          fakeMediaConnection.getConnectionState = sinon.stub().returns(MC.ConnectionState.Connecting);
+          const clock = sinon.useFakeTimers();
           const media = meeting.addMedia({
             mediaSettings: {}
           });
 
+          await clock.tickAsync(4000 /* meetingState timer, hardcoded inside addMedia */ + PC_BAIL_TIMEOUT /* connection state timer */);
+          await testUtils.flushPromises();
+
           assert.exists(media);
           await media.catch((err) => {
             assert.instanceOf(err, WebExMeetingsErrors);
           });
+
+          clock.restore();
         });
 
-        it('should reject if waitForIceConnectedState() rejects', async () => {
+        it('should reject if waitForMediaConnectionConnected() rejects', async () => {
           meeting.meetingState = 'ACTIVE';
-          meeting.mediaProperties.waitForIceConnectedState.rejects(new Error('fake error'));
+          meeting.mediaProperties.waitForMediaConnectionConnected.rejects(new Error('fake error'));
 
           let errorThrown = false;
 
@@ -1346,7 +1360,6 @@ describe('plugin-meetings', () => {
           meeting.statsAnalyzer = {stopAnalyzer: sinon.stub().resolves()};
           meeting.unsetRemoteStream = sinon.stub().returns(true);
           meeting.unsetPeerConnections = sinon.stub().returns(true);
-          meeting.roap.stop = sinon.stub().returns(Promise.resolve());
           meeting.logger.error = sinon.stub().returns(true);
 
           // A meeting needs to be joined to leave
@@ -1371,7 +1384,6 @@ describe('plugin-meetings', () => {
           assert.calledOnce(meeting.unsetLocalShareTrack);
           assert.calledOnce(meeting.unsetRemoteTracks);
           assert.calledOnce(meeting.unsetPeerConnections);
-          assert.calledOnce(meeting.roap.stop);
         });
         describe('after audio/video is defined', () => {
           let handleClientRequest;
@@ -1484,61 +1496,6 @@ describe('plugin-meetings', () => {
           });
         });
 
-        describe('getter: isLocalShareLive', () => {
-          const LIVE = 'live';
-          const ENDED = 'ended';
-          const SENDRECV = 'sendrecv';
-          const RECVONLY = 'reconly';
-          let sandbox;
-          let _direction;
-          let _trackReadyState = ENDED;
-
-          beforeEach(() => {
-            sandbox = sinon.createSandbox();
-            sandbox.stub(meeting.mediaProperties, 'shareTrack').value(true);
-            sandbox.stub(meeting.mediaProperties, 'peerConnection').value({
-              shareTransceiver: {
-                get direction() {
-                  return _direction;
-                },
-                sender: {
-                  track: {
-                    get readyState() {
-                      return _trackReadyState;
-                    }
-                  }
-                }
-              }
-            });
-          });
-
-          afterEach(() => {
-            sandbox.restore();
-            sandbox = null;
-          });
-
-          it('sets isLocalShareLive to true when sharing screen', () => {
-            _direction = SENDRECV;
-            _trackReadyState = LIVE;
-
-            assert.isTrue(meeting.isLocalShareLive);
-          });
-
-          it('sets isLocalShareLive to false when not sharing screen', () => {
-            _direction = RECVONLY;
-            _trackReadyState = ENDED;
-
-            assert.isFalse(meeting.isLocalShareLive);
-          });
-
-          it('sets isLocalShareLive to false when track is live but share direction is recv only', () => {
-            _direction = RECVONLY;
-            _trackReadyState = LIVE;
-
-            assert.isFalse(meeting.isLocalShareLive);
-          });
-        });
-
         describe('stops share immediately', () => {
           let sandbox;
 
@@ -1556,7 +1513,6 @@ describe('plugin-meetings', () => {
             const receiveShare = false;
             const stream = 'stream';
 
-            sandbox.stub(meeting.mediaProperties, 'peerConnection').value({shareTransceiver: true});
             sandbox.stub(MeetingUtil, 'getTrack').returns({videoTrack: true});
             MeetingUtil.validateOptions = sinon.stub().returns(Promise.resolve(true));
             sandbox.stub(meeting, 'canUpdateMedia').returns(true);
@@ -1620,42 +1576,6 @@ describe('plugin-meetings', () => {
             sandbox = null;
           });
 
-          it('calls handleShareTrackEnded if sharing is out of sync', async () => {
-            const sendShare = true;
-            const receiveShare = false;
-            const stream = 'stream';
-            const SENDRECV = 'sendrecv';
-            const delay = 1e3;
-
-            MeetingUtil.validateOptions = sinon.stub().returns(Promise.resolve(true));
-            MeetingUtil.updateTransceiver = sinon.stub().returns(Promise.resolve(true));
-            sandbox.stub(meeting, 'canUpdateMedia').returns(true);
-            sandbox.stub(MeetingUtil, 'getTrack').returns({videoTrack: null});
-            sandbox.stub(meeting, 'setLocalShareTrack');
-            sandbox.stub(meeting, 'unsetLocalShareTrack');
-            sandbox.stub(meeting, 'checkForStopShare').returns(false);
-
-            sandbox.stub(meeting, 'isLocalShareLive').value(false);
-            sandbox.stub(meeting, 'handleShareTrackEnded');
-            sandbox.stub(meeting.mediaProperties, 'peerConnection').value({
-              shareTransceiver: {
-                direction: SENDRECV
-              }
-            });
-            sandbox.useFakeTimers();
-
-            await meeting.updateShare({
-              sendShare,
-              receiveShare,
-              stream,
-              skipSignalingCheck: true
-            });
-            // simulate the setTimeout in code
-            sandbox.clock.tick(delay);
-
-            assert.calledOnce(meeting.handleShareTrackEnded);
-          });
-
           it('handleShareTrackEnded triggers an event', () => {
             const stream = 'stream';
             const {EVENT_TYPES} = CONSTANTS;
@@ -1917,6 +1837,11 @@ describe('plugin-meetings', () => {
       });
 
       describe('#updateAudio', () => {
+        const FAKE_AUDIO_TRACK = {
+          id: 'fake audio track',
+          getSettings: sinon.stub().returns({}),
+        };
+
         describe('when canUpdateMedia is true', () => {
           beforeEach(() => {
             meeting.canUpdateMedia = sinon.stub().returns(true);
@@ -1924,20 +1849,33 @@ describe('plugin-meetings', () => {
           describe('when options are valid', () => {
             beforeEach(() => {
               MeetingUtil.validateOptions = sinon.stub().returns(Promise.resolve());
+              meeting.mediaProperties.mediaDirection = {
+                sendAudio: false,
+                sendVideo: true,
+                sendShare: false,
+                receiveAudio: false,
+                receiveVideo: true,
+                receiveShare: true,
+              };
+              meeting.mediaProperties.webrtcMediaConnection = {updateSendReceiveOptions: sinon.stub()};
+              sinon.stub(MeetingUtil, 'getTrack').returns({audioTrack: FAKE_AUDIO_TRACK});
             });
-            describe('when mediaDirection is undefined', () => {
-              beforeEach(() => {
-                meeting.mediaProperties.mediaDirection = null;
-                MeetingUtil.updateTransceiver = sinon.stub();
+            it('calls this.mediaProperties.webrtcMediaConnection.updateSendReceiveOptions', () => meeting.updateAudio({
+              sendAudio: true,
+              receiveAudio: true,
+              stream: {id: 'fake stream'}
+            }).then(() => {
+              assert.calledOnce(meeting.mediaProperties.webrtcMediaConnection.updateSendReceiveOptions);
+              assert.calledWith(meeting.mediaProperties.webrtcMediaConnection.updateSendReceiveOptions, {
+                send: {audio: FAKE_AUDIO_TRACK},
+                receive: {
+                  audio: true, video: true, screenShareVideo: true, remoteQualityLevel: 'HIGH'
+                }
               });
-
-              it('sets previousMediaDirection to an empty object', () => meeting.updateAudio({
-                sendAudio: true,
-                receiveAudio: true
-              }).then(() => {
-                assert.calledOnce(MeetingUtil.updateTransceiver);
-              }));
-            });
+            }));
+          });
+          afterEach(() => {
+            sinon.restore();
           });
         });
       });
@@ -1988,10 +1926,36 @@ describe('plugin-meetings', () => {
         let sandbox;
         const mockLocalStream = {id: 'mock local stream'};
         const mockLocalShare = {id: 'mock local share stream'};
+        const FAKE_TRACKS = {
+          audio: {
+            id: 'fake audio track',
+            getSettings: sinon.stub().returns({}),
+          },
+          video: {
+            id: 'fake video track',
+            getSettings: sinon.stub().returns({}),
+          },
+          screenshareVideo: {
+            id: 'fake share track',
+            getSettings: sinon.stub().returns({}),
+          },
+
+        };
 
         beforeEach(() => {
           sandbox = sinon.createSandbox();
           meeting.mediaProperties.mediaDirection = {sendShare: true};
+          // setup the stub to return the right tracks
+          sandbox.stub(MeetingUtil, 'getTrack').callsFake((stream) => {
+            if (stream === mockLocalStream) {
+              return {audioTrack: FAKE_TRACKS.audio, videoTrack: FAKE_TRACKS.video};
+            }
+            if (stream === mockLocalShare) {
+              return {audioTrack: null, videoTrack: FAKE_TRACKS.screenshareVideo};
+            }
+
+            return {audioTrack: null, videoTrack: null};
+          });
         });
 
         afterEach(() => {
@@ -2011,7 +1975,9 @@ describe('plugin-meetings', () => {
           };
 
           sandbox.stub(meeting, 'canUpdateMedia').returns(false);
-          sandbox.stub(Media, 'updateMedia').resolves();
+          meeting.mediaProperties.webrtcMediaConnection = {
+            updateSendReceiveOptions: sinon.stub().resolves({})
+          };
 
           let myPromiseResolved = false;
 
@@ -2025,18 +1991,30 @@ describe('plugin-meetings', () => {
             });
 
           // verify that nothing was done
-          assert.notCalled(Media.updateMedia);
+          assert.notCalled(meeting.mediaProperties.webrtcMediaConnection.updateSendReceiveOptions);
 
           // now trigger processing of the queue
           meeting.canUpdateMedia.restore();
           sandbox.stub(meeting, 'canUpdateMedia').returns(true);
-          meeting.updateMedia = sinon.stub().returns(Promise.resolve());
 
           meeting.processNextQueuedMediaUpdate();
           await testUtils.flushPromises();
 
-          // and check that meeting.updateMedia is called with the original args
-          assert.calledWith(meeting.updateMedia, {localStream: mockLocalStream, localShare: mockLocalShare, mediaSettings});
+          // and check that updateSendReceiveOptions is called with the original args
+          assert.calledOnce(meeting.mediaProperties.webrtcMediaConnection.updateSendReceiveOptions);
+          assert.calledWith(meeting.mediaProperties.webrtcMediaConnection.updateSendReceiveOptions, {
+            send: {
+              audio: FAKE_TRACKS.audio,
+              video: FAKE_TRACKS.video,
+              screenShareVideo: FAKE_TRACKS.screenshareVideo,
+            },
+            receive: {
+              audio: true,
+              video: true,
+              screenShareVideo: true,
+              remoteQualityLevel: 'HIGH'
+            }
+          });
           assert.isTrue(myPromiseResolved);
         });
       });
@@ -2282,7 +2260,7 @@ describe('plugin-meetings', () => {
           meeting.mediaProperties.mediaDirection = mediaDirection;
           meeting.canUpdateMedia = sinon.stub().returns(true);
           MeetingUtil.validateOptions = sinon.stub().returns(Promise.resolve());
-          MeetingUtil.updateTransceiver = sinon.stub().returns(Promise.resolve());
+          meeting.updateVideo = sinon.stub().resolves();
           sinon.stub(MeetingUtil, 'getTrack').returns({videoTrack: fakeTrack});
         });
 
@@ -2842,7 +2820,6 @@ describe('plugin-meetings', () => {
           meeting.statsAnalyzer = {stopAnalyzer: sinon.stub().resolves()};
           meeting.unsetRemoteStream = sinon.stub().returns(true);
           meeting.unsetPeerConnections = sinon.stub().returns(true);
-          meeting.roap.stop = sinon.stub().returns(Promise.resolve());
           meeting.logger.error = sinon.stub().returns(true);
 
           // A meeting needs to be joined to end
@@ -2867,7 +2844,6 @@ describe('plugin-meetings', () => {
           assert.calledOnce(meeting?.unsetLocalShareTrack);
           assert.calledOnce(meeting?.unsetRemoteTracks);
           assert.calledOnce(meeting?.unsetPeerConnections);
-          assert.calledOnce(meeting?.roap?.stop);
         });
       });
 
@@ -3295,31 +3271,254 @@ describe('plugin-meetings', () => {
           assert.calledOnce(meeting.stopShare);
         });
       });
-      describe('#setRemoteStream', () => {
+      describe('#setupMediaConnectionListeners', () => {
+        let eventListeners;
+
         beforeEach(() => {
+          eventListeners = {};
           meeting.statsAnalyzer = {startAnalyzer: sinon.stub()};
+          meeting.mediaProperties.webrtcMediaConnection = {
+            // mock the on() method and store all the listeners
+            on: sinon.stub().callsFake((event, listener) => {
+              eventListeners[event] = listener;
+            })
+          };
         });
-        it('should trigger a media:ready event when remote stream track ontrack is fired', () => {
-          const pc = {};
 
-          meeting.setRemoteStream(pc);
-          pc.ontrack({track: 'track', transceiver: {mid: '0'}});
+        it('should register for all the correct RoapMediaConnection events', () => {
+          meeting.setupMediaConnectionListeners();
+          assert.isFunction(eventListeners[MC.Event.ROAP_STARTED]);
+          assert.isFunction(eventListeners[MC.Event.ROAP_DONE]);
+          assert.isFunction(eventListeners[MC.Event.ROAP_FAILURE]);
+          assert.isFunction(eventListeners[MC.Event.ROAP_MESSAGE_TO_SEND]);
+          assert.isFunction(eventListeners[MC.Event.REMOTE_TRACK_ADDED]);
+          assert.isFunction(eventListeners[MC.Event.CONNECTION_STATE_CHANGED]);
+        });
+
+        it('should trigger a media:ready event when REMOTE_TRACK_ADDED is fired', () => {
+          meeting.setupMediaConnectionListeners();
+          eventListeners[MC.Event.REMOTE_TRACK_ADDED]({track: 'track', type: MC.RemoteTrackType.AUDIO});
           assert.equal(TriggerProxy.trigger.getCall(1).args[2], 'media:ready');
           assert.deepEqual(TriggerProxy.trigger.getCall(1).args[3], {type: 'remoteAudio', stream: true});
 
-          pc.ontrack({track: 'track', transceiver: {mid: '1'}});
+          eventListeners[MC.Event.REMOTE_TRACK_ADDED]({track: 'track', type: MC.RemoteTrackType.VIDEO});
           assert.equal(TriggerProxy.trigger.getCall(2).args[2], 'media:ready');
           assert.deepEqual(TriggerProxy.trigger.getCall(2).args[3], {type: 'remoteVideo', stream: true});
 
-          pc.ontrack({transceiver: {mid: '2'}, track: 'track'});
+          eventListeners[MC.Event.REMOTE_TRACK_ADDED]({track: 'track', type: MC.RemoteTrackType.SCREENSHARE_VIDEO});
           assert.equal(TriggerProxy.trigger.getCall(3).args[2], 'media:ready');
           assert.deepEqual(TriggerProxy.trigger.getCall(3).args[3], {type: 'remoteShare', stream: true});
+        });
 
+        describe('should send correct metrics for ROAP_FAILURE event', () => {
+          const fakeErrorMessage = 'test error';
+          const fakeRootCauseName = 'root cause name';
+          const fakeErrorName = 'test error name';
 
-          // special case for safari
-          pc.ontrack({target: {audioTransceiver: {receiver: {track: {id: 'trackId'}}}}, transceiver: {}, track: {id: 'trackId'}});
-          assert.equal(TriggerProxy.trigger.getCall(1).args[2], 'media:ready');
-          assert.deepEqual(TriggerProxy.trigger.getCall(1).args[3], {type: 'remoteAudio', stream: true});
+          beforeEach(() => {
+            meeting.setupMediaConnectionListeners();
+          });
+
+          const checkMetricSent = (event) => {
+            assert.calledOnce(Metrics.postEvent);
+            assert.calledWithMatch(Metrics.postEvent, {event, meetingId: meeting.id, data: {canProceed: false}});
+          };
+
+          const checkBehavioralMetricSent = (metricName, expectedCode, expectedReason, expectedMetadataType) => {
+            assert.calledOnce(Metrics.sendBehavioralMetric);
+            assert.calledWith(
+              Metrics.sendBehavioralMetric,
+              metricName,
+              {
+                code: expectedCode,
+                correlation_id: meeting.correlationId,
+                reason: expectedReason,
+                stack: sinon.match.any
+              },
+              {
+                type: expectedMetadataType
+              }
+            );
+          };
+
+          it('should send metrics for SdpOfferCreationError error', () => {
+            const fakeError = new MC.Errors.SdpOfferCreationError(fakeErrorMessage, {name: fakeErrorName, cause: {name: fakeRootCauseName}});
+
+            eventListeners[MC.Event.ROAP_FAILURE](fakeError);
+
+            checkMetricSent(eventType.LOCAL_SDP_GENERATED);
+            checkBehavioralMetricSent(BEHAVIORAL_METRICS.PEERCONNECTION_FAILURE, MC.Errors.ErrorCode.SdpOfferCreationError, fakeErrorMessage, fakeRootCauseName);
+          });
+
+          it('should send metrics for SdpOfferHandlingError error', () => {
+            const fakeError = new MC.Errors.SdpOfferHandlingError(fakeErrorMessage, {name: fakeErrorName, cause: {name: fakeRootCauseName}});
+
+            eventListeners[MC.Event.ROAP_FAILURE](fakeError);
+
+            checkMetricSent(eventType.REMOTE_SDP_RECEIVED);
+            checkBehavioralMetricSent(BEHAVIORAL_METRICS.PEERCONNECTION_FAILURE, MC.Errors.ErrorCode.SdpOfferHandlingError, fakeErrorMessage, fakeRootCauseName);
+          });
+
+          it('should send metrics for SdpAnswerHandlingError error', () => {
+            const fakeError = new MC.Errors.SdpAnswerHandlingError(fakeErrorMessage, {name: fakeErrorName, cause: {name: fakeRootCauseName}});
+
+            eventListeners[MC.Event.ROAP_FAILURE](fakeError);
+
+            checkMetricSent(eventType.REMOTE_SDP_RECEIVED);
+            checkBehavioralMetricSent(BEHAVIORAL_METRICS.PEERCONNECTION_FAILURE, MC.Errors.ErrorCode.SdpAnswerHandlingError, fakeErrorMessage, fakeRootCauseName);
+          });
+
+          it('should send metrics for SdpError error', () => {
+            // SdpError is usually without a cause
+            const fakeError = new MC.Errors.SdpError(fakeErrorMessage, {name: fakeErrorName});
+
+            eventListeners[MC.Event.ROAP_FAILURE](fakeError);
+
+            checkMetricSent(eventType.LOCAL_SDP_GENERATED);
+            // expectedMetadataType is the error name in this case
+            checkBehavioralMetricSent(BEHAVIORAL_METRICS.INVALID_ICE_CANDIDATE, MC.Errors.ErrorCode.SdpError, fakeErrorMessage, fakeErrorName);
+          });
+
+          it('should send metrics for IceGatheringError error', () => {
+            // IceGatheringError is usually without a cause
+            const fakeError = new MC.Errors.IceGatheringError(fakeErrorMessage, {name: fakeErrorName});
+
+            eventListeners[MC.Event.ROAP_FAILURE](fakeError);
+
+            checkMetricSent(eventType.LOCAL_SDP_GENERATED);
+            // expectedMetadataType is the error name in this case
+            checkBehavioralMetricSent(BEHAVIORAL_METRICS.INVALID_ICE_CANDIDATE, MC.Errors.ErrorCode.IceGatheringError, fakeErrorMessage, fakeErrorName);
+          });
+        });
+
+        describe('handles MC.Event.ROAP_MESSAGE_TO_SEND correctly', () => {
+          let sendRoapOKStub;
+          let sendRoapMediaRequestStub;
+          let sendRoapAnswerStub;
+          let sendRoapErrorStub;
+
+          beforeEach(() => {
+            sendRoapOKStub = sinon.stub(meeting.roap, 'sendRoapOK').resolves({});
+            sendRoapMediaRequestStub = sinon.stub(meeting.roap, 'sendRoapMediaRequest').resolves({});
+            sendRoapAnswerStub = sinon.stub(meeting.roap, 'sendRoapAnswer').resolves({});
+            sendRoapErrorStub = sinon.stub(meeting.roap, 'sendRoapError').resolves({});
+
+            meeting.setupMediaConnectionListeners();
+          });
+
+          it('handles OK message correctly', () => {
+            eventListeners[MC.Event.ROAP_MESSAGE_TO_SEND]({roapMessage: {messageType: 'OK', seq: 1}});
+
+            assert.calledOnce(Metrics.postEvent);
+            assert.calledWithMatch(Metrics.postEvent, {event: eventType.REMOTE_SDP_RECEIVED, meetingId: meeting.id});
+
+            assert.calledOnce(sendRoapOKStub);
+            assert.calledWith(sendRoapOKStub, {seq: 1, mediaId: meeting.mediaId, correlationId: meeting.correlationId});
+          });
+
+          it('handles OFFER message correctly', () => {
+            eventListeners[MC.Event.ROAP_MESSAGE_TO_SEND]({
+              roapMessage: {
+                messageType: 'OFFER',
+                seq: 1,
+                sdp: 'fake sdp',
+                tieBreaker: 12345,
+              }
+            });
+
+            assert.calledOnce(Metrics.postEvent);
+            assert.calledWithMatch(Metrics.postEvent, {event: eventType.LOCAL_SDP_GENERATED, meetingId: meeting.id});
+
+            assert.calledOnce(sendRoapMediaRequestStub);
+            assert.calledWith(sendRoapMediaRequestStub, {
+              seq: 1, sdp: 'fake sdp', tieBreaker: 12345, meeting, reconnect: false
+            });
+          });
+
+          it('handles ANSWER message correctly', () => {
+            eventListeners[MC.Event.ROAP_MESSAGE_TO_SEND]({
+              roapMessage: {
+                messageType: 'ANSWER',
+                seq: 10,
+                sdp: 'fake sdp answer',
+                tieBreaker: 12345,
+              }
+            });
+
+            assert.calledOnce(Metrics.postEvent);
+            assert.calledWithMatch(Metrics.postEvent, {event: eventType.REMOTE_SDP_RECEIVED, meetingId: meeting.id});
+
+            assert.calledOnce(sendRoapAnswerStub);
+            assert.calledWith(sendRoapAnswerStub, {
+              seq: 10, sdp: 'fake sdp answer', mediaId: meeting.mediaId, correlationId: meeting.correlationId
+            });
+          });
+
+          it('sends metrics if fails to send roap ANSWER message', async () => {
+            sendRoapAnswerStub.rejects(new Error('sending answer failed'));
+
+            await eventListeners[MC.Event.ROAP_MESSAGE_TO_SEND]({
+              roapMessage: {
+                messageType: 'ANSWER',
+                seq: 10,
+                sdp: 'fake sdp answer',
+                tieBreaker: 12345,
+              }
+            });
+            await testUtils.flushPromises();
+
+            assert.calledOnce(Metrics.sendBehavioralMetric);
+            assert.calledWithMatch(Metrics.sendBehavioralMetric, BEHAVIORAL_METRICS.ROAP_ANSWER_FAILURE, {
+              correlation_id: meeting.correlationId,
+              locus_id: meeting.locusUrl.split('/').pop(),
+              reason: 'sending answer failed'
+            });
+          });
+
+          [MC.ErrorType.CONFLICT, MC.ErrorType.DOUBLECONFLICT].forEach((errorType) =>
+            it(`handles ERROR message indicating glare condition correctly (errorType=${errorType})`, () => {
+              eventListeners[MC.Event.ROAP_MESSAGE_TO_SEND]({
+                roapMessage: {
+                  messageType: 'ERROR',
+                  seq: 10,
+                  errorType,
+                  tieBreaker: 12345,
+                }
+              });
+
+              assert.calledOnce(Metrics.sendBehavioralMetric);
+              assert.calledWithMatch(Metrics.sendBehavioralMetric, BEHAVIORAL_METRICS.ROAP_GLARE_CONDITION, {
+                correlation_id: meeting.correlationId,
+                locus_id: meeting.locusUrl.split('/').pop(),
+                sequence: 10
+              });
+
+              assert.calledOnce(sendRoapErrorStub);
+              assert.calledWith(sendRoapErrorStub, {
+                seq: 10, errorType, mediaId: meeting.mediaId, correlationId: meeting.correlationId
+              });
+            }));
+
+          it('handles ERROR message indicating other errors correctly', () => {
+            eventListeners[MC.Event.ROAP_MESSAGE_TO_SEND]({
+              roapMessage: {
+                messageType: 'ERROR',
+                seq: 10,
+                errorType: MC.ErrorType.FAILED,
+                tieBreaker: 12345,
+              }
+            });
+
+            assert.notCalled(Metrics.sendBehavioralMetric);
+
+            assert.calledOnce(sendRoapErrorStub);
+            assert.calledWith(sendRoapErrorStub, {
+              seq: 10,
+              errorType: MC.ErrorType.FAILED,
+              mediaId: meeting.mediaId,
+              correlationId: meeting.correlationId
+            });
+          });
         });
       });
       describe('#setUpLocusInfoSelfListener', () => {
@@ -3514,13 +3713,13 @@ describe('plugin-meetings', () => {
         });
       });
       describe('#closePeerConnections', () => {
-        it('should close the peer connections, and return a promise', async () => {
-          PeerConnectionManager.close = sinon.stub().returns(Promise.resolve());
+        it('should close the webrtc media connection, and return a promise', async () => {
+          meeting.mediaProperties.webrtcMediaConnection = {close: sinon.stub()};
           const pcs = meeting.closePeerConnections();
 
           assert.exists(pcs.then);
           await pcs;
-          assert.calledOnce(PeerConnectionManager.close);
+          assert.calledOnce(meeting.mediaProperties.webrtcMediaConnection.close);
         });
       });
       describe('#unsetPeerConnections', () => {
@@ -3687,13 +3886,6 @@ describe('plugin-meetings', () => {
           });
         });
       });
-      describe('#setRoapSeq', () => {
-        it('should set the roap seq and return null', () => {
-          assert.equal(-1, meeting.roapSeq);
-          meeting.setRoapSeq(1);
-          assert.equal(meeting.roapSeq, 1);
-        });
-      });
       describe('#setCorrelationId', () => {
         it('should set the correlationId and return undefined', () => {
           assert.ok(meeting.correlationId);