MediaPlayerSynchronizer class

Creates a new MediaElementSynchronizer instance.

new MediaPlayerSynchronizer(player: IMediaPlayer, mediaSession: LiveMediaSession, runtime: IRuntimeSignaler, onEnd: () => void)

Parameters

If true, pause and play actions will be ignored unless explicitly invoked from the corresponding play() and pause() functions.

boolean blockUnexpectedPlayerEvents

Property Value

Synchronizers media session.

LiveMediaSession mediaSession

Property Value

Media player being synchronized.

IMediaPlayer player

Property Value

If true the client is in a view only mode.

boolean viewOnly

Property Value

Volume limiter used to temporarily reduce the videos volume when someone speaks in a meeting.

VolumeManager volumeManager

Property Value

Registers a new event listener.

function addEventListener(event: MediaPlayerSynchronizerEvents, listener: (evt: IMediaPlayerSynchronizerEvent) => void): MediaPlayerSynchronizer

Parameters

Returns

Begin a local seek operation.

function beginSeek()

Remarks

UI can call this when a user grabs a timeline scrubber and starts scrubbing the video to a new playback position. The synchronizer will being a new suspension which temporarily disconnects the client for the rest of the group for synchronization purposes. Calling endSeek() will end the suspension and seek the group to the users final seek position.

Ends synchronization of the current media player.

function end()

Ends a seek operation that was started by calling beginSeek().

function endSeek(seekTo: number)

Parameters

Tells the group to pause the current video.

function pause(): Promise<void>

Returns

a void promise that resolves once complete, throws if user does not have proper roles

Remarks

For proper operation apps should avoid calling mediaSession.coordinator.pause() directly and instead use the synchronizers pause() method.

Tells the group to begin playing the current video.

function play(): Promise<void>

Returns

a void promise that resolves once complete, throws if user does not have proper roles

Remarks

For proper operation apps should avoid calling mediaSession.coordinator.play() directly and instead use the synchronizers play() method.

Un-registers an existing event listener.

function removeEventListener(event: MediaPlayerSynchronizerEvents, listener: (evt: IMediaPlayerSynchronizerEvent) => void): MediaPlayerSynchronizer

Parameters

Returns

Tells the group to seek the current video to a new playback position.

function seekTo(time: number): Promise<void>

Parameters

Returns

a void promise that resolves once complete, throws if user does not have proper roles

Remarks

For proper operation apps should avoid calling mediaSession.coordinator.seekTo() directly and instead use the synchronizers seekTo() method.

function setPlaybackRate(playbackRate: number): Promise<void>

Parameters

Returns

Tells the group to change to a new track.

function setTrack(track: ExtendedMediaMetadata, waitPoints?: CoordinationWaitPoint[]): Promise<void>

Parameters

Returns

a void promise that resolves once complete, throws if user does not have proper roles

Remarks

For proper operation apps should avoid calling mediaSession.coordinator.setTrack() directly and instead use the synchronizers setTrack() method.

Updates the current tracks data object.

function setTrackData(data: null | object): Promise<void>

Parameters

Returns

a void promise that resolves once complete, throws if user does not have proper roles

Remarks

For proper operation apps should avoid calling mediaSession.coordinator.setTrackData() directly and instead use the synchronizers setTrackData() method.

Alias for emitter.on(eventName, listener).

function addListener<E>(eventName: string | symbol, listener: (args: any[]) => void): MediaPlayerSynchronizer

Parameters

Returns

Inherited From EventEmitter.addListener

Synchronously calls each of the listeners registered for the event named eventName, in the order they were registered, passing the supplied arguments to each.

Returns true if the event had listeners, false otherwise.

import { EventEmitter } from 'node:events';
const myEmitter = new EventEmitter();

// First listener
myEmitter.on('event', function firstListener() {
  console.log('Helloooo! first listener');
});
// Second listener
myEmitter.on('event', function secondListener(arg1, arg2) {
  console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
});
// Third listener
myEmitter.on('event', function thirdListener(...args) {
  const parameters = args.join(', ');
  console.log(`event with parameters ${parameters} in third listener`);
});

console.log(myEmitter.listeners('event'));

myEmitter.emit('event', 1, 2, 3, 4, 5);

// Prints:
// [
//   [Function: firstListener],
//   [Function: secondListener],
//   [Function: thirdListener]
// ]
// Helloooo! first listener
// event with parameters 1, 2 in second listener
// event with parameters 1, 2, 3, 4, 5 in third listener

function emit<E>(eventName: string | symbol, args: any[]): boolean

Parameters

Returns

Inherited From EventEmitter.emit

Returns an array listing the events for which the emitter has registered listeners.

import { EventEmitter } from 'node:events';

const myEE = new EventEmitter();
myEE.on('foo', () => {});
myEE.on('bar', () => {});

const sym = Symbol('symbol');
myEE.on(sym, () => {});

console.log(myEE.eventNames());
// Prints: [ 'foo', 'bar', Symbol(symbol) ]

function eventNames(): (string | symbol)[]

Returns

Inherited From EventEmitter.eventNames

Returns the current max listener value for the EventEmitter which is either set by emitter.setMaxListeners(n) or defaults to events.defaultMaxListeners.

function getMaxListeners(): number

Returns

Inherited From EventEmitter.getMaxListeners

Returns the number of listeners listening for the event named eventName. If listener is provided, it will return how many times the listener is found in the list of the listeners of the event.

function listenerCount<E>(eventName: string | symbol, listener?: (args: any[]) => void): number

Parameters

Returns

Inherited From EventEmitter.listenerCount

Returns a copy of the array of listeners for the event named eventName.

server.on('connection', (stream) => {
  console.log('someone connected!');
});
console.log(util.inspect(server.listeners('connection')));
// Prints: [ [Function] ]

function listeners<E>(eventName: string | symbol): (args: any[]) => void[]

Parameters

Returns

Inherited From EventEmitter.listeners

Alias for emitter.removeListener().

function off<E>(eventName: string | symbol, listener: (args: any[]) => void): MediaPlayerSynchronizer

Parameters

Returns

Inherited From EventEmitter.off

Adds the listener function to the end of the listeners array for the event named eventName. No checks are made to see if the listener has already been added. Multiple calls passing the same combination of eventName and listener will result in the listener being added, and called, multiple times.

server.on('connection', (stream) => {
  console.log('someone connected!');
});

Returns a reference to the EventEmitter, so that calls can be chained.

By default, event listeners are invoked in the order they are added. The emitter.prependListener() method can be used as an alternative to add the event listener to the beginning of the listeners array.

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => console.log('a'));
myEE.prependListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a

function on<E>(eventName: string | symbol, listener: (args: any[]) => void): MediaPlayerSynchronizer

Parameters

Returns

Inherited From EventEmitter.on

Adds a one-time listener function for the event named eventName. The next time eventName is triggered, this listener is removed and then invoked.

server.once('connection', (stream) => {
  console.log('Ah, we have our first user!');
});

Returns a reference to the EventEmitter, so that calls can be chained.

By default, event listeners are invoked in the order they are added. The emitter.prependOnceListener() method can be used as an alternative to add the event listener to the beginning of the listeners array.

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.once('foo', () => console.log('a'));
myEE.prependOnceListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a

function once<E>(eventName: string | symbol, listener: (args: any[]) => void): MediaPlayerSynchronizer

Parameters

Returns

Inherited From EventEmitter.once

Adds the listener function to the beginning of the listeners array for the event named eventName. No checks are made to see if the listener has already been added. Multiple calls passing the same combination of eventName and listener will result in the listener being added, and called, multiple times.

server.prependListener('connection', (stream) => {
  console.log('someone connected!');
});

Returns a reference to the EventEmitter, so that calls can be chained.

function prependListener<E>(eventName: string | symbol, listener: (args: any[]) => void): MediaPlayerSynchronizer

Parameters

Returns

Inherited From EventEmitter.prependListener

Adds a one-time listener function for the event named eventName to the beginning of the listeners array. The next time eventName is triggered, this listener is removed, and then invoked.

server.prependOnceListener('connection', (stream) => {
  console.log('Ah, we have our first user!');
});

Returns a reference to the EventEmitter, so that calls can be chained.

function prependOnceListener<E>(eventName: string | symbol, listener: (args: any[]) => void): MediaPlayerSynchronizer

Parameters

Returns

Inherited From EventEmitter.prependOnceListener

Returns a copy of the array of listeners for the event named eventName, including any wrappers (such as those created by .once()).

import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.once('log', () => console.log('log once'));

// Returns a new Array with a function `onceWrapper` which has a property
// `listener` which contains the original listener bound above
const listeners = emitter.rawListeners('log');
const logFnWrapper = listeners[0];

// Logs "log once" to the console and does not unbind the `once` event
logFnWrapper.listener();

// Logs "log once" to the console and removes the listener
logFnWrapper();

emitter.on('log', () => console.log('log persistently'));
// Will return a new Array with a single function bound by `.on()` above
const newListeners = emitter.rawListeners('log');

// Logs "log persistently" twice
newListeners[0]();
emitter.emit('log');

function rawListeners<E>(eventName: string | symbol): (args: any[]) => void[]

Parameters

Returns

Inherited From EventEmitter.rawListeners

Removes all listeners, or those of the specified eventName.

It is bad practice to remove listeners added elsewhere in the code, particularly when the EventEmitter instance was created by some other component or module (e.g. sockets or file streams).

Returns a reference to the EventEmitter, so that calls can be chained.

function removeAllListeners<E>(eventName?: string | symbol): MediaPlayerSynchronizer

Parameters

Returns

Inherited From EventEmitter.removeAllListeners

Removes the specified listener from the listener array for the event named eventName.

const callback = (stream) => {
  console.log('someone connected!');
};
server.on('connection', callback);
// ...
server.removeListener('connection', callback);

removeListener() will remove, at most, one instance of a listener from the listener array. If any single listener has been added multiple times to the listener array for the specified eventName, then removeListener() must be called multiple times to remove each instance.

Once an event is emitted, all listeners attached to it at the time of emitting are called in order. This implies that any removeListener() or removeAllListeners() calls after emitting and before the last listener finishes execution will not remove them from emit() in progress. Subsequent events behave as expected.

import { EventEmitter } from 'node:events';
class MyEmitter extends EventEmitter {}
const myEmitter = new MyEmitter();

const callbackA = () => {
  console.log('A');
  myEmitter.removeListener('event', callbackB);
};

const callbackB = () => {
  console.log('B');
};

myEmitter.on('event', callbackA);

myEmitter.on('event', callbackB);

// callbackA removes listener callbackB but it will still be called.
// Internal listener array at time of emit [callbackA, callbackB]
myEmitter.emit('event');
// Prints:
//   A
//   B

// callbackB is now removed.
// Internal listener array [callbackA]
myEmitter.emit('event');
// Prints:
//   A

Because listeners are managed using an internal array, calling this will change the position indexes of any listener registered after the listener being removed. This will not impact the order in which listeners are called, but it means that any copies of the listener array as returned by the emitter.listeners() method will need to be recreated.

When a single function has been added as a handler multiple times for a single event (as in the example below), removeListener() will remove the most recently added instance. In the example the once('ping') listener is removed:

import { EventEmitter } from 'node:events';
const ee = new EventEmitter();

function pong() {
  console.log('pong');
}

ee.on('ping', pong);
ee.once('ping', pong);
ee.removeListener('ping', pong);

ee.emit('ping');
ee.emit('ping');

Returns a reference to the EventEmitter, so that calls can be chained.

function removeListener<E>(eventName: string | symbol, listener: (args: any[]) => void): MediaPlayerSynchronizer

Parameters

Returns

Inherited From EventEmitter.removeListener

By default EventEmitters will print a warning if more than 10 listeners are added for a particular event. This is a useful default that helps finding memory leaks. The emitter.setMaxListeners() method allows the limit to be modified for this specific EventEmitter instance. The value can be set to Infinity (or 0) to indicate an unlimited number of listeners.

Returns a reference to the EventEmitter, so that calls can be chained.

function setMaxListeners(n: number): MediaPlayerSynchronizer

Parameters

Returns

Inherited From EventEmitter.setMaxListeners

The Symbol.for('nodejs.rejection') method is called in case a promise rejection happens when emitting an event and captureRejections is enabled on the emitter. It is possible to use events.captureRejectionSymbol in place of Symbol.for('nodejs.rejection').

import { EventEmitter, captureRejectionSymbol } from 'node:events';

class MyClass extends EventEmitter {
  constructor() {
    super({ captureRejections: true });
  }

  [captureRejectionSymbol](err, event, ...args) {
    console.log('rejection happened for', event, 'with', err, ...args);
    this.destroy(err);
  }

  destroy(err) {
    // Tear the resource down here.
  }
}

function [captureRejectionSymbol](error: Error, event: string | symbol, args: any[])

Parameters

Inherited From EventEmitter.__@captureRejectionSymbol@144