LiveMediaSessionCoordinator class

The LiveMediaSessionCoordinator tracks the playback & position state of all other clients being synchronized with. It is responsible for keeping the local media player in sync with the group.

Properties

canPlayPause	Controls whether or not the local client is allowed to instruct the group to play or pause.
canSeek	Controls whether or not the local client is allowed to seek the group to a new playback position.
canSendPositionUpdates	Controls whether or not the local client is allowed to send position updates to the group.
canSetPlaybackRate	Controls whether or not the local client is allowed to change the playback rate.
canSetTrack	Controls whether or not the local client is allowed to change tracks.
canSetTrackData	Controls whether or not the local client is allowed to change the tracks custom data object.
isSuspended	Returns true if the local client is in a suspended state.
maxPlaybackDrift	Max amount of playback drift allowed in seconds.
positionUpdateInterval	Frequency with which position updates are broadcast to the rest of the group in seconds.

Methods

beginSuspension(CoordinationWaitPoint)	Begins a new local suspension.
pause()	Instructs the group to pause the current track.
play()	Instructs the group to play the current track.
seekTo(number)	Instructs the group to seek to a new position within the current track.
setPlaybackRate(number)
setTrack(null \| ExtendedMediaMetadata, CoordinationWaitPoint[])	Instructs the group to load a new track.
setTrackData(null \| object)	Updates the track data object for the current track.

Inherited Methods

addListener<E>(string \| symbol, (args: any[]) => void)	Alias for `emitter.on(eventName, listener)`.
emit<E>(string \| symbol, any[])	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
eventNames()	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) ]`
getMaxListeners()	Returns the current max listener value for the `EventEmitter` which is either set by `emitter.setMaxListeners(n)` or defaults to `events.defaultMaxListeners`.
listenerCount<E>(string \| symbol, (args: any[]) => void)	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.
listeners<E>(string \| symbol)	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] ]`
off<E>(string \| symbol, (args: any[]) => void)	Alias for `emitter.removeListener()`.
on<E>(string \| symbol, (args: any[]) => void)	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`
once<E>(string \| symbol, (args: any[]) => void)	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`
prependListener<E>(string \| symbol, (args: any[]) => void)	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.
prependOnceListener<E>(string \| symbol, (args: any[]) => void)	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.
rawListeners<E>(string \| symbol)	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');
removeAllListeners<E>(string \| symbol)	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.
removeListener<E>(string \| symbol, (args: any[]) => void)	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.
setMaxListeners(number)	By default `EventEmitter`s 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.
[captureRejectionSymbol](Error, string \| symbol, any[])	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. } }`

Controls whether or not the local client is allowed to instruct the group to play or pause.

canPlayPause: boolean

Property Value

boolean

Remarks

This flag largely meant to influence decisions made by the coordinator and can be used by the UI to determine what controls should be shown to the user. It does not provide any security in itself.

If your app is running in a semi-trusted environment where only some clients are allowed to play/pause media, you should use "role based verification" to enforce those policies.

Controls whether or not the local client is allowed to seek the group to a new playback position.

canSeek: boolean

Property Value

boolean

Remarks

This flag largely meant to influence decisions made by the coordinator and can be used by the UI to determine what controls should be shown to the user. It does not provide any security in itself.

If your app is running in a semi-trusted environment where only some clients are allowed to change the playback position, you should use "role based verification" to enforce those policies.

Controls whether or not the local client is allowed to send position updates to the group.

canSendPositionUpdates: boolean

Property Value

boolean

Remarks

This flag largely meant to limit the number of signals sent to the group for performance reasons. It does not provide any security in itself.

Controls whether or not the local client is allowed to change the playback rate.

canSetPlaybackRate: boolean

Property Value

boolean

Remarks

This flag largely meant to influence decisions made by the coordinator and can be used by the UI to determine what controls should be shown to the user. It does not provide any security in itself.

If your app is running in a semi-trusted environment where only some clients are allowed to change the tracks data object, you should use "role based verification" to enforce those policies.

Controls whether or not the local client is allowed to change tracks.

canSetTrack: boolean

Property Value

boolean

Remarks

This flag largely meant to influence decisions made by the coordinator and can be used by the UI to determine what controls should be shown to the user. It does not provide any security in itself.

If your app is running in a semi-trusted environment where only some clients are allowed to change tracks, you should use "role based verification" to enforce those policies.

Controls whether or not the local client is allowed to change the tracks custom data object.

canSetTrackData: boolean

Property Value

boolean

Remarks

This flag largely meant to influence decisions made by the coordinator and can be used by the UI to determine what controls should be shown to the user. It does not provide any security in itself.

If your app is running in a semi-trusted environment where only some clients are allowed to change the tracks data object, you should use "role based verification" to enforce those policies.

Returns true if the local client is in a suspended state.

boolean isSuspended

Property Value

boolean

Max amount of playback drift allowed in seconds.

number maxPlaybackDrift

Property Value

number

Frequency with which position updates are broadcast to the rest of the group in seconds.

number positionUpdateInterval

Property Value

number

Begins a new local suspension.

function beginSuspension(waitPoint?: CoordinationWaitPoint): MediaSessionCoordinatorSuspension

Parameters

waitPoint: CoordinationWaitPoint

Optional. Dynamic wait point to broadcast to all of the clients.

Returns

MediaSessionCoordinatorSuspension

The suspension object. Call end() on the returned suspension to end the suspension.

Remarks

Suspension temporarily suspend the clients local synchronization with the group. This can be useful for displaying ads to users or temporarily disconnecting from the session while the user seeks the video using a timeline scrubber.

Multiple simultaneous suspensions are allowed and when the last suspension ends the local client will be immediately re-synchronized with the group.

A "Dynamic Wait Point" can be specified when beginSuspension() is called and the wait point will be broadcast to all other clients in the group. Those clients will then automatically enter a suspension state once they reach the positions specified by the wait point. Clients that are passed the wait point will immediately suspend.

Any wait point based suspension (dynamic or static) will result in all clients remaining in a suspension state until the list client ends their suspension. This behavior can be conditionally bypassed by settings the wait points maxClients value.

Throws an exception if the session/coordinator hasn't been initialized.

Instructs the group to pause the current track.

function pause(): Promise<void>

Returns

Promise<void>

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

Remarks

Throws an exception if the session/coordinator hasn't been initialized, no track has been loaded, or canPlayPause is false.

Instructs the group to play the current track.

function play(): Promise<void>

Returns

Promise<void>

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

Remarks

Throws an exception if the session/coordinator hasn't been initialized, no track has been loaded, or canPlayPause is false.

Instructs the group to seek to a new position within the current track.

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

Parameters

time: number

Playback position in seconds to seek to.

Returns

Promise<void>

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

Remarks

Throws an exception if the session/coordinator hasn't been initialized, no track has been loaded, or canSeek is false.

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

Parameters

playbackRate: number

Returns

Promise<void>

Instructs the group to load a new track.

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

Parameters

metadata: null | ExtendedMediaMetadata

The track to load or null to indicate that the end of the track is reached.

waitPoints: CoordinationWaitPoint[]

Optional. List of static wait points to configure for the track. Dynamic wait points can be added via the beginSuspension() call.

Returns

Promise<void>

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

Remarks

Throws an exception if the session/coordinator hasn't been initialized or canSetTrack is false.

Updates the track data object for the current track.

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

Parameters

data: null | object

New data object to sync with the group. This value will be synchronized using a last writer wins strategy.

Returns

Promise<void>

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

Remarks

The track data object can be used by applications to synchronize things like pitch, roll, and yaw of a 360 video. This data object will be reset to null anytime the track changes.

Throws an exception if the session/coordinator hasn't been initialized or canSetTrackData is false.

Alias for emitter.on(eventName, listener).

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

Parameters

eventName: string | symbol

listener: (args: any[]) => void

Returns

LiveMediaSessionCoordinator

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

eventName: string | symbol

args: any[]

Returns

boolean

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

(string | symbol)[]

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

number

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

eventName: string | symbol

The name of the event being listened for

listener: (args: any[]) => void

The event handler function

Returns

number

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

eventName: string | symbol

Returns

(args: any[]) => void[]

Inherited From EventEmitter.listeners

Alias for emitter.removeListener().

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

Parameters

eventName: string | symbol

listener: (args: any[]) => void

Returns

LiveMediaSessionCoordinator

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): LiveMediaSessionCoordinator

Parameters

eventName: string | symbol

The name of the event.

listener: (args: any[]) => void

The callback function

Returns

LiveMediaSessionCoordinator

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): LiveMediaSessionCoordinator

Parameters

eventName: string | symbol

The name of the event.

listener: (args: any[]) => void

The callback function

Returns

LiveMediaSessionCoordinator

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): LiveMediaSessionCoordinator

Parameters

eventName: string | symbol

The name of the event.

listener: (args: any[]) => void

The callback function

Returns

LiveMediaSessionCoordinator

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): LiveMediaSessionCoordinator

Parameters

eventName: string | symbol

The name of the event.

listener: (args: any[]) => void

The callback function

Returns

LiveMediaSessionCoordinator

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

eventName: string | symbol

Returns

(args: any[]) => void[]

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): LiveMediaSessionCoordinator

Parameters

eventName: string | symbol

Returns

LiveMediaSessionCoordinator

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): LiveMediaSessionCoordinator

Parameters

eventName: string | symbol

listener: (args: any[]) => void

Returns

LiveMediaSessionCoordinator

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): LiveMediaSessionCoordinator

Parameters

n: number

Returns

LiveMediaSessionCoordinator

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

error: Error

event: string | symbol

args: any[]

Inherited From EventEmitter.__@captureRejectionSymbol@144

Properties

Methods

Inherited Methods

Property Details

canPlayPause

Property Value

Remarks

canSeek

Property Value

Remarks

canSendPositionUpdates

Property Value

Remarks

canSetPlaybackRate

Property Value

Remarks

canSetTrack

Property Value

Remarks

canSetTrackData

Property Value

Remarks

isSuspended

Property Value

maxPlaybackDrift

Property Value

positionUpdateInterval

Property Value

Method Details

beginSuspension(CoordinationWaitPoint)

Parameters

Returns

Remarks

pause()

Returns

Remarks

play()

Returns

Remarks

seekTo(number)

Parameters

Returns

Remarks

setPlaybackRate(number)

Parameters

Returns

setTrack(null | ExtendedMediaMetadata, CoordinationWaitPoint[])

Parameters

Returns

Remarks

setTrackData(null | object)

Parameters

Returns

Remarks

Inherited Method Details

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

Parameters

Returns

emit<E>(string | symbol, any[])

Parameters

Returns

eventNames()

Returns

getMaxListeners()

Returns

listenerCount<E>(string | symbol, (args: any[]) => void)

Parameters

Returns

listeners<E>(string | symbol)

Parameters

Returns

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

Parameters

Returns

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

Parameters

Returns

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

Parameters