@100mslive/hms-video-store 0.10.29-alpha.1 → 0.11.0

package/src/rtc-stats/HMSWebrtcStats.ts

@@ -0,0 +1,140 @@
+import {
+  computeNumberRate,
+  getLocalPeerStatsFromReport,
+  getLocalTrackStats,
+  getPacketsLostAndJitterFromReport,
+  getTrackStats,
+  union,
+} from './utils';
+import AnalyticsEventFactory from '../analytics/AnalyticsEventFactory';
+import { ErrorFactory } from '../error/ErrorFactory';
+import { HMSAction } from '../error/HMSAction';
+import { EventBus } from '../events/EventBus';
+import { HMSPeerStats, HMSTrackStats, PeerConnectionType } from '../interfaces/webrtc-stats';
+import { HMSLocalTrack, HMSRemoteAudioTrack, HMSRemoteTrack, HMSRemoteVideoTrack } from '../media/tracks';
+import { Store } from '../sdk/store';
+import HMSLogger from '../utils/logger';
+
+export class HMSWebrtcStats {
+  private readonly TAG = '[HMSWebrtcStats]';
+  private localPeerID?: string;
+  private peerStats: Record<string, HMSPeerStats> = {};
+  private remoteTrackStats: Record<string, HMSTrackStats> = {};
+  private localTrackStats: Record<string, Record<string, HMSTrackStats>> = {};
+
+  /**
+   * Removed localPeerID check in other places as it will be present before
+   * this is initialized
+   */
+  constructor(
+    private getStats: Record<PeerConnectionType, RTCPeerConnection['getStats'] | undefined>,
+    private store: Store,
+    private readonly eventBus: EventBus,
+  ) {
+    this.localPeerID = this.store.getLocalPeer()?.peerId;
+  }
+
+  getLocalPeerStats = (): HMSPeerStats | undefined => {
+    return this.peerStats[this.localPeerID!];
+  };
+
+  getRemoteTrackStats = (trackId: string): HMSTrackStats | undefined => {
+    return this.remoteTrackStats[trackId];
+  };
+
+  getAllRemoteTracksStats = () => {
+    return this.remoteTrackStats;
+  };
+
+  getLocalTrackStats = () => {
+    return this.localTrackStats;
+  };
+
+  /**
+   * @internal
+   */
+  updateStats = async () => {
+    await this.updateLocalPeerStats();
+    await this.updateLocalTrackStats();
+    await this.updateRemoteTrackStats();
+  };
+
+  private updateLocalPeerStats = async () => {
+    const prevLocalPeerStats = this.getLocalPeerStats();
+    let publishReport: RTCStatsReport | undefined;
+    try {
+      publishReport = await this.getStats.publish?.();
+    } catch (err: any) {
+      this.eventBus.analytics.publish(
+        AnalyticsEventFactory.rtcStatsFailed(ErrorFactory.WebrtcErrors.StatsFailed(HMSAction.PUBLISH, err.message)),
+      );
+      HMSLogger.w(this.TAG, 'Error in getting publish stats', err);
+    }
+    const publishStats: HMSPeerStats['publish'] | undefined =
+      publishReport && getLocalPeerStatsFromReport('publish', publishReport, prevLocalPeerStats);
+
+    let subscribeReport: RTCStatsReport | undefined;
+    try {
+      subscribeReport = await this.getStats.subscribe?.();
+    } catch (err: any) {
+      this.eventBus.analytics.publish(
+        AnalyticsEventFactory.rtcStatsFailed(ErrorFactory.WebrtcErrors.StatsFailed(HMSAction.SUBSCRIBE, err.message)),
+      );
+      HMSLogger.w(this.TAG, 'Error in getting subscribe stats', err);
+    }
+    const baseSubscribeStats =
+      subscribeReport && getLocalPeerStatsFromReport('subscribe', subscribeReport, prevLocalPeerStats);
+    const { packetsLost, jitter } = getPacketsLostAndJitterFromReport(subscribeReport);
+    const packetsLostRate = computeNumberRate(
+      packetsLost,
+      prevLocalPeerStats?.subscribe?.packetsLost,
+      baseSubscribeStats?.timestamp,
+      prevLocalPeerStats?.subscribe?.timestamp,
+    );
+
+    const subscribeStats: HMSPeerStats['subscribe'] =
+      baseSubscribeStats && Object.assign(baseSubscribeStats, { packetsLostRate, jitter, packetsLost });
+
+    this.peerStats[this.localPeerID!] = { publish: publishStats, subscribe: subscribeStats };
+  };
+
+  private updateRemoteTrackStats = async () => {
+    const tracks = Array.from(this.store.getTracksMap().values()).filter(
+      track => track instanceof HMSRemoteVideoTrack || track instanceof HMSRemoteAudioTrack,
+    );
+    const trackIds = tracks.map(track => track.trackId);
+    Object.keys(this.remoteTrackStats).forEach(trackId => {
+      if (!trackIds.includes(trackId)) {
+        delete this.remoteTrackStats[trackId];
+      }
+    });
+    for (const track of tracks) {
+      const peerName = track.peerId && this.store.getPeerById(track.peerId)?.name;
+      const prevTrackStats = this.getRemoteTrackStats(track.trackId);
+      const trackStats = await getTrackStats(this.eventBus, track as HMSRemoteTrack, peerName, prevTrackStats);
+      if (trackStats) {
+        this.remoteTrackStats[track.trackId] = trackStats;
+      }
+    }
+  };
+
+  private updateLocalTrackStats = async () => {
+    const tracks = this.store.getLocalPeerTracks().reduce<Record<string, HMSLocalTrack>>((res, track) => {
+      res[track.getTrackIDBeingSent()] = track;
+      return res;
+    }, {});
+    const trackIDs = union(Object.keys(this.localTrackStats), Object.keys(tracks));
+    for (const trackID of trackIDs) {
+      const track = tracks[trackID] as HMSLocalTrack;
+      if (track) {
+        const peerName = this.store.getLocalPeer()?.name;
+        const trackStats = await getLocalTrackStats(this.eventBus, track, peerName, this.localTrackStats[trackID]);
+        if (trackStats) {
+          this.localTrackStats[trackID] = trackStats;
+        }
+      } else {
+        delete this.localTrackStats[trackID];
+      }
+    }
+  };
+}

package/src/rtc-stats/index.ts

@@ -0,0 +1,2 @@
+export { HMSWebrtcInternals } from './HMSWebrtcInternals';
+export { HMSWebrtcStats } from './HMSWebrtcStats';

package/src/rtc-stats/utils.ts

@@ -0,0 +1,266 @@
+import AnalyticsEventFactory from '../analytics/AnalyticsEventFactory';
+import { ErrorFactory } from '../error/ErrorFactory';
+import { HMSAction } from '../error/HMSAction';
+import { EventBus } from '../events/EventBus';
+import { RID } from '../interfaces';
+import {
+  HMSLocalTrackStats,
+  HMSPeerStats,
+  HMSTrackStats,
+  MissingInboundStats,
+  PeerConnectionType,
+  RTCRemoteInboundRtpStreamStats,
+} from '../interfaces/webrtc-stats';
+import { HMSLocalTrack, HMSRemoteTrack } from '../media/tracks';
+import HMSLogger from '../utils/logger';
+import { isPresent } from '../utils/validations';
+
+export const getLocalTrackStats = async (
+  eventBus: EventBus,
+  track: HMSLocalTrack,
+  peerName?: string,
+  prevTrackStats?: Record<string, HMSTrackStats>,
+): Promise<Record<string, HMSTrackStats> | undefined> => {
+  let trackReport: RTCStatsReport | undefined;
+  const trackStats: Record<string, HMSTrackStats> = {};
+  if (!track.transceiver?.sender.track) {
+    return;
+  }
+  try {
+    trackReport = await track.transceiver.sender.getStats();
+    const mimeTypes: { [key: string]: string } = {}; // codecId -> mimeType
+    const outbound: Record<string, RTCOutboundRtpStreamStats> = {};
+    const inbound: Record<string, RTCInboundRtpStreamStats & MissingInboundStats> = {};
+    trackReport?.forEach(stat => {
+      switch (stat.type) {
+        case 'outbound-rtp':
+          outbound[stat.id] = stat;
+          break;
+        case 'remote-inbound-rtp':
+          inbound[stat.ssrc] = stat;
+          break;
+        case 'codec':
+          mimeTypes[stat.id] = stat.mimeType;
+          break;
+        default:
+          break;
+      }
+    });
+
+    Object.keys({ ...outbound }).forEach(stat => {
+      const codecId = outbound[stat]?.codecId;
+      const mimeType = codecId ? mimeTypes[codecId] : undefined;
+      let codec: string | undefined;
+      if (mimeType) {
+        codec = mimeType.substring(mimeType.indexOf('/') + 1);
+      }
+      const out = { ...outbound[stat], rid: (outbound[stat] as HMSLocalTrackStats)?.rid as RID | undefined };
+      const inStats = inbound[out.ssrc];
+      trackStats[stat] = {
+        ...out,
+        bitrate: computeBitrate('bytesSent', out, prevTrackStats?.[stat]),
+        packetsLost: inStats?.packetsLost,
+        jitter: inStats?.jitter,
+        roundTripTime: inStats?.roundTripTime,
+        totalRoundTripTime: inStats?.totalRoundTripTime,
+        peerName,
+        peerID: track.peerId,
+        enabled: track.enabled,
+        codec,
+      };
+    });
+  } catch (err: any) {
+    eventBus.analytics.publish(
+      AnalyticsEventFactory.rtcStatsFailed(
+        ErrorFactory.WebrtcErrors.StatsFailed(
+          HMSAction.TRACK,
+          `Error getting local track stats ${track.trackId} - ${err.message}`,
+        ),
+      ),
+    );
+    HMSLogger.w('[HMSWebrtcStats]', 'Error in getting local track stats', track, err, (err as Error).name);
+  }
+  return trackStats;
+};
+
+export const getTrackStats = async (
+  eventBus: EventBus,
+  track: HMSRemoteTrack,
+  peerName?: string,
+  prevTrackStats?: HMSTrackStats,
+): Promise<HMSTrackStats | undefined> => {
+  let trackReport: RTCStatsReport | undefined;
+  try {
+    trackReport = await track.transceiver?.receiver.getStats();
+  } catch (err: any) {
+    eventBus.analytics.publish(
+      AnalyticsEventFactory.rtcStatsFailed(
+        ErrorFactory.WebrtcErrors.StatsFailed(
+          HMSAction.TRACK,
+          `Error getting remote track stats ${track.trackId} - ${err.message}`,
+        ),
+      ),
+    );
+    HMSLogger.w('[HMSWebrtcStats]', 'Error in getting remote track stats', track, err);
+  }
+  const trackStats = getRelevantStatsFromTrackReport(trackReport);
+
+  const bitrate = computeBitrate('bytesReceived', trackStats, prevTrackStats);
+
+  const packetsLostRate = computeStatRate('packetsLost', trackStats, prevTrackStats);
+
+  if (trackStats?.remote) {
+    Object.assign(trackStats.remote, {
+      packetsLostRate: computeStatRate('packetsLost', trackStats.remote, prevTrackStats?.remote),
+    });
+  }
+
+  return (
+    trackStats &&
+    Object.assign(trackStats, {
+      bitrate,
+      packetsLostRate,
+      peerId: track.peerId,
+      enabled: track.enabled,
+      peerName,
+      codec: trackStats.codec,
+    })
+  );
+};
+
+const getRelevantStatsFromTrackReport = (trackReport?: RTCStatsReport) => {
+  let streamStats: RTCInboundRtpStreamStats | (RTCOutboundRtpStreamStats & { rid?: RID }) | undefined;
+  // Valid by Webrtc spec, not in TS
+  // let remoteStreamStats: RTCRemoteInboundRtpStreamStats | RTCRemoteOutboundRtpStreamStats;
+  let remoteStreamStats: RTCRemoteInboundRtpStreamStats | undefined;
+
+  const mimeTypes: { [key: string]: string } = {}; // codecId -> mimeType
+  trackReport?.forEach(stat => {
+    switch (stat.type) {
+      case 'inbound-rtp':
+        streamStats = stat;
+        break;
+      case 'outbound-rtp':
+        streamStats = stat;
+        break;
+      case 'remote-inbound-rtp':
+        remoteStreamStats = stat;
+        break;
+      case 'codec':
+        mimeTypes[stat.id] = stat.mimeType;
+        break;
+      default:
+        break;
+    }
+  });
+
+  const mimeType = streamStats?.codecId ? mimeTypes[streamStats.codecId] : undefined;
+  let codec: string | undefined;
+  if (mimeType) {
+    codec = mimeType.substring(mimeType.indexOf('/') + 1);
+  }
+
+  return (
+    streamStats &&
+    Object.assign(streamStats, {
+      remote: remoteStreamStats,
+      codec: codec,
+    })
+  );
+};
+
+export const getLocalPeerStatsFromReport = (
+  type: PeerConnectionType,
+  report?: RTCStatsReport,
+  prevStats?: HMSPeerStats,
+): (RTCIceCandidatePairStats & { bitrate: number }) | undefined => {
+  const activeCandidatePair = getActiveCandidatePairFromReport(report);
+  const bitrate = computeBitrate(
+    (type === 'publish' ? 'bytesSent' : 'bytesReceived') as any,
+    activeCandidatePair,
+    prevStats && prevStats[type],
+  );
+
+  return activeCandidatePair && Object.assign(activeCandidatePair, { bitrate });
+};
+
+export const getActiveCandidatePairFromReport = (report?: RTCStatsReport): RTCIceCandidatePairStats | undefined => {
+  let activeCandidatePair: RTCIceCandidatePairStats | undefined;
+  report?.forEach(stat => {
+    if (stat.type === 'transport') {
+      // TS doesn't have correct types for RTCStatsReports
+      // @ts-expect-error
+      activeCandidatePair = report?.get(stat.selectedCandidatePairId);
+    }
+  });
+
+  // Fallback for Firefox.
+  if (!activeCandidatePair) {
+    report?.forEach(stat => {
+      if (stat.type === 'candidate-pair' && stat.selected) {
+        activeCandidatePair = stat;
+      }
+    });
+  }
+
+  return activeCandidatePair;
+};
+
+export const getPacketsLostAndJitterFromReport = (report?: RTCStatsReport): { packetsLost: number; jitter: number } => {
+  const result = { packetsLost: 0, jitter: 0 };
+  report?.forEach(stat => {
+    if (stat.packetsLost) {
+      result.packetsLost += stat.packetsLost;
+    }
+    if (stat.jitter > result.jitter) {
+      result.jitter = stat.jitter;
+    }
+  });
+
+  return result;
+};
+
+export const union = <T>(arr1: T[], arr2: T[]): T[] => {
+  return Array.from(new Set(arr1.concat(arr2)));
+};
+
+/**
+ * Ref: https://github.dev/peermetrics/webrtc-stats/blob/b5c1fed68325543e6f563c6d3f4450a4b51e12b7/src/utils.ts#L62
+ */
+export const computeBitrate = <T extends HMSTrackStats>(
+  statName: keyof T,
+  newReport?: Partial<T>,
+  oldReport?: Partial<T>,
+): number => computeStatRate(statName, newReport, oldReport) * 8; // Bytes to bits
+
+const computeStatRate = <T extends HMSTrackStats>(
+  statName: keyof T,
+  newReport?: Partial<T>,
+  oldReport?: Partial<T>,
+): number => {
+  const newVal = newReport && newReport[statName];
+  const oldVal = oldReport ? oldReport[statName] : null;
+  const conditions = [newReport, oldReport, isPresent(newVal), isPresent(oldVal)];
+  if (conditions.every(condition => !!condition)) {
+    // Type not null checked in `isPresent`
+    // * 1000 - ms to s
+    return (
+      computeNumberRate(
+        newVal as unknown as number,
+        oldVal as unknown as number,
+        newReport?.timestamp,
+        oldReport?.timestamp,
+      ) * 1000
+    );
+  } else {
+    return 0;
+  }
+};
+
+export const computeNumberRate = (newVal?: number, oldVal?: number, newTimestamp?: number, oldTimestamp?: number) => {
+  if (isPresent(newVal) && isPresent(oldVal) && newTimestamp && oldTimestamp) {
+    return ((newVal as number) - (oldVal as number)) / (newTimestamp - oldTimestamp);
+  } else {
+    return 0;
+  }
+};

package/src/{core/schema → schema}/device-change.ts

@@ -1,5 +1,5 @@
 import { HMSException } from './error';
-import { DeviceMap } from '../hmsSDKStore/sdkTypes';
+import { DeviceMap } from '../interfaces';
 
 export type { DeviceMap };
 

package/src/{core/schema → schema}/index.ts

@@ -11,4 +11,3 @@ export * from './device-change';
 export * from './playlist';
 export * from './session-store';
 export * from './playlist-selectors';
-export * from './interactivity-center';

package/src/{core/schema → schema}/message.ts

@@ -36,4 +36,6 @@ export interface HMSMessageInput {
   recipientRoles?: HMSRoleName[];
   type?: string;
   message: any;
+  id: string;
+  time: number;
 }

package/src/{core/schema → schema}/notification.ts

@@ -1,10 +1,10 @@
-import { HMSPoll } from '@100mslive/hms-video';
 import { HMSDeviceChangeEvent } from './device-change';
 import { HMSException } from './error';
 import { HMSMessage } from './message';
 import { HMSPeer, HMSTrack } from './peer';
 import { HMSPlaylistItem } from './playlist';
 import { HMSChangeMultiTrackStateRequest, HMSChangeTrackStateRequest, HMSLeaveRoomRequest } from './requests';
+import { HMSPoll } from '../internal';
 
 interface BaseNotification {
   id: number;

package/src/{core/schema → schema}/peer.ts

@@ -4,7 +4,7 @@ import {
   HMSSimulcastLayer,
   HMSSimulcastLayerDefinition,
   ScreenCaptureHandle,
-} from '../hmsSDKStore/sdkTypes';
+} from '../interfaces';
 
 export type HMSPeerID = string;
 export type HMSTrackID = string;

package/src/{core/schema → schema}/role.ts

@@ -1,4 +1,4 @@
-import type { HMSRole } from '@100mslive/hms-video';
+import type { HMSRole } from '../interfaces';
 
 export type HMSRoleName = string;
 

package/src/{core/schema → schema}/room.ts

@@ -1,5 +1,5 @@
-import { HLSVariant, HMSHLS, HMSRecording, HMSRTMP } from '@100mslive/hms-video';
 import { HMSPeerID } from './peer';
+import { HLSVariant, HMSHLS, HMSRecording, HMSRTMP } from '../interfaces';
 
 export type { HMSRecording, HMSRTMP, HMSHLS, HLSVariant };
 export type HMSRoomID = string;

package/src/{core/schema → schema}/schema.ts

@@ -6,14 +6,7 @@ import { HMSRoleChangeStoreRequest } from './requests';
 import { HMSRole } from './role';
 import { HMSRoom, HMSRoomState } from './room';
 import { HMSMediaSettings } from './settings';
-import {
-  DeviceMap,
-  HMSConnectionQuality,
-  HMSPeerStats,
-  HMSPoll,
-  HMSTrackStats,
-  HMSWhiteboard,
-} from '../hmsSDKStore/sdkTypes';
+import { DeviceMap, HMSConnectionQuality, HMSPeerStats, HMSPoll, HMSTrackStats, HMSWhiteboard } from '../interfaces';
 
 export interface HMSGenericTypes {
   sessionStore: Record<string, any>;

package/src/sdk/HMSPeerListIterator.ts

@@ -0,0 +1,73 @@
+import { HMSRemotePeer } from './models/peer';
+import { Store } from './store';
+import { HMSPeerListIteratorOptions } from '../interfaces/peer-list-iterator';
+import { PeerNotificationInfo } from '../notification-manager';
+import { createRemotePeer } from '../notification-manager/managers/utils';
+import { PeersIterationResponse } from '../signal/interfaces';
+import HMSTransport from '../transport';
+
+export class HMSPeerListIterator {
+  private isEnd = false;
+  private iterator: string | null = null;
+  private total = 0;
+  private defaultPaginationLimit = 10;
+  constructor(private transport: HMSTransport, private store: Store, private options?: HMSPeerListIteratorOptions) {}
+
+  private validateConnection() {
+    if (!this.transport || !this.store) {
+      throw Error(`Use usePaginatedParticipants or hmsActions.getPeerListIterator after preview or join has happened`);
+    }
+  }
+
+  hasNext(): boolean {
+    return !this.isEnd;
+  }
+
+  getTotal(): number {
+    return this.total;
+  }
+
+  async findPeers() {
+    this.validateConnection();
+    const response = await this.transport.signal.findPeers({
+      ...(this.options || {}),
+      limit: this.options?.limit || this.defaultPaginationLimit,
+    });
+    this.updateState(response);
+    return this.processPeers(response.peers);
+  }
+
+  async next() {
+    this.validateConnection();
+    let response: PeersIterationResponse;
+    if (!this.iterator && !this.isEnd) {
+      return await this.findPeers();
+    } else if (this.iterator) {
+      response = await this.transport.signal.peerIterNext({
+        iterator: this.iterator,
+        limit: this.options?.limit || this.defaultPaginationLimit,
+      });
+      this.updateState(response);
+      return this.processPeers(response.peers);
+    }
+    return [];
+  }
+
+  private processPeers(peers: PeerNotificationInfo[]) {
+    const hmsPeers: HMSRemotePeer[] = [];
+    peers.forEach(peer => {
+      const hmsPeer = createRemotePeer(peer, this.store);
+      hmsPeers.push(hmsPeer);
+    });
+    return hmsPeers;
+  }
+
+  private updateState(response: PeersIterationResponse) {
+    this.isEnd = response.eof;
+    this.total = response.total;
+    // iterator is only received once in findpeer -  reuse the same iterator
+    if (response.iterator) {
+      this.iterator = response.iterator;
+    }
+  }
+}