@100mslive/hms-video-store 0.12.37 → 0.12.38-alpha.0

package/dist/media/tracks/HMSLocalAudioTrack.d.ts

@@ -20,6 +20,7 @@ export declare class HMSLocalAudioTrack extends HMSAudioTrack {
      * for you to stop, which leads to the microphone not released even after leave is called.
      */
     private tracksCreated;
+    private permissionState?;
     audioLevelMonitor?: TrackAudioLevelMonitor;
     /**
      * see the doc in HMSLocalVideoTrack

package/dist/media/tracks/HMSLocalVideoTrack.d.ts

@@ -16,6 +16,7 @@ export declare class HMSLocalVideoTrack extends HMSVideoTrack {
     private _layerDefinitions;
     private TAG;
     private enabledStateBeforeBackground;
+    private permissionState?;
     /**
      * true if it's screenshare and current tab is what is being shared. Browser dependent, Chromium only
      * at the point of writing this comment.

package/dist/test/setup.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.12.37",
+  "version": "0.12.38-alpha.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -73,5 +73,5 @@
     "conferencing",
     "100ms"
   ],
-  "gitHead": "fb5f4afe6a342bcb25bed49bdb294b797e68b005"
+  "gitHead": "37d70e0a4986c804cb8dcc51fecb4ea1c75761dc"
 }

package/src/analytics/AnalyticsTimer.ts

@@ -31,13 +31,21 @@ export class AnalyticsTimer {
   private eventPerformanceMeasures: Partial<Record<TimedEvent, PerformanceMeasure>> = {};
 
   start(eventName: TimedEvent) {
-    performance.mark(eventName);
+    try {
+      if (typeof performance !== 'undefined' && performance.mark) {
+        performance.mark(eventName);
+      }
+    } catch (error) {
+      HMSLogger.w('[AnalyticsTimer]', `Error marking performance for event ${eventName}`, { error });
+    }
   }
 
   end(eventName: TimedEvent) {
     try {
-      this.eventPerformanceMeasures[eventName] = performance.measure(eventName, eventName);
-      HMSLogger.d('[HMSPerformanceTiming]', eventName, this.eventPerformanceMeasures[eventName]?.duration);
+      if (typeof performance !== 'undefined' && performance.measure) {
+        this.eventPerformanceMeasures[eventName] = performance.measure(eventName, eventName);
+        HMSLogger.d('[HMSPerformanceTiming]', eventName, this.eventPerformanceMeasures[eventName]?.duration);
+      }
     } catch (error) {
       HMSLogger.w('[AnalyticsTimer]', `Error in measuring performance for event ${eventName}`, { error });
     }

package/src/media/tracks/HMSLocalAudioTrack.ts

@@ -2,11 +2,13 @@ import isEqual from 'lodash.isequal';
 import { HMSAudioTrack } from './HMSAudioTrack';
 import AnalyticsEventFactory from '../../analytics/AnalyticsEventFactory';
 import { DeviceStorageManager } from '../../device-manager/DeviceStorage';
+import { ErrorCodes } from '../../error/ErrorCodes';
 import { HMSException } from '../../error/HMSException';
 import { EventBus } from '../../events/EventBus';
 import { HMSAudioTrackSettings as IHMSAudioTrackSettings } from '../../interfaces';
 import { HMSAudioPlugin, HMSPluginSupportResult } from '../../plugins';
 import { HMSAudioPluginsManager } from '../../plugins/audio';
+import { LocalTrackManager } from '../../sdk/LocalTrackManager';
 import Room from '../../sdk/models/HMSRoom';
 import HMSLogger from '../../utils/logger';
 import { getAudioTrack, isEmptyTrack, listenToPermissionChange } from '../../utils/track';
@@ -33,6 +35,7 @@ export class HMSLocalAudioTrack extends HMSAudioTrack {
    */
   private tracksCreated = new Set<MediaStreamTrack>();
 
+  private permissionState?: PermissionState;
   audioLevelMonitor?: TrackAudioLevelMonitor;
 
   /**
@@ -113,18 +116,22 @@ export class HMSLocalAudioTrack extends HMSAudioTrack {
         }),
       );
     } else {
-      HMSLogger.d(this.TAG, 'On visibile replacing track as it is not publishing');
-      try {
-        await this.replaceTrackWith(this.settings);
-      } catch (error) {
-        this.eventBus.error.publish(error as HMSException);
-      }
       this.eventBus.analytics.publish(
         this.sendInterruptionEvent({
           started: false,
           reason: 'visibility-change',
         }),
       );
+      if (this.permissionState && this.permissionState !== 'granted') {
+        HMSLogger.d(this.TAG, 'On visibile not replacing track as permission is not granted');
+        return;
+      }
+      HMSLogger.d(this.TAG, 'On visibile replacing track as it is not publishing');
+      try {
+        await this.replaceTrackWith(this.settings);
+      } catch (error) {
+        this.eventBus.error.publish(error as HMSException);
+      }
     }
   };
 
@@ -161,6 +168,18 @@ export class HMSLocalAudioTrack extends HMSAudioTrack {
       HMSLogger.d(this.TAG, 'replaceTrack, Previous track stopped', prevTrack, 'newTrack', newTrack);
       await this.updateTrack(newTrack);
     } catch (e) {
+      const error = e as HMSException;
+
+      if (
+        error.code === ErrorCodes.TracksErrors.CANT_ACCESS_CAPTURE_DEVICE ||
+        error.code === ErrorCodes.TracksErrors.SYSTEM_DENIED_PERMISSION
+      ) {
+        const newTrack = await LocalTrackManager.getEmptyAudioTrack();
+        this.addTrackEventListeners(newTrack);
+        this.tracksCreated.add(newTrack);
+        await this.updateTrack(newTrack);
+        throw error;
+      }
       // Generate a new track from previous settings so there will be audio because previous track is stopped
       const newTrack = await getAudioTrack(this.settings);
       this.addTrackEventListeners(newTrack);
@@ -317,6 +336,7 @@ export class HMSLocalAudioTrack extends HMSAudioTrack {
 
   private trackPermissions = () => {
     listenToPermissionChange('microphone', (state: PermissionState) => {
+      this.permissionState = state;
       this.eventBus.analytics.publish(AnalyticsEventFactory.permissionChange(this.type, state));
       if (state === 'denied') {
         this.eventBus.localAudioEnabled.publish({ enabled: false, track: this });

package/src/media/tracks/HMSLocalVideoTrack.ts

@@ -3,6 +3,7 @@ import { HMSVideoTrack } from './HMSVideoTrack';
 import { VideoElementManager } from './VideoElementManager';
 import AnalyticsEventFactory from '../../analytics/AnalyticsEventFactory';
 import { DeviceStorageManager } from '../../device-manager/DeviceStorage';
+import { ErrorCodes } from '../../error/ErrorCodes';
 import { ErrorFactory } from '../../error/ErrorFactory';
 import { HMSAction } from '../../error/HMSAction';
 import { HMSException } from '../../error/HMSException';
@@ -40,6 +41,7 @@ export class HMSLocalVideoTrack extends HMSVideoTrack {
   private _layerDefinitions: HMSSimulcastLayerDefinition[] = [];
   private TAG = '[HMSLocalVideoTrack]';
   private enabledStateBeforeBackground = false;
+  private permissionState?: PermissionState;
 
   /**
    * true if it's screenshare and current tab is what is being shared. Browser dependent, Chromium only
@@ -392,7 +394,20 @@ export class HMSLocalVideoTrack extends HMSVideoTrack {
         this.settings = this.buildNewSettings({ deviceId: this.nativeTrack.getSettings().deviceId });
       }
       return newTrack;
-    } catch (error) {
+    } catch (e) {
+      const error = e as HMSException;
+
+      if (
+        error.code === ErrorCodes.TracksErrors.CANT_ACCESS_CAPTURE_DEVICE ||
+        error.code === ErrorCodes.TracksErrors.SYSTEM_DENIED_PERMISSION
+      ) {
+        const track = await this.replaceTrackWithBlank();
+        this.addTrackEventListeners(track);
+        await this.replaceSender(track, this.enabled);
+        this.nativeTrack = track;
+        this.videoHandler.updateSinks();
+        throw error;
+      }
       // Generate a new track from previous settings so there won't be blank tile because previous track is stopped
       const track = await getVideoTrack(this.settings);
       this.addTrackEventListeners(track);
@@ -595,6 +610,17 @@ export class HMSLocalVideoTrack extends HMSVideoTrack {
         }),
       );
     } else {
+      // ended interruption event
+      this.eventBus.analytics.publish(
+        this.sendInterruptionEvent({
+          started: false,
+          reason: 'visibility-change',
+        }),
+      );
+      if (this.permissionState && this.permissionState !== 'granted') {
+        HMSLogger.d(this.TAG, 'On visibile not replacing track as permission is not granted');
+        return;
+      }
       HMSLogger.d(this.TAG, 'visibility visible, restoring track state', this.enabledStateBeforeBackground);
       if (this.enabledStateBeforeBackground) {
         try {
@@ -603,13 +629,6 @@ export class HMSLocalVideoTrack extends HMSVideoTrack {
           this.eventBus.error.publish(error as HMSException);
         }
       }
-      // ended interruption event
-      this.eventBus.analytics.publish(
-        this.sendInterruptionEvent({
-          started: false,
-          reason: 'visibility-change',
-        }),
-      );
     }
   };
 }

package/src/rtc-stats/utils.ts

@@ -189,7 +189,6 @@ export const getActiveCandidatePairFromReport = (report?: RTCStatsReport): RTCIc
   report?.forEach(stat => {
     if (stat.type === 'transport') {
       // TS doesn't have correct types for RTCStatsReports
-      // @ts-expect-error
       activeCandidatePair = report?.get(stat.selectedCandidatePairId);
     }
   });

package/src/test/setup.ts

@@ -0,0 +1,14 @@
+// Setup for Jest tests
+
+// Mock Performance API properly for Jest 29
+global.performance = {
+  mark: jest.fn(),
+  measure: jest.fn(() => ({ duration: 0 } as PerformanceMeasure)),
+  clearMarks: jest.fn(),
+  clearMeasures: jest.fn(),
+  getEntriesByName: jest.fn(() => []),
+  getEntriesByType: jest.fn(() => []),
+  now: jest.fn(() => Date.now()),
+} as any;
+
+export {};

package/src/utils/track.ts

@@ -45,7 +45,9 @@ export const listenToPermissionChange = (
     // @ts-ignore
     .query({ name: permissionName })
     .then(permission => {
+      onChange(permission.state);
       permission.onchange = () => {
+        HMSLogger.d(`${permissionName} permission changed`, permission.state);
         onChange(permission.state);
       };
     })