@100mslive/react-native-hms 0.8.4 → 0.9.2

package/lib/typescript/index.d.ts

@@ -46,6 +46,20 @@ export * from './classes/HMSRtmpStreamingState';
 export * from './classes/HMSServerRecordingState';
 export * from './classes/HMSBrowserRecordingState';
 export * from './classes/HMSRTMPConfig';
+export * from './classes/HMSHLSConfig';
+export * from './classes/HMSHLSMeetingURLVariant';
+export * from './classes/HMSHLSVariant';
+export * from './classes/HMSHLSStreamingState';
 export * from './classes/HMSVideoResolution';
+export * from './classes/HMSLocalAudioStats';
+export * from './classes/HMSLocalVideoStats';
+export * from './classes/HMSRTCStats';
+export * from './classes/HMSRTCStatsReport';
+export * from './classes/HMSRemoteAudioStats';
+export * from './classes/HMSRemoteVideoStats';
+export * from './classes/HMSHLSRecordingConfig';
+export * from './classes/HMSHLSRecordingState';
+export * from './classes/HMSMessageRecipient';
+export * from './classes/HMSMessageRecipientType';
 import { HMSSDK as HmsManager } from './classes/HMSSDK';
 export default HmsManager;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@100mslive/react-native-hms",
-  "version": "0.8.4",
+  "version": "0.9.2",
   "description": "The React Native package for 100ms SDK",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -95,7 +95,6 @@
     "prettier": "^2.0.5",
     "react-native-builder-bob": "^0.18.0",
     "release-it": "^14.2.2",
-    "typedoc": "^0.22.10",
     "typescript": "^4.1.3"
   },
   "peerDependencies": {

package/react-native-hms.podspec

@@ -16,5 +16,5 @@ Pod::Spec.new do |s|
   s.source_files = "ios/**/*.{h,m,mm,swift}"
 
   s.dependency "React-Core"
-  s.dependency "HMSSDK"
+  s.dependency "HMSSDK", "0.2.8"
 end

package/src/classes/HMSBrowserRecordingState.ts

@@ -3,9 +3,18 @@ import type { HMSException } from './HMSException';
 export class HMSBrowserRecordingState {
   running: string;
   error: HMSException;
+  startedAt: Date;
+  stoppedAt: Date;
 
-  constructor(params: { running: string; error: HMSException }) {
+  constructor(params: {
+    running: string;
+    error: HMSException;
+    startedAt: Date;
+    stoppedAt: Date;
+  }) {
     this.running = params.running;
     this.error = params.error;
+    this.startedAt = params.startedAt;
+    this.stoppedAt = params.stoppedAt;
   }
 }

package/src/classes/HMSEncoder.ts

@@ -15,6 +15,20 @@ import { HMSRole } from './HMSRole';
 import { HMSRoleChangeRequest } from './HMSRoleChangeRequest';
 import { HMSChangeTrackStateRequest } from './HMSChangeTrackStateRequest';
 import { HMSVideoResolution } from './HMSVideoResolution';
+import { HMSRTCStats } from './HMSRTCStats';
+import { HMSRTCStatsReport } from './HMSRTCStatsReport';
+import { HMSRemoteAudioTrack } from './HMSRemoteAudioTrack';
+import { HMSRemoteVideoTrack } from './HMSRemoteVideoTrack';
+import { HMSSpeaker } from './HMSSpeaker';
+import { HMSSpeakerUpdate } from './HMSSpeakerUpdate';
+import {
+  HMSBrowserRecordingState,
+  HMSHLSStreamingState,
+  HMSHLSVariant,
+  HMSRtmpStreamingState,
+  HMSServerRecordingState,
+} from '..';
+import { HMSHLSRecordingState } from './HMSHLSRecordingState';
 
 export class HMSEncoder {
   static encodeHmsRoom(room: HMSRoom, id: string) {
@@ -22,10 +36,23 @@ export class HMSEncoder {
       id: room?.id,
       metaData: room?.metaData,
       name: room?.name,
+      peerCount: room?.peerCount,
       peers: HMSEncoder.encodeHmsPeers(room?.peers, id),
-      browserRecordingState: room?.browserRecordingState,
-      rtmpHMSRtmpStreamingState: room?.rtmpHMSRtmpStreamingState,
-      serverRecordingState: room?.serverRecordingState,
+      browserRecordingState: HMSEncoder.encodeBrowserRecordingState(
+        room?.browserRecordingState
+      ),
+      rtmpHMSRtmpStreamingState: HMSEncoder.encodeRTMPStreamingState(
+        room?.rtmpHMSRtmpStreamingState
+      ),
+      serverRecordingState: HMSEncoder.encodeServerRecordingState(
+        room?.serverRecordingState
+      ),
+      hlsStreamingState: HMSEncoder.encodeHLSStreamingState(
+        room?.hlsStreamingState
+      ),
+      hlsRecordingState: HMSEncoder.encodeHLSRecordingState(
+        room?.hlsRecordingState
+      ),
     };
 
     return new HMSRoom(encodedObj);
@@ -182,6 +209,34 @@ export class HMSEncoder {
     return new HMSVideoResolution(encodedObj);
   }
 
+  static encodeHmsLocalAudioTrack(track: any, id: string) {
+    const encodedObj = {
+      id: id,
+      trackId: track?.trackId,
+      source: track?.source,
+      trackDescription: track?.trackDescription,
+      isMute: track?.isMute,
+      settings: HMSEncoder.encodeHmsAudioTrackSettings(track?.settings),
+      type: track?.type,
+    };
+
+    return new HMSLocalAudioTrack(encodedObj);
+  }
+
+  static encodeHmsLocalVideoTrack(track: any, id: string) {
+    const encodedObj = {
+      id: id,
+      trackId: track?.trackId,
+      source: track?.source,
+      trackDescription: track?.trackDescription,
+      isMute: track?.isMute,
+      settings: HMSEncoder.encodeHmsVideoTrackSettings(track?.settings),
+      type: track?.type,
+    };
+
+    return new HMSLocalVideoTrack(encodedObj);
+  }
+
   static encodeHmsRemotePeers(peers: any, id: string) {
     const hmsPeers: any[] = [];
 
@@ -231,6 +286,33 @@ export class HMSEncoder {
     return new HMSRemotePeer(encodedObj);
   }
 
+  static encodeHmsRemoteAudioTrack(track: any, id: string) {
+    const encodedObj = {
+      id: id,
+      trackId: track?.trackId,
+      source: track?.source,
+      trackDescription: track?.trackDescription,
+      isMute: track?.isMute,
+      playbackAllowed: track?.playbackAllowed,
+    };
+
+    return new HMSRemoteAudioTrack(encodedObj);
+  }
+
+  static encodeHmsRemoteVideoTrack(track: any, id: string) {
+    const encodedObj = {
+      id: id,
+      trackId: track?.trackId,
+      source: track?.source,
+      trackDescription: track?.trackDescription,
+      layer: track?.layer,
+      isMute: track?.isMute,
+      playbackAllowed: track?.playbackAllowed,
+    };
+
+    return new HMSRemoteVideoTrack(encodedObj);
+  }
+
   static encodeHmsPreviewTracks(previewTracks: any) {
     const encodedObj = {
       audioTrack: previewTracks.audioTrack
@@ -281,4 +363,112 @@ export class HMSEncoder {
 
     return new HMSChangeTrackStateRequest(encodedChangeTrackStateRequest);
   }
+
+  static encodeRTCStats(data: any) {
+    let video = this.encodeRTCStatsUnit(data?.video);
+    let audio = this.encodeRTCStatsUnit(data?.audio);
+    let combined = this.encodeRTCStatsUnit(data?.combined);
+
+    return new HMSRTCStatsReport({ video, audio, combined });
+  }
+
+  static encodeRTCStatsUnit(data: any) {
+    return new HMSRTCStats({
+      bitrateReceived: data?.bitrateReceived,
+      bitrateSent: data?.bitrateSent,
+      bytesReceived: data?.bytesReceived,
+      bytesSent: data?.bytesSent,
+      packetsLost: data?.packetsLost,
+      packetsReceived: data?.packetsReceived,
+      roundTripTime: data?.roundTripTime,
+    });
+  }
+
+  static encodeHmsSpeakerUpdate(data: any, id: string) {
+    return new HMSSpeakerUpdate({
+      event: data?.event,
+      count: data?.count,
+      peers: HMSEncoder.encodeHmsSpeakers(data?.peers, id),
+    });
+  }
+
+  static encodeHmsSpeakers(data: any, id: string) {
+    let encodedSpeakers: Array<HMSSpeaker> = [];
+
+    data?.map((item: any) => {
+      encodedSpeakers.push(HMSEncoder.encodeHmsSpeaker(item, id));
+    });
+
+    return encodedSpeakers;
+  }
+
+  static encodeHmsSpeaker(data: any, id: string) {
+    return new HMSSpeaker({
+      level: data?.level,
+      peer: HMSEncoder.encodeHmsPeer(data?.peer, id),
+      track: HMSEncoder.encodeHmsTrack(data?.track, id),
+    });
+  }
+
+  static encodeBrowserRecordingState(data: any) {
+    return new HMSBrowserRecordingState({
+      running: data?.running,
+      startedAt: new Date(parseInt(data?.startedAt)),
+      stoppedAt: new Date(parseInt(data?.stoppedAt)),
+      error: data?.error,
+    });
+  }
+
+  static encodeServerRecordingState(data: any) {
+    return new HMSServerRecordingState({
+      running: data?.running,
+      error: data?.error,
+      startedAt: new Date(parseInt(data?.startedAt)),
+    });
+  }
+
+  static encodeRTMPStreamingState(data: any) {
+    return new HMSRtmpStreamingState({
+      running: data?.running,
+      startedAt: new Date(parseInt(data?.startedAt)),
+      stoppedAt: new Date(parseInt(data?.stoppedAt)),
+      error: data?.error,
+    });
+  }
+
+  static encodeHLSStreamingState(data: any) {
+    return new HMSHLSStreamingState({
+      running: data?.running,
+      variants: this.encodeHLSVariants(data?.variants),
+    });
+  }
+
+  static encodeHLSRecordingState(data: any) {
+    if (data) {
+      return new HMSHLSRecordingState({
+        running: data?.running,
+        startedAt: new Date(parseInt(data?.startedAt)),
+        singleFilePerLayer: data?.singleFilePerLayer,
+        videoOnDemand: data?.videoOnDemand,
+      });
+    } else {
+      return undefined;
+    }
+  }
+
+  static encodeHLSVariants(data: any) {
+    let variants: HMSHLSVariant[] = [];
+
+    data?.map((item: any) => {
+      let variant = new HMSHLSVariant({
+        hlsStreamUrl: item.hlsStreamUrl,
+        meetingUrl: item.meetingUrl,
+        metadata: item?.metadata,
+        startedAt: new Date(parseInt(item?.startedAt)),
+      });
+      variants.push(variant);
+    });
+
+    return variants;
+  }
 }

package/src/classes/HMSHLSConfig.ts

@@ -0,0 +1,15 @@
+import type { HMSHLSMeetingURLVariant } from './HMSHLSMeetingURLVariant';
+import type { HMSHLSRecordingConfig } from './HMSHLSRecordingConfig';
+
+export class HMSHLSConfig {
+  hlsRecordingConfig?: HMSHLSRecordingConfig;
+  meetingURLVariants: Array<HMSHLSMeetingURLVariant>;
+
+  constructor(params: {
+    hlsRecordingConfig?: HMSHLSRecordingConfig;
+    meetingURLVariants: Array<HMSHLSMeetingURLVariant>;
+  }) {
+    this.hlsRecordingConfig = params.hlsRecordingConfig;
+    this.meetingURLVariants = params.meetingURLVariants;
+  }
+}

package/src/classes/HMSHLSMeetingURLVariant.ts

@@ -0,0 +1,9 @@
+export class HMSHLSMeetingURLVariant {
+  meetingUrl: string;
+  metadata: string;
+
+  constructor(params: { meetingUrl: string; metadata: string }) {
+    this.meetingUrl = params.meetingUrl;
+    this.metadata = params.metadata;
+  }
+}

package/src/classes/HMSHLSRecordingConfig.ts

@@ -0,0 +1,9 @@
+export class HMSHLSRecordingConfig {
+  singleFilePerLayer: boolean;
+  videoOnDemand: boolean;
+
+  constructor(params: { singleFilePerLayer: boolean; videoOnDemand: boolean }) {
+    this.singleFilePerLayer = params.singleFilePerLayer;
+    this.videoOnDemand = params.videoOnDemand;
+  }
+}

package/src/classes/HMSHLSRecordingState.ts

@@ -0,0 +1,18 @@
+export class HMSHLSRecordingState {
+  singleFilePerLayer: boolean;
+  videoOnDemand: boolean;
+  running: boolean;
+  startedAt?: Date;
+
+  constructor(params: {
+    singleFilePerLayer: boolean;
+    videoOnDemand: boolean;
+    running: boolean;
+    startedAt?: Date;
+  }) {
+    this.singleFilePerLayer = params.singleFilePerLayer;
+    this.videoOnDemand = params.videoOnDemand;
+    this.running = params.running;
+    this.startedAt = params.startedAt;
+  }
+}

package/src/classes/HMSHLSStreamingState.ts

@@ -0,0 +1,11 @@
+import type { HMSHLSVariant } from './HMSHLSVariant';
+
+export class HMSHLSStreamingState {
+  running: boolean;
+  variants: Array<HMSHLSVariant>;
+
+  constructor(params: { running: boolean; variants: Array<HMSHLSVariant> }) {
+    this.running = params.running;
+    this.variants = params.variants;
+  }
+}

package/src/classes/HMSHLSVariant.ts

@@ -0,0 +1,18 @@
+export class HMSHLSVariant {
+  hlsStreamUrl?: string;
+  meetingUrl?: string;
+  metadata?: string;
+  startedAt?: Date;
+
+  constructor(params: {
+    hlsStreamUrl?: string;
+    meetingUrl?: string;
+    metadata?: string;
+    startedAt?: Date;
+  }) {
+    this.hlsStreamUrl = params.hlsStreamUrl;
+    this.meetingUrl = params.meetingUrl;
+    this.metadata = params.metadata;
+    this.startedAt = params.startedAt;
+  }
+}

package/src/classes/HMSLocalAudioStats.ts

@@ -0,0 +1,15 @@
+export class HMSLocalAudioStats {
+  bitrate?: number;
+  bytesSent?: number;
+  roundTripTime?: number;
+
+  constructor(params: {
+    bitrate?: number;
+    bytesSent?: number;
+    roundTripTime?: number;
+  }) {
+    this.bitrate = params.bitrate;
+    this.bytesSent = params.bytesSent;
+    this.roundTripTime = params.roundTripTime;
+  }
+}

package/src/classes/HMSLocalVideoStats.ts

@@ -0,0 +1,23 @@
+import type { HMSVideoResolution } from './HMSVideoResolution';
+
+export class HMSLocalVideoStats {
+  bitrate?: number;
+  bytesSent?: number;
+  roundTripTime?: number;
+  frameRate?: number;
+  resolution?: HMSVideoResolution;
+
+  constructor(params: {
+    bitrate?: number;
+    bytesSent?: number;
+    roundTripTime?: number;
+    frameRate?: number;
+    resolution?: HMSVideoResolution;
+  }) {
+    this.bitrate = params.bitrate;
+    this.bytesSent = params.bytesSent;
+    this.roundTripTime = params.roundTripTime;
+    this.frameRate = params.frameRate;
+    this.resolution = params.resolution;
+  }
+}

package/src/classes/HMSLogger.ts

@@ -10,6 +10,7 @@ export class HMSLogger {
     data: any;
     id: string;
   }[] = [];
+  private onLog?: Function;
 
   constructor(params?: { verbose: boolean; warning: boolean; error: boolean }) {
     if (params) {
@@ -22,28 +23,41 @@ export class HMSLogger {
   verbose(message: string, data: any) {
     if (this._verbose) {
       console.log(message, data);
+      if (this.onLog) {
+        this?.onLog({ message, data });
+      }
+      this.logs.push({ type: 'verbose', message, data, id: data?.id });
     }
-    this.logs.push({ type: 'verbose', message, data, id: data?.id });
   }
 
   warn(message: string, data: any) {
     if (this._warning) {
       console.warn(message, data);
+      if (this.onLog) {
+        this?.onLog({ message, data });
+      }
+      this.logs.push({ type: 'warn', message, data, id: data?.id });
     }
-    this.logs.push({ type: 'warn', message, data, id: data?.id });
   }
 
   error(message: string, data: any) {
     if (this._error) {
       console.error(message, data);
+      if (this.onLog) {
+        this?.onLog({ message, data });
+      }
+      this.logs.push({ type: 'error', message, data, id: data?.id });
     }
-    this.logs.push({ type: 'error', message, data, id: data?.id });
   }
 
   getLogs() {
     return this.logs;
   }
 
+  setLogListener(callback: Function) {
+    this.onLog = callback;
+  }
+
   updateLogLevel(level: HMSLogLevel, value: boolean) {
     switch (level) {
       case HMSLogLevel.VERBOSE: {

package/src/classes/HMSMessage.ts

@@ -1,19 +1,25 @@
+import type { HMSMessageRecipient } from './HMSMessageRecipient';
+import type { HMSPeer } from './HMSPeer';
+
 export class HMSMessage {
   // endpoint: string;
   public message: string;
   public type: string;
-  public time?: string;
-  public sender?: string;
+  public time: Date;
+  public sender: HMSPeer;
+  public recipient: HMSMessageRecipient;
 
   constructor(params: {
     message: string;
     type: string;
-    time?: string;
-    sender?: string;
+    time: string;
+    sender: HMSPeer;
+    recipient: HMSMessageRecipient;
   }) {
     this.message = params.message;
     this.type = params.type;
-    this.time = params.time;
+    this.time = new Date(params.time);
     this.sender = params.sender;
+    this.recipient = params.recipient;
   }
 }

package/src/classes/HMSMessageRecipient.ts

@@ -0,0 +1,19 @@
+import type { HMSMessageRecipientType } from './HMSMessageRecipientType';
+import type { HMSPeer } from './HMSPeer';
+import type { HMSRole } from './HMSRole';
+
+export class HMSMessageRecipient {
+  public recipientType?: HMSMessageRecipientType;
+  public recipientPeer?: HMSPeer;
+  public recipientRoles?: HMSRole[];
+
+  constructor(params: {
+    recipientType: HMSMessageRecipientType;
+    recipientPeer?: HMSPeer;
+    recipientRoles?: HMSRole[];
+  }) {
+    this.recipientType = params.recipientType;
+    this.recipientPeer = params.recipientPeer;
+    this.recipientRoles = params.recipientRoles;
+  }
+}

package/src/classes/HMSMessageRecipientType.ts

@@ -0,0 +1,5 @@
+export enum HMSMessageRecipientType {
+  BROADCAST = 'BROADCAST',
+  PEER = 'PEER',
+  ROLES = 'ROLES',
+}

package/src/classes/HMSPeerUpdate.ts

@@ -1,13 +1,7 @@
 export enum HMSPeerUpdate {
   PEER_JOINED = 'PEER_JOINED',
   PEER_LEFT = 'PEER_LEFT',
-  AUDIO_TOGGLED = 'AUDIO_TOGGLED',
-  VIDEO_TOGGLED = 'VIDEO_TOGGLED',
   METADATA_CHANGED = 'METADATA_CHANGED',
-  BECAME_DOMINANT_SPEAKER = 'BECAME_DOMINANT_SPEAKER',
-  NO_DOMINANT_SPEAKER = 'NO_DOMINANT_SPEAKER',
-  RESIGNED_DOMINANT_SPEAKER = 'RESIGNED_DOMINANT_SPEAKER',
-  STARTED_SPEAKING = 'STARTED_SPEAKING',
-  STOPPED_SPEAKING = 'STOPPED_SPEAKING',
   ROLE_CHANGED = 'ROLE_CHANGED',
+  NAME_CHANGED = 'NAME_CHANGED',
 }

package/src/classes/HMSPermissions.ts

@@ -5,7 +5,7 @@ export class HMSPermissions {
   mute?: boolean;
   changeRole?: boolean;
   recording?: boolean;
-  rtmp?: boolean;
+  streaming?: boolean;
 
   constructor(params?: {
     endRoom?: boolean;
@@ -14,7 +14,7 @@ export class HMSPermissions {
     mute?: boolean;
     changeRole?: boolean;
     recording?: boolean;
-    rtmp?: boolean;
+    streaming?: boolean;
   }) {
     if (params) {
       this.endRoom = params.endRoom;
@@ -23,7 +23,7 @@ export class HMSPermissions {
       this.mute = params.mute;
       this.changeRole = params.changeRole;
       this.recording = params.recording;
-      this.rtmp = params.rtmp;
+      this.streaming = params.streaming;
     }
   }
 }

package/src/classes/HMSRTCStats.ts

@@ -0,0 +1,27 @@
+export class HMSRTCStats {
+  bitrateReceived?: number;
+  bitrateSent?: number;
+  bytesReceived?: number;
+  bytesSent?: number;
+  packetsLost?: number;
+  packetsReceived?: number;
+  roundTripTime?: number;
+
+  constructor(params: {
+    bitrateReceived?: number;
+    bitrateSent?: number;
+    bytesReceived?: number;
+    bytesSent?: number;
+    packetsLost?: number;
+    packetsReceived?: number;
+    roundTripTime?: number;
+  }) {
+    this.bitrateReceived = params.bitrateReceived;
+    this.bitrateSent = params.bitrateSent;
+    this.bytesReceived = params.bytesReceived;
+    this.bytesSent = params.bytesSent;
+    this.packetsLost = params.packetsLost;
+    this.packetsReceived = params.packetsReceived;
+    this.roundTripTime = params.roundTripTime;
+  }
+}

package/src/classes/HMSRTCStatsReport.ts

@@ -0,0 +1,17 @@
+import type { HMSRTCStats } from './HMSRTCStats';
+
+export class HMSRTCStatsReport {
+  video?: HMSRTCStats;
+  audio?: HMSRTCStats;
+  combined?: HMSRTCStats;
+
+  constructor(params: {
+    video?: HMSRTCStats;
+    audio?: HMSRTCStats;
+    combined?: HMSRTCStats;
+  }) {
+    this.audio = params.audio;
+    this.video = params.video;
+    this.combined = params.combined;
+  }
+}

package/src/classes/HMSRemoteAudioStats.ts

@@ -0,0 +1,21 @@
+export class HMSRemoteAudioStats {
+  bitrate?: number;
+  packetsReceived?: number;
+  packetsLost?: number;
+  bytesReceived?: number;
+  jitter?: number;
+
+  constructor(params: {
+    bitrate?: number;
+    packetsReceived?: number;
+    packetsLost?: number;
+    bytesReceived?: number;
+    jitter?: number;
+  }) {
+    this.bitrate = params.bitrate;
+    this.packetsReceived = params.packetsReceived;
+    this.jitter = params.jitter;
+    this.packetsLost = params.packetsLost;
+    this.bytesReceived = params.bytesReceived;
+  }
+}

package/src/classes/HMSRemoteVideoStats.ts

@@ -0,0 +1,29 @@
+import type { HMSVideoResolution } from './HMSVideoResolution';
+
+export class HMSRemoteVideoStats {
+  bitrate?: number;
+  packetsReceived?: number;
+  packetsLost?: number;
+  bytesReceived?: number;
+  jitter?: number;
+  resolution?: HMSVideoResolution;
+  frameRate?: number;
+
+  constructor(params: {
+    bitrate?: number;
+    packetsReceived?: number;
+    packetsLost?: number;
+    bytesReceived?: number;
+    jitter?: number;
+    resolution?: HMSVideoResolution;
+    frameRate?: number;
+  }) {
+    this.bitrate = params.bitrate;
+    this.packetsReceived = params.packetsReceived;
+    this.packetsLost = params.packetsLost;
+    this.bytesReceived = params.bytesReceived;
+    this.jitter = params.jitter;
+    this.resolution = params.resolution;
+    this.frameRate = params.frameRate;
+  }
+}