@100mslive/react-native-hms 1.3.0 → 1.5.0

package/lib/typescript/classes/HMSSubscribeDegradationPolicy.d.ts

@@ -0,0 +1,10 @@
+export declare class HMSSubscribeDegradationPolicy {
+    packetLossThreshold?: number;
+    degradeGracePeriodSeconds?: number;
+    recoverGracePeriodSeconds?: number;
+    constructor(params: {
+        packetLossThreshold?: number;
+        degradeGracePeriodSeconds?: number;
+        recoverGracePeriodSeconds?: number;
+    });
+}

package/lib/typescript/classes/HMSSubscribeSettings.d.ts

@@ -1,8 +1,11 @@
+import type { HMSSubscribeDegradationPolicy } from './HMSSubscribeDegradationPolicy';
 export declare class HMSSubscribeSettings {
-    subscribeTo?: [string];
+    subscribeTo?: string[];
     maxSubsBitRate: number;
+    subscribeDegradation?: HMSSubscribeDegradationPolicy;
     constructor(params: {
-        subscribeTo?: [string];
+        subscribeTo?: string[];
         maxSubsBitRate: number;
+        subscribeDegradation?: HMSSubscribeDegradationPolicy;
     });
 }

package/lib/typescript/classes/HMSVideoResolution.d.ts

@@ -2,7 +2,7 @@ export declare class HMSVideoResolution {
     height?: number;
     width?: number;
     constructor(params: {
-        height: number;
-        width: number;
+        height?: number;
+        width?: number;
     });
 }

package/lib/typescript/classes/HmsView.d.ts

@@ -1,13 +1,13 @@
 import React from 'react';
 import { ViewStyle } from 'react-native';
 import { HMSVideoViewMode } from './HMSVideoViewMode';
-interface HmsComponentProps {
+export interface HmsComponentProps {
     trackId: string;
     style?: ViewStyle;
     mirror?: boolean;
+    autoSimulcast?: boolean;
     scaleType?: HMSVideoViewMode;
     setZOrderMediaOverlay?: boolean;
     id: string;
 }
 export declare const HmsViewComponent: React.ForwardRefExoticComponent<HmsComponentProps & React.RefAttributes<any>>;
-export {};

package/lib/typescript/index.d.ts

@@ -75,6 +75,11 @@ export * from './classes/HMSLogSettings';
 export * from './classes/HMSLogAlarmManager';
 export * from './classes/HMSMessageType';
 export * from './classes/HMSPIPListenerActions';
+export * from './classes/HMSLayer';
+export * from './classes/HMSSimulcastLayerDefinition';
+export * from './classes/HMSQualityLimitationReasons';
+export * from './classes/HMSQualityLimitationReason';
+export * from './classes/HMSCameraControl';
 export type { HmsViewComponent as HMSView } from './classes/HmsView';
 import { HMSSDK as HmsManager } from './classes/HMSSDK';
 export default HmsManager;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@100mslive/react-native-hms",
-  "version": "1.3.0",
-  "description": "The React Native package for 100ms SDK",
+  "version": "1.5.0",
+  "description": "Integrate Real Time Audio and Video conferencing, Interactive Live Streaming, and Chat in your apps with 100ms React Native SDK. With support for HLS and RTMP Live Streaming and Recording, Picture-in-Picture (PiP), one-to-one Video Call Modes, Audio Rooms, Video Player and much more, add immersive real-time communications to your apps.",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
   "types": "lib/typescript/index.d.ts",

package/sdk-versions.json

@@ -1,5 +1,5 @@
 {
-  "ios": "0.8.1",
-  "iOSBroadcastExtension": "0.0.8",
-  "android": "2.5.9"
+  "ios": "0.9.2",
+  "iOSBroadcastExtension": "0.0.9",
+  "android": "2.6.1"
 }

package/src/classes/HMSCameraControl.ts

@@ -0,0 +1,21 @@
+import { NativeModules } from 'react-native';
+import { HMSConstants } from './HMSConstants';
+
+const { HMSManager } = NativeModules;
+
+export class HMSCameraControl {
+  /**
+   * It captures the image from the device camera at max possible resolution.
+   *
+   * @param {boolean} [flash=false] flash - value indicating whether to use flash while capturing image or not
+   * @returns Promise - which is resolved with the file path of the captured image saved on the disk
+   */
+  static captureImageAtMaxSupportedResolution(
+    flash: boolean = false
+  ): Promise<string> {
+    return HMSManager.captureImageAtMaxSupportedResolution({
+      id: HMSConstants.DEFAULT_SDK_ID,
+      flash,
+    });
+  }
+}

package/src/classes/HMSEncoder.ts

@@ -32,6 +32,13 @@ import { HMSMessageRecipient } from './HMSMessageRecipient';
 import { HMSException } from './HMSException';
 import { HMSConstants } from './HMSConstants';
 import { HMSPeerUpdateOrdinals } from './HMSPeerUpdate';
+import { HMSLocalAudioStats } from './HMSLocalAudioStats';
+import { HMSLocalVideoStats } from './HMSLocalVideoStats';
+import { HMSRemoteAudioStats } from './HMSRemoteAudioStats';
+import { HMSRemoteVideoStats } from './HMSRemoteVideoStats';
+import { HMSLayer } from './HMSLayer';
+import { HMSSimulcastLayerDefinition } from './HMSSimulcastLayerDefinition';
+import { HMSQualityLimitationReasons } from './HMSQualityLimitationReasons';
 
 const { HMSManager } = NativeModules;
 
@@ -46,10 +53,10 @@ export class HMSEncoder {
     this.data = { roles: {} };
   }
 
-  static encodeHmsRoom(room: HMSRoom, id: string) {
+  static encodeHmsRoom(room: any, id: string) {
     const encodedObj = {
       id: room?.id,
-      sessionId: room?.sessionId,
+      sessionId: room?.sessionId || undefined,
       metaData: room?.metaData,
       name: room?.name,
       peerCount: room?.peerCount,
@@ -70,6 +77,7 @@ export class HMSEncoder {
         room?.hlsRecordingState
       ),
       localPeer: HMSEncoder.encodeHmsLocalPeer(room?.localPeer, id),
+      // startedAt: HMSEncoder.encodeDate(room?.startedAt),
     };
 
     return new HMSRoom(encodedObj);
@@ -278,7 +286,6 @@ export class HMSEncoder {
             trackId: peer?.remoteVideoTrackData?.trackId,
             source: peer?.remoteVideoTrackData?.source,
             trackDescription: peer?.remoteVideoTrackData?.trackDescription,
-            layer: peer?.remoteVideoTrackData?.layer,
             isMute: peer?.remoteVideoTrackData?.isMute,
             playbackAllowed: peer?.remoteVideoTrackData?.playbackAllowed,
           }
@@ -307,7 +314,6 @@ export class HMSEncoder {
       trackId: track?.trackId,
       source: track?.source,
       trackDescription: track?.trackDescription,
-      layer: track?.layer,
       isMute: track?.isMute,
       playbackAllowed: track?.playbackAllowed,
     };
@@ -393,14 +399,24 @@ export class HMSEncoder {
   }
 
   static encodeRTCStatsUnit(data: any) {
+    const [
+      bitrateReceived,
+      bitrateSent,
+      bytesReceived,
+      bytesSent,
+      packetsLost,
+      packetsReceived,
+      roundTripTime,
+    ] = data;
+
     return new HMSRTCStats({
-      bitrateReceived: data?.bitrateReceived,
-      bitrateSent: data?.bitrateSent,
-      bytesReceived: data?.bytesReceived,
-      bytesSent: data?.bytesSent,
-      packetsLost: data?.packetsLost,
-      packetsReceived: data?.packetsReceived,
-      roundTripTime: data?.roundTripTime,
+      bitrateReceived,
+      bitrateSent,
+      bytesReceived,
+      bytesSent,
+      packetsLost,
+      packetsReceived,
+      roundTripTime,
     });
   }
 
@@ -544,4 +560,102 @@ export class HMSEncoder {
       canRetry: data?.error?.canRetry,
     });
   }
+
+  static encodeHMSLocalAudioStats(data: any) {
+    const [bitrate, bytesSent, roundTripTime] = data;
+
+    return new HMSLocalAudioStats({
+      bitrate: bitrate >= 0 ? bitrate : undefined,
+      bytesSent: bytesSent ? bytesSent : undefined,
+      roundTripTime: roundTripTime >= 0 ? roundTripTime : undefined,
+    });
+  }
+
+  static encodeHMSLocalVideoStats(data: any[]) {
+    return data.map((item: any) => {
+      const [
+        bitrate,
+        bytesSent,
+        roundTripTime,
+        frameRate,
+        resolution,
+        layer,
+        qualityLimitationReasons,
+      ] = item;
+
+      return new HMSLocalVideoStats({
+        bitrate: bitrate >= 0 ? bitrate : undefined,
+        bytesSent: bytesSent ? bytesSent : undefined,
+        roundTripTime: roundTripTime >= 0 ? roundTripTime : undefined,
+        frameRate: frameRate >= 0 ? frameRate : undefined,
+        resolution: resolution
+          ? { width: resolution[0], height: resolution[1] }
+          : undefined, // resolution: [width, height]
+        layer: layer ? layer : undefined,
+        qualityLimitationReasons: qualityLimitationReasons
+          ? this.encodeHMSQualityLimitationReasons(qualityLimitationReasons)
+          : undefined,
+      });
+    });
+  }
+
+  static encodeHMSRemoteAudioStats(data: any) {
+    const [bitrate, bytesReceived, jitter, packetsLost, packetsReceived] = data;
+
+    return new HMSRemoteAudioStats({
+      bitrate: bitrate >= 0 ? bitrate : undefined,
+      bytesReceived: bytesReceived ? bytesReceived : undefined,
+      jitter: jitter >= 0 ? jitter : undefined,
+      packetsLost: packetsLost >= 0 ? packetsLost : undefined,
+      packetsReceived: packetsReceived ? packetsReceived : undefined,
+    });
+  }
+
+  static encodeHMSRemoteVideoStats(data: any) {
+    const [
+      bitrate,
+      bytesReceived,
+      frameRate,
+      jitter,
+      packetsLost,
+      packetsReceived,
+      resolution,
+    ] = data;
+
+    return new HMSRemoteVideoStats({
+      bitrate: bitrate >= 0 ? bitrate : undefined,
+      bytesReceived: bytesReceived ? bytesReceived : undefined,
+      frameRate: frameRate >= 0 ? frameRate : undefined,
+      jitter: jitter >= 0 ? jitter : undefined,
+      packetsLost: packetsLost >= 0 ? packetsLost : undefined,
+      packetsReceived: packetsReceived ? packetsReceived : undefined,
+      resolution: resolution
+        ? { width: resolution[0], height: resolution[1] }
+        : undefined, // resolution: [width, height]
+    });
+  }
+
+  static encodeHMSSimulcastLayerDefinition(data: any[]) {
+    return data.map((sld) => {
+      return new HMSSimulcastLayerDefinition({
+        layer: HMSLayer[sld.layer as HMSLayer], // DOUBT: This can be invalid. Should we throw error?
+        resolution: this.encodeHmsVideoResolution({
+          width: sld.resolution[0],
+          height: sld.resolution[1],
+        }),
+      });
+    });
+  }
+
+  static encodeHMSQualityLimitationReasons(data: any) {
+    return new HMSQualityLimitationReasons({
+      reason: data.reason,
+      bandwidth: data.bandwidth,
+      cpu: data.cpu,
+      none: data.none,
+      other: data.other,
+      qualityLimitationResolutionChanges:
+        data.qualityLimitationResolutionChanges,
+    });
+  }
 }

package/src/classes/HMSLayer.ts

@@ -0,0 +1,5 @@
+export enum HMSLayer {
+  LOW = 'LOW',
+  MEDIUM = 'MEDIUM',
+  HIGH = 'HIGH',
+}

package/src/classes/HMSLocalVideoStats.ts

@@ -1,23 +1,44 @@
+import type { HMSLayer } from './HMSLayer';
+import type { HMSQualityLimitationReasons } from './HMSQualityLimitationReasons';
 import type { HMSVideoResolution } from './HMSVideoResolution';
 
 export class HMSLocalVideoStats {
+  // Outgoing bitrate of this track observed since previous report in Kb/s.
   bitrate?: number;
+
+  // Total bytes sent by this track in the current session.
   bytesSent?: number;
+
+  // Round trip time observed since previous report
   roundTripTime?: number;
+
+  // Frame rate of video frames being sent (FPS)
   frameRate?: number;
+
+  // Resolution of video frames being sent
   resolution?: HMSVideoResolution;
 
+  // Reason for quality limitations
+  qualityLimitationReasons?: HMSQualityLimitationReasons;
+
+  /// Simulcast Layer
+  layer?: HMSLayer;
+
   constructor(params: {
     bitrate?: number;
     bytesSent?: number;
     roundTripTime?: number;
     frameRate?: number;
     resolution?: HMSVideoResolution;
+    qualityLimitationReasons?: HMSQualityLimitationReasons;
+    layer?: HMSLayer;
   }) {
     this.bitrate = params.bitrate;
     this.bytesSent = params.bytesSent;
     this.roundTripTime = params.roundTripTime;
     this.frameRate = params.frameRate;
     this.resolution = params.resolution;
+    this.qualityLimitationReasons = params.qualityLimitationReasons;
+    this.layer = params.layer;
   }
 }

package/src/classes/HMSPeer.ts

@@ -9,7 +9,7 @@ import { HMSConstants } from './HMSConstants';
 export class HMSPeer {
   peerID: string;
   /**
-   * @deprecated customerDescription has been deprecated in favor of metadata
+   * @deprecated customerDescription property has been deprecated in favor of metadata property
    */
   customerDescription?: string;
 

package/src/classes/HMSPublishSettings.ts

@@ -1,21 +1,25 @@
 import type { HMSAudioSettings } from './HMSAudioSettings';
 import type { HMSVideoSettings } from './HMSVideoSettings';
+import type { HMSSimulcastSettings } from './HMSSimulcastSettings';
 
 export class HMSPublishSettings {
   audio?: HMSAudioSettings;
   video?: HMSVideoSettings;
   screen?: HMSVideoSettings;
   allowed?: string[];
+  simulcast?: HMSSimulcastSettings;
 
   constructor(params: {
     audio?: HMSAudioSettings;
     video?: HMSVideoSettings;
     screen?: HMSVideoSettings;
     allowed?: string[];
+    simulcast?: HMSSimulcastSettings;
   }) {
     this.audio = params.audio;
     this.video = params.video;
     this.screen = params.screen;
     this.allowed = params.allowed;
+    this.simulcast = params.simulcast;
   }
 }

package/src/classes/HMSQualityLimitationReason.ts

@@ -0,0 +1,7 @@
+export enum HMSQualityLimitationReason {
+  BANDWIDTH = 'BANDWIDTH',
+  CPU = 'CPU',
+  NONE = 'NONE',
+  OTHER = 'OTHER',
+  UNKNOWN = 'UNKNOWN',
+}

package/src/classes/HMSQualityLimitationReasons.ts

@@ -0,0 +1,27 @@
+import type { HMSQualityLimitationReason } from './HMSQualityLimitationReason';
+
+export class HMSQualityLimitationReasons {
+  bandwidth?: number;
+  cpu?: number;
+  none?: number;
+  other?: number;
+  qualityLimitationResolutionChanges?: number;
+  reason: HMSQualityLimitationReason;
+
+  constructor(params: {
+    bandwidth?: number;
+    cpu?: number;
+    none?: number;
+    other?: number;
+    qualityLimitationResolutionChanges?: number;
+    reason: HMSQualityLimitationReason;
+  }) {
+    this.bandwidth = params.bandwidth;
+    this.cpu = params.cpu;
+    this.none = params.none;
+    this.other = params.other;
+    this.qualityLimitationResolutionChanges =
+      params.qualityLimitationResolutionChanges;
+    this.reason = params.reason;
+  }
+}

package/src/classes/HMSRemotePeer.ts

@@ -30,7 +30,6 @@ export class HMSRemotePeer extends HMSPeer {
       source?: number | string;
       trackDescription?: string;
       isMute?: boolean;
-      layer?: any;
       playbackAllowed?: boolean;
       id: string;
     };

package/src/classes/HMSRemoteVideoTrack.ts

@@ -2,6 +2,9 @@ import { NativeModules } from 'react-native';
 import { getLogger } from './HMSLogger';
 import { HMSVideoTrack } from './HMSVideoTrack';
 import type { HMSTrackType } from './HMSTrackType';
+import type { HMSLayer } from './HMSLayer';
+import type { HMSSimulcastLayerDefinition } from './HMSSimulcastLayerDefinition';
+import { HMSEncoder } from './HMSEncoder';
 
 const {
   /**
@@ -11,8 +14,6 @@ const {
 } = NativeModules;
 
 export class HMSRemoteVideoTrack extends HMSVideoTrack {
-  layer?: any; //TODO: layer to be made HMSSimulcastLayer type
-
   /**
    * Switches Video of remote user on/off depending upon the value of playbackAllowed
    *
@@ -54,17 +55,64 @@ export class HMSRemoteVideoTrack extends HMSVideoTrack {
     }
   };
 
+  async getLayer() {
+    const logger = getLogger();
+    logger?.verbose('#Function getLayer', {
+      id: this.id,
+      trackId: this.trackId,
+    });
+
+    const layer: HMSLayer = await HMSManager.getVideoTrackLayer({
+      id: this.id,
+      trackId: this.trackId,
+    });
+
+    return layer;
+  }
+
+  async getLayerDefinition() {
+    const logger = getLogger();
+    logger?.verbose('#Function getLayerDefinition', {
+      id: this.id,
+      trackId: this.trackId,
+    });
+
+    const layerDefinition: HMSSimulcastLayerDefinition[] =
+      await HMSManager.getVideoTrackLayerDefinition({
+        id: this.id,
+        trackId: this.trackId,
+      });
+
+    return HMSEncoder.encodeHMSSimulcastLayerDefinition(layerDefinition);
+  }
+
+  async setLayer(layer: HMSLayer) {
+    const logger = getLogger();
+    logger?.verbose('#Function setVideoTrackLayer', {
+      id: this.id,
+      trackId: this.trackId,
+      layer,
+    });
+
+    const success = await HMSManager.setVideoTrackLayer({
+      id: this.id,
+      trackId: this.trackId,
+      layer,
+    });
+
+    return success;
+  }
+
   constructor(params: {
     trackId: string;
     source?: number | string;
     trackDescription?: string;
     isMute?: boolean;
-    layer?: any;
     playbackAllowed?: boolean;
     id: string;
+    isDegraded?: boolean;
     type?: HMSTrackType;
   }) {
     super(params);
-    this.layer = params.layer;
   }
 }

package/src/classes/HMSRoom.ts

@@ -10,9 +10,11 @@ import { HMSConstants } from './HMSConstants';
 
 export class HMSRoom {
   id: string;
+  // startedAt?: Date;
 
   constructor(params: { id: string }) {
     this.id = params.id;
+    // this.startedAt = params.startedAt;
   }
 
   get sessionId(): string {

package/src/classes/HMSRoomUpdate.ts

@@ -6,4 +6,5 @@ export enum HMSRoomUpdate {
   BROWSER_RECORDING_STATE_UPDATED = 'BROWSER_RECORDING_STATE_UPDATED',
   HLS_STREAMING_STATE_UPDATED = 'HLS_STREAMING_STATE_UPDATED',
   HLS_RECORDING_STATE_UPDATED = 'HLS_RECORDING_STATE_UPDATED',
+  ROOM_PEER_COUNT_UPDATED = 'ROOM_PEER_COUNT_UPDATED',
 }