@livedigital/client 3.17.0 → 3.18.0

package/dist/types/common.d.ts

@@ -49,6 +49,8 @@ export declare type Role = 'audience' | 'host';
 export declare type PeerResponse = {
     id: string;
     channelIds: string[];
+    groups: PeerGroup[];
+    producePermissions: TrackLabel[];
     appId: string;
     producers: ProducerData[];
     uid?: string;
@@ -335,3 +337,13 @@ export declare type PeerSyncData = Omit<PeerShortData, 'appData'> & {
     appData?: string;
 };
 export declare type TransportAppData = AppData;
+export declare type PeerGroup = 'moderator' | 'user';
+export declare type ChangePeerProducePermissionPayload = {
+    peerId: string;
+    producePermissions: TrackLabel[];
+};
+export interface ChannelChangeProducePermissionsPayload {
+    groups: PeerGroup[];
+    producePermissions: TrackLabel[];
+}
+export declare type TrackLabelString = 'camera' | 'microphone' | 'screen-video' | 'screen-audio';

package/dist/types/engine.d.ts

@@ -78,6 +78,9 @@ export interface ChannelStateInconsistentPayload {
     peerId?: string;
     producerId?: string;
 }
+export interface ProducePermissionsChangedPayload {
+    labels: TrackLabel[];
+}
 export interface EngineDependenciesFactory {
     createSystem: (params: CreateSystemParams) => System;
     createMedia: (params: CreateMediaParams) => Media;
@@ -116,6 +119,7 @@ export declare type ClientObserverEvents = {
     [CLIENT_EVENTS.forcedDisconnect]: [];
     [CLIENT_EVENTS.rejectUnauthorized]: [];
     [CLIENT_EVENTS.channelStateInconsistent]: [ChannelStateInconsistentPayload];
+    [CLIENT_EVENTS.producePermissionsChanged]: [ProducePermissionsChangedPayload];
 };
 export declare type InternalObserverEvents = {
     [INTERNAL_CLIENT_EVENTS.trackProduced]: [Track | BaseTrack];

package/package.json

@@ -2,7 +2,7 @@
   "name": "@livedigital/client",
   "author": "vlprojects",
   "license": "MIT",
-  "version": "3.17.0",
+  "version": "3.18.0",
   "private": false,
   "bugs": {
     "url": "https://github.com/vlprojects/livedigital-sdk/issues"

package/src/constants/events.ts

@@ -11,6 +11,8 @@ export const CHANNEL_EVENTS = {
   getAudioObserverProducer: 'channel.getAudioObserverProducer',
   getGeneralDataProducer: 'channel.getGeneralDataProducer',
   getChannelStateSyncDataProducer: 'channel.getChannelStateSyncDataProducer',
+  changeProducePermissions: 'channel.changeProducePermissions',
+  changePeerProducePermissions: 'peer.changeProducePermissions',
   ping: 'peer.ping',
 } as const;
 
@@ -32,6 +34,7 @@ export const CLIENT_EVENTS = {
   connectionRestored: 'connection-restored',
   forcedDisconnect: 'forced-disconnect',
   rejectUnauthorized: 'reject-unauthorized',
+  producePermissionsChanged: 'produce-permissions-changed',
 } as const;
 
 export const TRACK_EVENTS = {

package/src/engine/Peer.ts

@@ -11,19 +11,27 @@ import {
   PeerInfo,
   SubscribeOptions,
   PeerShortData,
+  PeerGroup,
+  TrackLabel, TrackLabelString,
 } from '../types/common';
 import EnhancedEventEmitter from '../EnhancedEventEmitter';
 import Engine from './index';
-import { CHANNEL_EVENTS, MEDIASOUP_EVENTS, PEER_EVENTS } from '../constants/events';
+import {
+  CHANNEL_EVENTS, CLIENT_EVENTS, MEDIASOUP_EVENTS, PEER_EVENTS,
+} from '../constants/events';
 import Logger from './Logger';
 import PeerProducer from './PeerProducer';
 import PeerConsumer from './PeerConsumer';
 import PeerTrack from './media/tracks/PeerTrack';
 import validateAppData from '../helpers/appDataValidator';
+import { ProducePermissionsChangedPayload } from '../types/engine';
+import { logResponse } from '../helpers/peer';
 
 interface PeerConstructor {
   id: string;
   channelIds: string[];
+  groups: PeerGroup[];
+  producePermissions: TrackLabel[];
   appId: string;
   producers: ProducerData[],
   videoConsumer?: PeerConsumer;
@@ -54,6 +62,7 @@ export type PeerObserverEvents = {
   [PEER_EVENTS.trackResumed]: [PeerTrack];
   [PEER_EVENTS.trackPaused]: [PeerTrack];
   [PEER_EVENTS.trackFailed]: [PeerTrack];
+  [CLIENT_EVENTS.producePermissionsChanged]: [ProducePermissionsChangedPayload];
   [MEDIASOUP_EVENTS.producerClose]: [ProducerData];
   [MEDIASOUP_EVENTS.newProducer]: [ProducerData];
   [MEDIASOUP_EVENTS.closeConsumer]: [consumerId: string];
@@ -71,6 +80,10 @@ class Peer {
 
   public channelIds: string[];
 
+  public groups: PeerGroup[];
+
+  public producePermissions: TrackLabel[];
+
   public appId: string;
 
   public loginDate: Date;
@@ -100,6 +113,8 @@ class Peer {
   constructor({
     id,
     channelIds,
+    groups,
+    producePermissions,
     appId,
     loginDate,
     producers = [],
@@ -110,6 +125,8 @@ class Peer {
   }: PeerConstructor) {
     this.id = id;
     this.channelIds = channelIds;
+    this.groups = groups;
+    this.producePermissions = producePermissions;
     this.appId = appId;
     this.loginDate = loginDate;
     this.applicationData = appData || {};
@@ -136,6 +153,14 @@ class Peer {
     return this.id === this.engine.myPeerId;
   }
 
+  public get isModerator(): boolean {
+    return this.groups.includes('moderator');
+  }
+
+  public get isUser(): boolean {
+    return this.groups.includes('user');
+  }
+
   public get publishedMedia(): PayloadOfPublishedMedia[] {
     return Array.from(this.producers.values()).map((producer) => ({
       producerId: producer.id,
@@ -156,17 +181,27 @@ class Peer {
     };
   }
 
+  public hasPermission(producePermission: TrackLabel): boolean {
+    return this.producePermissions.includes(producePermission);
+  }
+
+  public hasGroup(group: PeerGroup): boolean {
+    return this.groups.includes(group);
+  }
+
   public async subscribe({ producerId, muted = false }: SubscribeOptions): Promise<void> {
     try {
       const producer = this.producers.get(producerId);
       if (!producer) {
-        this.logger.warn('subscribe()', { message: 'Peer does not have a producer', peer: this, producerId });
+        this.logger.warn('subscribe()',
+          { message: 'Peer does not have a producer', peer: logResponse(this), producerId });
         return;
       }
 
       const peerConsumer = this.getAllConsumers().find((item) => item.producerId === producerId);
       if (peerConsumer) {
-        this.logger.debug('subscribe()', { message: 'Already subscribed to producer', peer: this, producerId });
+        this.logger.debug('subscribe()',
+          { message: 'Already subscribed to producer', peer: logResponse(this), producerId });
         return;
       }
 
@@ -193,7 +228,7 @@ class Peer {
       }
 
       this.tracks.set(track.label, track);
-      this.logger.debug(`Subscribed for ${producer.kind}`, { peer: this });
+      this.logger.debug(`Subscribed for ${producer.kind}`, { peer: logResponse(this) });
     } catch (error) {
       this.logger.error('subscribe()', { producerId, error });
       throw new Error('Error subscribe media');
@@ -214,13 +249,27 @@ class Peer {
 
       await track.close();
       this.tracks.delete(track.label);
-      this.logger.debug(`Unsubscribed consumer ${consumer.kind}`, { peer: this });
+      this.logger.debug(`Unsubscribed consumer ${consumer.kind}`, { peer: logResponse(this) });
     } catch (error) {
       this.logger.error('unsubscribe()', { producerId, error });
       throw new Error('Error unsubscribe media');
     }
   }
 
+  public async changeProducePermissions(producePermissions: TrackLabelString[]): Promise<void> {
+    const isIamModerator = this.engine.peersRepository.get(this.engine.myPeerId ?? '')?.isModerator;
+    if (!isIamModerator) {
+      throw new Error('Not enough access');
+    }
+
+    await this.engine.network.socket.request(CHANNEL_EVENTS.changePeerProducePermissions, {
+      peerId: this.id,
+      producePermissions,
+    });
+
+    this.logger.debug('Produce permissions changed', { peerId: this.id, producePermissions });
+  }
+
   async getInfo(): Promise<PeerInfo> {
     try {
       return {
@@ -235,7 +284,7 @@ class Peer {
         tracks: await Promise.all(Array.from(this.tracks.values()).map((track) => track.getInfo())),
       };
     } catch (error) {
-      this.logger.error('getInfo()', { peer: this, error });
+      this.logger.error('getInfo()', { peer: logResponse(this), error });
       throw new Error('Error get info');
     }
   }
@@ -251,7 +300,7 @@ class Peer {
 
     const producer = new PeerProducer(producerData);
     this.producers.set(producer.id, producer);
-    this.logger.debug('Peer published media:', { peer: this, producer });
+    this.logger.debug('Peer published media:', { peer: logResponse(this), producer });
     this.observer.safeEmit(PEER_EVENTS.mediaPublished, {
       producerId: producer.id,
       kind: producer.kind,
@@ -265,7 +314,7 @@ class Peer {
 
     this.observer.on(MEDIASOUP_EVENTS.producerClose, async (producer: ProducerData) => {
       this.producers.delete(producer.id);
-      this.logger.debug('Peer unpublished media:', { peer: this, producer });
+      this.logger.debug('Peer unpublished media:', { peer: logResponse(this), producer });
       this.observer.safeEmit(PEER_EVENTS.mediaUnPublished, {
         producerId: producer.id,
         kind: producer.kind,
@@ -296,7 +345,7 @@ class Peer {
 
       await track.close();
       this.tracks.delete(track.label);
-      this.logger.debug('Peer video track was ended:', { peer: this, track });
+      this.logger.debug('Peer video track was ended:', { peer: logResponse(this), track });
     });
 
     this.observer.on(MEDIASOUP_EVENTS.pauseConsumer, async (consumerId) => {
@@ -464,9 +513,9 @@ class Peer {
         validateAppData(appData);
         this.setAppData(appData);
         this.observer.emit(PEER_EVENTS.appDataUpdated, appData);
-        this.logger.debug('updatePeerAppData', { peer: this, appData });
+        this.logger.debug('updatePeerAppData', { peer: logResponse(this), appData });
       } catch (error) {
-        this.logger.error('updatePeerAppData', { peer: this, appData, error });
+        this.logger.error('updatePeerAppData', { peer: logResponse(this), appData, error });
       }
     });
   }
@@ -521,7 +570,7 @@ class Peer {
       });
 
       this.overallConnectionQuality = connectionQuality;
-      this.logger.debug('emitConnectionQuality()', { peer: this, connectionQuality });
+      this.logger.debug('emitConnectionQuality()', { peer: logResponse(this), connectionQuality });
     }, 1000);
   }
 

package/src/engine/handlers/ChannelEventHandler.ts

@@ -1,5 +1,5 @@
 import {
-  ActivityConfirmationRequiredPayload,
+  ActivityConfirmationRequiredPayload, ChangePeerProducePermissionPayload, ChannelChangeProducePermissionsPayload,
   ChannelEvent,
   LogMessageHandler,
   PeerResponse,
@@ -78,6 +78,44 @@ class ChannelEventHandler {
       this.engine.clientEventEmitter.safeEmit(CLIENT_EVENTS.activityConfirmationAcquired, event);
       this.logger.info('Notify the channel that the activity has been acquired.', event);
     });
+
+    connection.on(CHANNEL_EVENTS.changeProducePermissions, (payload: ChannelChangeProducePermissionsPayload) => {
+      const { producePermissions, groups } = payload;
+      const peers = this.engine.peers.filter((peer) => peer.groups.some((group) => groups.includes(group)));
+      peers.forEach((peer) => {
+        // eslint-disable-next-line no-param-reassign
+        peer.producePermissions = producePermissions;
+
+        if (!peer.isMe) {
+          return;
+        }
+
+        this.engine.clientEventEmitter.safeEmit(CLIENT_EVENTS.producePermissionsChanged, {
+          labels: producePermissions,
+        });
+      });
+
+      this.logger.info('Peers changed produce permissions', { groups, producePermissions });
+    });
+
+    connection.on(CHANNEL_EVENTS.changePeerProducePermissions, (payload: ChangePeerProducePermissionPayload) => {
+      const { peerId, producePermissions } = payload;
+      const peer = this.engine.peersRepository.get(peerId);
+
+      if (!peer) {
+        return;
+      }
+
+      peer.producePermissions = producePermissions;
+
+      if (!peer.isMe) {
+        return;
+      }
+
+      this.engine.clientEventEmitter.safeEmit(CLIENT_EVENTS.producePermissionsChanged, {
+        labels: producePermissions,
+      });
+    });
   }
 
   private removeEventListeners() {
@@ -95,6 +133,7 @@ class ChannelEventHandler {
       CHANNEL_EVENTS.activityConfirmationExpired,
       CHANNEL_EVENTS.activityConfirmationAcquired,
       CHANNEL_EVENTS.updatePeerAppData,
+      CHANNEL_EVENTS.changeProducePermissions,
     ];
 
     eventNames.forEach((x) => connection.removeAllListeners(x));

package/src/helpers/peer.ts

@@ -0,0 +1,20 @@
+import Peer from '../engine/Peer';
+
+type PeerLogResponse = {
+  id: Peer['id'];
+  appId: Peer['appId'];
+  role: Peer['role'];
+  groups: Peer['groups'];
+  producePermissions: Peer['producePermissions'];
+};
+
+// eslint-disable-next-line import/prefer-default-export
+export function logResponse(peer: Peer): PeerLogResponse {
+  return {
+    id: peer.id,
+    appId: peer.appId,
+    role: peer.role,
+    groups: peer.groups,
+    producePermissions: peer.producePermissions,
+  };
+}

package/src/types/common.ts

@@ -67,6 +67,8 @@ export type Role = 'audience' | 'host';
 export type PeerResponse = {
   id: string,
   channelIds: string[],
+  groups: PeerGroup[],
+  producePermissions: TrackLabel[],
   appId: string,
   producers: ProducerData[],
   uid?: string,
@@ -411,3 +413,17 @@ export type PeerSyncData = Omit<PeerShortData, 'appData'> & {
 };
 
 export type TransportAppData = AppData;
+
+export type PeerGroup = 'moderator' | 'user';
+
+export type ChangePeerProducePermissionPayload = {
+  peerId: string;
+  producePermissions: TrackLabel[];
+};
+
+export interface ChannelChangeProducePermissionsPayload {
+  groups: PeerGroup[];
+  producePermissions: TrackLabel[];
+}
+
+export type TrackLabelString = 'camera' | 'microphone' | 'screen-video' | 'screen-audio';

package/src/types/engine.ts

@@ -107,6 +107,10 @@ export interface ChannelStateInconsistentPayload {
   producerId?: string;
 }
 
+export interface ProducePermissionsChangedPayload {
+  labels: TrackLabel[];
+}
+
 export interface EngineDependenciesFactory {
   createSystem: (params: CreateSystemParams) => System;
   createMedia: (params: CreateMediaParams) => Media;
@@ -137,6 +141,7 @@ export type ClientObserverEvents = {
   [CLIENT_EVENTS.forcedDisconnect]:[];
   [CLIENT_EVENTS.rejectUnauthorized]:[];
   [CLIENT_EVENTS.channelStateInconsistent]:[ChannelStateInconsistentPayload];
+  [CLIENT_EVENTS.producePermissionsChanged]:[ProducePermissionsChangedPayload];
 };
 
 export type InternalObserverEvents = {