@wazo/sdk 0.38.5 → 0.38.8

package/src/utils/__tests__/object.test.js

@@ -0,0 +1,35 @@
+// @flow
+import { convertKeysFromCamelToUnderscore } from '../object';
+
+describe('object utils', () => {
+  describe('convertKeysFromCamelToUnderscore', () => {
+    it('should throw an error when input is not an object', () => {
+      const msg = 'Input is not an object';
+      expect(() => convertKeysFromCamelToUnderscore(true)).toThrow(msg);
+      expect(() => convertKeysFromCamelToUnderscore(null)).toThrow(msg);
+      expect(() => convertKeysFromCamelToUnderscore(undefined)).toThrow(msg);
+      expect(() => convertKeysFromCamelToUnderscore([])).toThrow(msg);
+      expect(() => convertKeysFromCamelToUnderscore('some-string')).toThrow(msg);
+    });
+
+    it('should convert camel-cased keys to underscore', () => {
+      let value = Math.random();
+      expect(convertKeysFromCamelToUnderscore({ LoremIpsum: value })).toEqual({ lorem_ipsum: value });
+      value = Math.random();
+      expect(convertKeysFromCamelToUnderscore({ loremIpsum: value })).toEqual({ lorem_ipsum: value });
+      value = Math.random();
+      expect(convertKeysFromCamelToUnderscore({ 'lorem-ipsum': value })).toEqual({ 'lorem-ipsum': value });
+      value = Math.random();
+      expect(convertKeysFromCamelToUnderscore({ L123: value })).toEqual({ l123: value });
+    });
+
+    it('should handle multi-leveled object', () => {
+      const value = Math.random();
+      expect(convertKeysFromCamelToUnderscore({ LoremIpsum: { DoloreSit: { Amet: value }, regular: 'reg' } }))
+        .toEqual({ lorem_ipsum: { dolore_sit: { amet: value }, regular: 'reg' } });
+
+      expect(convertKeysFromCamelToUnderscore({ LoremIpsum: { DoloreSit: { Amet: [value] }, regular: ['something'] } }))
+        .toEqual({ lorem_ipsum: { dolore_sit: { amet: [value] }, regular: ['something'] } });
+    });
+  });
+});

package/src/utils/__tests__/sdp.test.js

@@ -9,7 +9,7 @@ import {
   fixSdp,
   fixBundle,
   toggleVideoDirection,
-  hasAnActiveVideo,
+  hasAnActiveVideo, addIcesInAllBundles,
 } from '../sdp';
 
 const goodSdp = `
@@ -174,4 +174,36 @@ describe('SDP utils', () => {
       expect(hasAnActiveVideo(inactiveVideo)).toBeFalsy();
     });
   });
+
+  describe('Adding candidate in all bundles ', () => {
+    it('should add candidate everywhere', async () => {
+      const audioWithoutCandidate = `
+c=IN IP4 203.0.113.1
+m=audio 54400 RTP/SAVPF 0 96
+m=video 54400 RTP/SAVPF 0 96
+a=candidate:0 1 UDP 2113667327 203.0.113.1 54400 typ host
+a=candidate:3996450952 1 udp 41819903 14.72.21.2 65092 typ relay raddr 0.0.0.0 rport 0 generation 0 network-id 3 network-cost 10
+`;
+      const fixedAudioWithoutCandidate = sdpParser.parse(addIcesInAllBundles(audioWithoutCandidate));
+
+      expect(fixedAudioWithoutCandidate.media[0].candidates[0].type).toBe('host');
+      expect(fixedAudioWithoutCandidate.media[0].candidates[1].type).toBe('relay');
+      expect(fixedAudioWithoutCandidate.media[1].candidates[0].type).toBe('host');
+      expect(fixedAudioWithoutCandidate.media[1].candidates[1].type).toBe('relay');
+
+      // It should not add candidate if already present
+      const audioWithCandidate = `
+c=IN IP4 203.0.113.1
+m=audio 54400 RTP/SAVPF 0 96
+a=candidate:0 1 UDP 2113667327 203.0.113.1 54400 typ srflx
+
+m=video 54400 RTP/SAVPF 0 96
+a=candidate:0 1 UDP 2113667327 203.0.113.1 54400 typ host
+`;
+      const fixedAudioWithCandidate = sdpParser.parse(addIcesInAllBundles(audioWithCandidate));
+
+      expect(fixedAudioWithCandidate.media[0].candidates[0].type).toBe('srflx');
+      expect(fixedAudioWithCandidate.media[1].candidates[0].type).toBe('host');
+    });
+  });
 });

package/src/utils/__tests__/string.test.js

@@ -0,0 +1,23 @@
+import { camelToUnderscore } from '../string';
+
+describe('string utils', () => {
+  describe('camelToUnderscore', () => {
+    it('', () => {
+      expect(() => camelToUnderscore(null)).toThrow('Input is not a string');
+      expect(() => camelToUnderscore(undefined)).toThrow('Input is not a string');
+      expect(() => camelToUnderscore({})).toThrow('Input is not a string');
+      expect(() => camelToUnderscore([])).toThrow('Input is not a string');
+    });
+
+    it('should convert camel-cased string to underscore', () => {
+      expect(camelToUnderscore('loremIpsum')).toEqual('lorem_ipsum');
+      expect(camelToUnderscore('lorem-ipsum')).toEqual('lorem-ipsum');
+      expect(camelToUnderscore('')).toEqual('');
+    });
+
+    it('should not prefix string with an underscore', () => {
+      expect(camelToUnderscore('LoremIpsum')).toEqual('lorem_ipsum');
+      expect(camelToUnderscore('L123')).toEqual('l123');
+    });
+  });
+});

package/src/utils/object.js

@@ -0,0 +1,15 @@
+// @flow
+
+import { camelToUnderscore } from './string';
+
+export const convertKeysFromCamelToUnderscore = (args: Object) => {
+  if (!args || typeof args !== 'object' || Array.isArray(args)) {
+    throw new Error('Input is not an object');
+  }
+
+  return Object.keys(args).reduce((acc, key) => {
+    acc[camelToUnderscore(key)] = typeof args[key] === 'object' && !Array.isArray(args[key])
+      ? convertKeysFromCamelToUnderscore(args[key]) : args[key];
+    return acc;
+  }, {});
+};

package/src/utils/sdp.js

@@ -120,3 +120,21 @@ export const fixSdp = (sdp: string, candidates: Object[], forcePort: boolean = t
 
   return fixed;
 };
+
+export const addIcesInAllBundles = (sdp: string) => {
+  const parsedSdp = sdpParser.parse(sdp);
+
+  const mediaWithCandidate = parsedSdp.media.find(media => !!media.candidates);
+  if (!mediaWithCandidate) {
+    return sdp;
+  }
+
+  const { candidates } = mediaWithCandidate;
+
+  parsedSdp.media = parsedSdp.media.map(media => ({
+    ...media,
+    candidates: media.candidates || candidates,
+  }));
+
+  return sdpParser.write(parsedSdp);
+};

package/src/utils/string.js

@@ -0,0 +1,8 @@
+// @flow
+
+export const camelToUnderscore = (key: string) => {
+  if (typeof key !== 'string') {
+    throw new Error('Input is not a string');
+  }
+  return key.charAt(0).toLowerCase() + key.substring(1).replace(/([A-Z])/g, '_$1').toLowerCase();
+};

package/src/web-rtc-client.js

@@ -1070,41 +1070,58 @@ export default class WebRTCClient extends Emitter {
     });
   }
 
-  changeAudioInputDevice(id: string, session: ?Inviter) {
+  async changeAudioInputDevice(id: string, session: ?Inviter, force: ?boolean) {
     const currentId = this.getAudioDeviceId();
     logger.info('setting audio input device', { id, currentId, session: !!session });
 
-    if (id === currentId) {
+    if (!force && id === currentId) {
       return null;
     }
 
+    // in order to handle an audio track change for default devices
+    // we need the actual id of the device (not 'default')
+    let deviceId = id;
+    if (id === 'default' && navigator.mediaDevices) {
+      const devices = await navigator.mediaDevices.enumerateDevices();
+      const defaultDevice = devices.find(device => device.deviceId === 'default');
+      if (defaultDevice) {
+        const deviceLabel = defaultDevice.label.replace('Default - ', '');
+        const targetDevice = devices.find(device => device.label === deviceLabel);
+        if (targetDevice) {
+          deviceId = targetDevice.deviceId;
+          if (!force && deviceId === currentId) {
+            return null;
+          }
+        }
+      }
+    }
+
     // let's update the local audio value
     if (this.audio) {
       this.audio = {
         deviceId: {
-          exact: id,
+          exact: deviceId,
         },
       };
     }
 
-    if (session) {
+    if (session && navigator.mediaDevices) {
       const sdh = session.sessionDescriptionHandler;
       const pc = sdh.peerConnection;
 
-      // $FlowFixMe
-      return navigator.mediaDevices.getUserMedia({ audio: { deviceId: { exact: id } } }).then(async stream => {
-        const audioTrack = stream.getAudioTracks()[0];
-        const sender = pc && pc.getSenders().find(s => audioTrack && s && s.track && s.track.kind === audioTrack.kind);
+      const constraints = { audio: { deviceId: { exact: deviceId } } };
+      const stream = await navigator.mediaDevices.getUserMedia(constraints);
+      const audioTrack = stream.getAudioTracks()[0];
+      const sender = pc && pc.getSenders().find(s => audioTrack && s && s.track && s.track.kind === audioTrack.kind);
 
-        if (sender) {
-          if (sender.track) {
-            audioTrack.enabled = sender.track.enabled;
-          }
-          sender.replaceTrack(audioTrack);
+      if (sender) {
+        if (sender.track) {
+          audioTrack.enabled = sender.track.enabled;
         }
+        sender.replaceTrack(audioTrack);
+      }
 
-        return stream;
-      });
+      return stream;
     }
   }
 
@@ -1124,14 +1141,14 @@ export default class WebRTCClient extends Emitter {
       return null;
     }
 
-    // let's update the local video value
-    if (this.video) {
-      this.video = {
-        deviceId: {
-          exact: id,
-        },
-      };
-    }
+    // let's make sure we don't lose other video constraints settings -- width, height, frameRate...
+    const videoObject = typeof this.video === 'object' ? this.video : {};
+    this.video = {
+      ...videoObject,
+      deviceId: {
+        exact: id,
+      },
+    };
   }
 
   changeSessionVideoInputDevice(id: ?string, session: Inviter) {

package/src/websocket-client.js

@@ -94,6 +94,7 @@ export const AGENT_UNPAUSED = 'agent_unpaused';
 export const CONFERENCE_ADHOC_PARTICIPANT_LEFT = 'conference_adhoc_participant_left';
 export const CONFERENCE_ADHOC_DELETED = 'conference_adhoc_deleted';
 export const MEETING_USER_PROGRESS = 'meeting_user_progress';
+export const MEETING_USER_GUEST_AUTHORIZATION_CREATED = 'meeting_user_guest_authorization_created';
 
 const BLACKLIST_EVENTS = [
   CHAT_MESSAGE_SENT,
@@ -448,6 +449,7 @@ WebSocketClient.eventLists = [
   CONFERENCE_ADHOC_PARTICIPANT_LEFT,
   CONFERENCE_ADHOC_DELETED,
   MEETING_USER_PROGRESS,
+  MEETING_USER_GUEST_AUTHORIZATION_CREATED,
 ];
 
 export default WebSocketClient;