feat(calling): adding metrics for bnr

docs/samples/calling/app.js

@@ -85,6 +85,7 @@ const directoryNumberCFA = document.querySelector('#directoryNumber');
 const cfaDataElem = document.querySelector('#callforwardalways-data');
 const makeCallBtn = document.querySelector('#create-call-action');
 const muteElm = document.getElementById('mute_button');
+const bnrButton = document.getElementById('bnr_button');
 
 let base64;
 let audio64;
@@ -615,22 +616,27 @@ async function getMediaStreams() {
   makeCallBtn.disabled = false;
 }
 
-async function addNoiseReductionEffect() {
+async function toggleNoiseReductionEffect() {
   effect = await localAudioStream.getEffect('background-noise-removal');
 
   if (!effect) {
     effect = await Calling.createNoiseReductionEffect(tokenElm.value);
 
     await localAudioStream.addEffect('background-noise-removal', effect);
-  }
-
-  await effect.enable();
-}
-
-async function removeNoiseReductionEffect() {
-  effect = await localAudioStream.getEffect('background-noise-removal');
-  if (effect) {
-    await effect.disable();
+    await effect.enable();
+    console.log('pkesari_Created new effect and enabling it: ', effect.isEnabled);
+    bnrButton.innerHTML = 'Disable BNR()';
+  } else {
+    console.log('pkesari_Effect is present and is enabled: ', effect.isEnabled);
+    if (effect.isEnabled) {
+      await effect.disable();
+      console.log('pkesari_Disabling effect: ', effect.isEnabled);
+      bnrButton.innerHTML = 'Enable BNR()';
+    } else {
+      await effect.enable();
+      console.log('pkesari_Enabling effect: ', effect.isEnabled);
+      bnrButton.innerHTML = 'Disable BNR()';
+    }
   }
 }
 

docs/samples/calling/index.html

@@ -120,10 +120,8 @@ <h2 class="collapsible">Call initialization</h2>
                 class="btn-code">getMediaStreams()</button>
             </div>
             <div class="u-mv">
-              <button id="sd-add-bnr" type="button" onclick="addNoiseReductionEffect()"
+              <button id="bnr_button" type="button" onclick="toggleNoiseReductionEffect()"
               class="btn-code">Enable BNR()</button>
-              <button id="sd-add-bnr" type="button" onclick="removeNoiseReductionEffect()"
-              class="btn-code">Disable BNR()</button>
             </div>
           </fieldset>
 

packages/@webex/media-helpers/package.json

@@ -24,7 +24,7 @@
   "dependencies": {
     "@webex/internal-media-core": "^2.0.0",
     "@webex/ts-events": "^1.1.0",
-    "@webex/web-media-effects": "^2.13.1"
+    "@webex/web-media-effects": "^2.13.3"
   },
   "browserify": {
     "transform": [

packages/calling/src/CallingClient/calling/call.test.ts

@@ -7,7 +7,7 @@ import * as Utils from '../../common/Utils';
 import {CALL_EVENT_KEYS, CallEvent, RoapEvent, RoapMessage} from '../../Events/types';
 import {DEFAULT_SESSION_TIMER} from '../constants';
 import {CallDirection, CallType, ServiceIndicator, WebexRequestPayload} from '../../common/types';
-import {METRIC_EVENT, TRANSFER_ACTION, METRIC_TYPE} from '../../Metrics/types';
+import {METRIC_EVENT, TRANSFER_ACTION, METRIC_TYPE, MEDIA_EFFECT_ACTION} from '../../Metrics/types';
 import {Call, createCall} from './call';
 import {
   MobiusCallState,
@@ -36,25 +36,6 @@ const defaultServiceIndicator = ServiceIndicator.CALLING;
 const activeUrl = 'FakeActiveUrl';
 const mockLineId = 'e4e8ee2a-a154-4e52-8f11-ef4cde2dce72';
 
-// class MockMediaStream {
-//   private track;
-
-//   constructor(track: any) {
-//     this.track = track;
-//   }
-// }
-
-// globalThis.MediaStream = MockMediaStream;
-
-// // eslint-disable-next-line @typescript-eslint/no-unused-vars
-// jest.spyOn(window, 'MediaStream').mockImplementation((tracks: MediaStreamTrack[]) => {
-//   return {} as MediaStream;
-// });
-
-// // Object.defineProperty(window, 'MediaStream', {
-// //   writable: true,
-// // });
-
 describe('Call Tests', () => {
   const deviceId = '55dfb53f-bed2-36da-8e85-cee7f02aa68e';
   const dest = {
@@ -111,6 +92,10 @@ describe('Call Tests', () => {
     enabled: false,
   } as MediaStreamTrack;
 
+  const mockEffect = {
+    isEnabled: true,
+  };
+
   const roapMediaConnectionConfig = {
     skipInactiveTransceivers: true,
     iceServers: [],
@@ -286,6 +271,9 @@ describe('Call Tests', () => {
         getAudioTracks: jest.fn().mockReturnValue([mockTrack]),
       },
       on: jest.fn(),
+      getEffect: jest.fn().mockImplementation(() => {
+        return mockEffect;
+      }),
     };
 
     const localAudioStream = mockStream as unknown as MediaSDK.LocalMicrophoneStream;
@@ -302,6 +290,8 @@ describe('Call Tests', () => {
       defaultServiceIndicator
     );
 
+    const mediaMetricSpy = jest.spyOn(call['metricManager'], 'submitBNRMetric');
+
     call.dial(localAudioStream);
 
     expect(mockTrack.enabled).toEqual(true);
@@ -311,6 +301,15 @@ describe('Call Tests', () => {
       expect.any(String)
     );
     expect(call['mediaStateMachine'].state.value).toBe('S_SEND_ROAP_OFFER');
+
+    expect(mediaMetricSpy).toBeCalledOnceWith(
+      METRIC_EVENT.MEDIA,
+      MEDIA_EFFECT_ACTION.BNR_ENABLED,
+      METRIC_TYPE.BEHAVIORAL,
+      call.getCallId(),
+      call.getCorrelationId()
+    );
+
     /* Now change the state and recall to check for error */
     call['mediaStateMachine'].state.value = 'S_SEND_ROAP_OFFER';
     call.dial(localAudioStream);
@@ -327,6 +326,9 @@ describe('Call Tests', () => {
         getAudioTracks: jest.fn().mockReturnValue([mockTrack]),
       },
       on: jest.fn(),
+      getEffect: jest.fn().mockImplementation(() => {
+        return mockEffect;
+      }),
     };
 
     const localAudioStream = mockStream as unknown as MediaSDK.LocalMicrophoneStream;
@@ -344,6 +346,8 @@ describe('Call Tests', () => {
     );
     /** Cannot answer in idle state */
 
+    const mediaMetricSpy = jest.spyOn(call['metricManager'], 'submitBNRMetric');
+
     call.answer(localAudioStream);
     expect(mockTrack.enabled).toEqual(true);
     expect(mockMediaSDK.RoapMediaConnection).toBeCalledOnceWith(
@@ -361,6 +365,92 @@ describe('Call Tests', () => {
     call['callStateMachine'].state.value = 'S_SEND_CALL_PROGRESS';
     call.answer(localAudioStream);
     expect(call['callStateMachine'].state.value).toBe('S_SEND_CALL_CONNECT');
+
+    expect(mediaMetricSpy).toBeCalledOnceWith(
+      METRIC_EVENT.MEDIA,
+      MEDIA_EFFECT_ACTION.BNR_ENABLED,
+      METRIC_TYPE.BEHAVIORAL,
+      call.getCallId(),
+      call.getCorrelationId()
+    );
+  });
+
+  it('testing enabling/disabling the BNR on an active call', async () => {
+    const mockStream = {
+      outputStream: {
+        getAudioTracks: jest.fn().mockReturnValue([mockTrack]),
+      },
+      on: jest.fn(),
+      getEffect: jest.fn(),
+    };
+
+    const localAudioStream = mockStream as unknown as MediaSDK.LocalMicrophoneStream;
+    const onSpy = jest.spyOn(localAudioStream, 'on');
+
+    const call = createCall(
+      activeUrl,
+      webex,
+      dest,
+      CallDirection.OUTBOUND,
+      deviceId,
+      mockLineId,
+      deleteCallFromCollection,
+      defaultServiceIndicator
+    );
+
+    call.dial(localAudioStream);
+
+    expect(mockTrack.enabled).toEqual(true);
+    expect(mockMediaSDK.RoapMediaConnection).toBeCalledOnceWith(
+      roapMediaConnectionConfig,
+      roapMediaConnectionOptions,
+      expect.any(String)
+    );
+    expect(call['mediaStateMachine'].state.value).toBe('S_SEND_ROAP_OFFER');
+
+    const updateLocalTracksSpy = jest.spyOn(call['mediaConnection'], 'updateLocalTracks');
+    const mediaMetricSpy = jest.spyOn(call['metricManager'], 'submitBNRMetric');
+
+    /* Send metrics for BNR enabled */
+    jest.spyOn(localAudioStream, 'getEffect').mockReturnValue(mockEffect as any);
+
+    expect(onSpy).toBeCalledOnceWith(
+      MediaSDK.LocalStreamEventNames.OutputTrackChange,
+      expect.any(Function)
+    );
+
+    mediaMetricSpy.mockClear();
+    onSpy.mock.calls[0][1](mockTrack as MediaStreamTrack);
+
+    expect(updateLocalTracksSpy).toBeCalledOnceWith({audio: mockTrack});
+
+    expect(mediaMetricSpy).toBeCalledOnceWith(
+      METRIC_EVENT.MEDIA,
+      MEDIA_EFFECT_ACTION.BNR_ENABLED,
+      METRIC_TYPE.BEHAVIORAL,
+      call.getCallId(),
+      call.getCorrelationId()
+    );
+
+    /* Clear the mocks */
+    updateLocalTracksSpy.mockClear();
+    mediaMetricSpy.mockClear();
+
+    /* Send metrics for BNR disabled */
+    mockEffect.isEnabled = false;
+    jest.spyOn(localAudioStream, 'getEffect').mockReturnValue(mockEffect as any);
+
+    onSpy.mock.calls[0][1](mockTrack as MediaStreamTrack);
+
+    expect(updateLocalTracksSpy).toBeCalledOnceWith({audio: mockTrack});
+
+    expect(mediaMetricSpy).toBeCalledOnceWith(
+      METRIC_EVENT.MEDIA,
+      MEDIA_EFFECT_ACTION.BNR_DISABLED,
+      METRIC_TYPE.BEHAVIORAL,
+      call.getCallId(),
+      call.getCorrelationId()
+    );
   });
 });
 

packages/calling/src/CallingClient/calling/call.ts

@@ -23,6 +23,7 @@ import {CallError, createCallError} from '../../Errors/catalog/CallError';
 /* eslint-disable tsdoc/syntax */
 /* eslint-disable no-param-reassign */
 import {
+  BACKGROUND_NOISE_REMOVAL,
   CALL_ENDPOINT_RESOURCE,
   CALL_FILE,
   CALL_HOLD_SERVICE,
@@ -80,7 +81,13 @@ import {
 import log from '../../Logger';
 import {ICallerId} from './CallerId/types';
 import {createCallerId} from './CallerId';
-import {IMetricManager, METRIC_TYPE, METRIC_EVENT, TRANSFER_ACTION} from '../../Metrics/types';
+import {
+  IMetricManager,
+  METRIC_TYPE,
+  METRIC_EVENT,
+  TRANSFER_ACTION,
+  MEDIA_EFFECT_ACTION,
+} from '../../Metrics/types';
 import {getMetricManager} from '../../Metrics';
 import {SERVICES_ENDPOINT} from '../../common/constants';
 
@@ -1981,6 +1988,17 @@ export class Call extends Eventing<CallEventTypes> implements ICall {
     }
 
     if (this.callStateMachine.state.value === 'S_SEND_CALL_PROGRESS') {
+      const effect = localAudioStream.getEffect(BACKGROUND_NOISE_REMOVAL);
+      if (effect && effect.isEnabled) {
+        this.metricManager.submitBNRMetric(
+          METRIC_EVENT.MEDIA,
+          MEDIA_EFFECT_ACTION.BNR_ENABLED,
+          METRIC_TYPE.BEHAVIORAL,
+          this.callId,
+          this.correlationId
+        );
+      }
+
       this.sendCallStateMachineEvt({type: 'E_SEND_CALL_CONNECT'});
     } else {
       log.warn(
@@ -2006,6 +2024,17 @@ export class Call extends Eventing<CallEventTypes> implements ICall {
     }
 
     if (this.mediaStateMachine.state.value === 'S_ROAP_IDLE') {
+      const effect = localAudioStream.getEffect(BACKGROUND_NOISE_REMOVAL);
+      if (effect && effect.isEnabled) {
+        this.metricManager.submitBNRMetric(
+          METRIC_EVENT.MEDIA,
+          MEDIA_EFFECT_ACTION.BNR_ENABLED,
+          METRIC_TYPE.BEHAVIORAL,
+          this.callId,
+          this.correlationId
+        );
+      }
+
       this.sendMediaStateMachineEvt({type: 'E_SEND_ROAP_OFFER'});
     } else {
       log.warn(
@@ -2400,8 +2429,27 @@ export class Call extends Eventing<CallEventTypes> implements ICall {
   }
 
   private outputTrackUpdateListener(localAudioStream: LocalMicrophoneStream) {
+    let effect;
     localAudioStream.on(LocalStreamEventNames.OutputTrackChange, (track: MediaStreamTrack) => {
       this.mediaConnection.updateLocalTracks({audio: track});
+      effect = localAudioStream.getEffect(BACKGROUND_NOISE_REMOVAL);
+      if (effect && effect.isEnabled) {
+        this.metricManager.submitBNRMetric(
+          METRIC_EVENT.MEDIA,
+          MEDIA_EFFECT_ACTION.BNR_ENABLED,
+          METRIC_TYPE.BEHAVIORAL,
+          this.callId,
+          this.correlationId
+        );
+      } else if (effect && !effect.isEnabled) {
+        this.metricManager.submitBNRMetric(
+          METRIC_EVENT.MEDIA,
+          MEDIA_EFFECT_ACTION.BNR_DISABLED,
+          METRIC_TYPE.BEHAVIORAL,
+          this.callId,
+          this.correlationId
+        );
+      }
     });
   }
 

packages/calling/src/CallingClient/constants.ts

@@ -119,3 +119,4 @@ export const FAILOVER_UTIL = 'startFailoverTimer';
 export const NETWORK_CHANGE_DETECTION_UTIL = 'detectNetworkChange';
 export const CALLS_CLEARED_HANDLER_UTIL = 'callsClearedHandler';
 export const RECONNECT_UTIL = 'reconnectOnFailure';
+export const BACKGROUND_NOISE_REMOVAL = 'background-noise-removal';

packages/calling/src/Metrics/index.ts

@@ -321,6 +321,43 @@ class MetricManager implements IMetricManager {
       this.webex.internal.metrics.submitClientMetrics(name, data);
     }
   }
+
+  public submitBNRMetric(
+    name: METRIC_EVENT,
+    metricAction: string,
+    type: METRIC_TYPE,
+    callId: CallId,
+    correlationId: CorrelationId
+  ) {
+    let data;
+
+    if (METRIC_EVENT.MEDIA) {
+      data = {
+        tags: {
+          action: metricAction,
+          device_id: this.deviceInfo?.device?.deviceId,
+          service_indicator: this.serviceIndicator,
+        },
+        fields: {
+          device_url: this.deviceInfo?.device?.clientDeviceUri,
+          mobius_url: this.deviceInfo?.device?.uri,
+          calling_sdk_version: VERSION,
+          call_id: callId,
+          correlation_id: correlationId,
+        },
+        type,
+      };
+    } else {
+      log.warn('Invalid metric name received. Rejecting request to submit metric.', {
+        file: METRIC_FILE,
+        method: this.submitBNRMetric.name,
+      });
+    }
+
+    if (data) {
+      this.webex.internal.metrics.submitClientMetrics(name, data);
+    }
+  }
 }
 
 /**