@signageos/front-applet 7.1.1 → 8.0.0

package/docs/sos/stream.md

@@ -0,0 +1,960 @@
+# stream
+
+The `sos.video` API groups together methods for streaming videos.
+
+:::warning
+
+Are you using **Samsung Tizen** to play streams? Read more about limitation and
+[Tizen-specific details](https://docs.signageos.io/hc/en-us/articles/4405387373458).
+
+:::
+
+:::danger
+
+Be aware version of JS API (v6.0.0+) changed how stream functions `play()` and `prepare()` work. For using an options object you need to
+our latest core app versions. If you are using older core app versions, you need to use deprecated format.
+
+:::
+
+## Methods
+
+### getTracks()
+
+The `getTracks()` method returns a track list of a stream.
+
+```ts expandable
+getTracks(videoId: IVideoProperties): Promise<ITrackInfo[]>;
+// show-more
+interface IVideoProperties {
+    uri: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+
+type ITrackInfo = ITrackVideoInfo | ITrackAudioInfo | ITrackTextInfo;
+
+interface ITrackVideoInfo extends ITrack<'VIDEO'> {
+    videoSize: {
+        width: number;
+        height: number;
+    };
+}
+
+interface ITrack<T extends TrackType> {
+    trackType: T;
+    mimeType: string;
+    groupId: string;
+    trackIndex: number;
+    selected: boolean;
+    language: string | null;
+    supported: boolean;
+}
+
+type TrackType = 'TEXT' | 'AUDIO' | 'VIDEO';
+
+interface ITrackAudioInfo extends ITrack<'AUDIO'> {
+    channelCount: number;
+}
+
+interface ITrackTextInfo extends ITrack<'TEXT'> {
+    selection: string[];
+}
+
+```
+
+<Separator />
+
+### onConnected()
+
+The `onConnected()` method sets up a listener, which is called whenever a stream is connected.
+
+```ts expandable
+onConnected(listener: (event: IStreamEvent<'connected'>) => void): void;
+// show-more
+interface IStreamEvent<T extends StreamEventType> {
+    type: T;
+    srcArguments: IStreamEventProperties;
+}
+
+type StreamEventType = 'connected' | 'disconnected' | 'error' | 'stop' | 'play' | 'prepare' | 'pause' | 'resume' | 'tracks_changed';
+
+interface IStreamEventProperties {
+    uri: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    protocol?: keyof typeof StreamProtocol | string;
+    /**
+     * @deprecated Events should not return options object instead should return protocol {@link protocol}
+     */
+    options?: IStreamOptions | IStreamPrepareOptions;
+}
+
+interface IStreamOptions extends IOptions {
+    protocol?: keyof typeof StreamProtocol | string;
+    autoReconnect?: boolean;
+    autoReconnectInterval?: number;
+}
+
+interface IOptions {
+    /** @deprecated */
+    '4k'?: boolean;
+    background?: boolean;
+    volume?: number;
+}
+
+interface IStreamPrepareOptions extends IStreamOptions {
+    trackSelection?: {
+        /** Maximum number of audio channels to play */
+        maxAudioChannelCount?: number;
+        /** Minimum video size to play */
+        minVideoSize?: {
+            width: number;
+            height: number;
+        };
+        /** Maximum video size to play */
+        maxVideoSize?: {
+            width: number;
+            height: number;
+        };
+        /** Preferred audio languages to play */
+        preferredAudioLanguages?: string[];
+        /** Preferred text languages to play */
+        preferredTextLanguages?: string[];
+    };
+    drm?: {
+        scheme: DrmScheme;
+        licenseUri: string;
+        licenseRequestHeaders: {
+            [key: string]: string;
+        };
+    };
+}
+
+type DrmScheme = 'CommonPSSH' | 'ClearKey' | 'Widevine' | 'PlayReady' | AnyString;
+
+type AnyString = string & {};
+
+```
+
+<Separator />
+
+### onDisconnected()
+
+The `onDisconnected()` method sets up a listener, which is called whenever a stream gets disconnected.
+
+```ts expandable
+onDisconnected(listener: (event: IStreamEvent<'disconnected'>) => void): void;
+// show-more
+interface IStreamEvent<T extends StreamEventType> {
+    type: T;
+    srcArguments: IStreamEventProperties;
+}
+
+type StreamEventType = 'connected' | 'disconnected' | 'error' | 'stop' | 'play' | 'prepare' | 'pause' | 'resume' | 'tracks_changed';
+
+interface IStreamEventProperties {
+    uri: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    protocol?: keyof typeof StreamProtocol | string;
+    /**
+     * @deprecated Events should not return options object instead should return protocol {@link protocol}
+     */
+    options?: IStreamOptions | IStreamPrepareOptions;
+}
+
+interface IStreamOptions extends IOptions {
+    protocol?: keyof typeof StreamProtocol | string;
+    autoReconnect?: boolean;
+    autoReconnectInterval?: number;
+}
+
+interface IOptions {
+    /** @deprecated */
+    '4k'?: boolean;
+    background?: boolean;
+    volume?: number;
+}
+
+interface IStreamPrepareOptions extends IStreamOptions {
+    trackSelection?: {
+        /** Maximum number of audio channels to play */
+        maxAudioChannelCount?: number;
+        /** Minimum video size to play */
+        minVideoSize?: {
+            width: number;
+            height: number;
+        };
+        /** Maximum video size to play */
+        maxVideoSize?: {
+            width: number;
+            height: number;
+        };
+        /** Preferred audio languages to play */
+        preferredAudioLanguages?: string[];
+        /** Preferred text languages to play */
+        preferredTextLanguages?: string[];
+    };
+    drm?: {
+        scheme: DrmScheme;
+        licenseUri: string;
+        licenseRequestHeaders: {
+            [key: string]: string;
+        };
+    };
+}
+
+type DrmScheme = 'CommonPSSH' | 'ClearKey' | 'Widevine' | 'PlayReady' | AnyString;
+
+type AnyString = string & {};
+
+```
+
+<Separator />
+
+### onError()
+
+The `onTracksChanged()` method sets up a listener, which is called whenever an unexpected error occurs during a stream.
+
+```ts expandable
+onError(listener: (event: IStreamErrorEvent) => void): void;
+// show-more
+interface IStreamErrorEvent extends IStreamEvent<'error'> {
+    errorMessage?: string | undefined;
+}
+
+interface IStreamEvent<T extends StreamEventType> {
+    type: T;
+    srcArguments: IStreamEventProperties;
+}
+
+type StreamEventType = 'connected' | 'disconnected' | 'error' | 'stop' | 'play' | 'prepare' | 'pause' | 'resume' | 'tracks_changed';
+
+interface IStreamEventProperties {
+    uri: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    protocol?: keyof typeof StreamProtocol | string;
+    /**
+     * @deprecated Events should not return options object instead should return protocol {@link protocol}
+     */
+    options?: IStreamOptions | IStreamPrepareOptions;
+}
+
+interface IStreamOptions extends IOptions {
+    protocol?: keyof typeof StreamProtocol | string;
+    autoReconnect?: boolean;
+    autoReconnectInterval?: number;
+}
+
+interface IOptions {
+    /** @deprecated */
+    '4k'?: boolean;
+    background?: boolean;
+    volume?: number;
+}
+
+interface IStreamPrepareOptions extends IStreamOptions {
+    trackSelection?: {
+        /** Maximum number of audio channels to play */
+        maxAudioChannelCount?: number;
+        /** Minimum video size to play */
+        minVideoSize?: {
+            width: number;
+            height: number;
+        };
+        /** Maximum video size to play */
+        maxVideoSize?: {
+            width: number;
+            height: number;
+        };
+        /** Preferred audio languages to play */
+        preferredAudioLanguages?: string[];
+        /** Preferred text languages to play */
+        preferredTextLanguages?: string[];
+    };
+    drm?: {
+        scheme: DrmScheme;
+        licenseUri: string;
+        licenseRequestHeaders: {
+            [key: string]: string;
+        };
+    };
+}
+
+type DrmScheme = 'CommonPSSH' | 'ClearKey' | 'Widevine' | 'PlayReady' | AnyString;
+
+type AnyString = string & {};
+
+```
+
+<Separator />
+
+### onPause()
+
+The `onStop()` method sets up a listener, which is called whenever a stream is paused.
+
+```ts expandable
+onPause(listener: (event: IStreamEvent<'pause'>) => void): void;
+// show-more
+interface IStreamEvent<T extends StreamEventType> {
+    type: T;
+    srcArguments: IStreamEventProperties;
+}
+
+type StreamEventType = 'connected' | 'disconnected' | 'error' | 'stop' | 'play' | 'prepare' | 'pause' | 'resume' | 'tracks_changed';
+
+interface IStreamEventProperties {
+    uri: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    protocol?: keyof typeof StreamProtocol | string;
+    /**
+     * @deprecated Events should not return options object instead should return protocol {@link protocol}
+     */
+    options?: IStreamOptions | IStreamPrepareOptions;
+}
+
+interface IStreamOptions extends IOptions {
+    protocol?: keyof typeof StreamProtocol | string;
+    autoReconnect?: boolean;
+    autoReconnectInterval?: number;
+}
+
+interface IOptions {
+    /** @deprecated */
+    '4k'?: boolean;
+    background?: boolean;
+    volume?: number;
+}
+
+interface IStreamPrepareOptions extends IStreamOptions {
+    trackSelection?: {
+        /** Maximum number of audio channels to play */
+        maxAudioChannelCount?: number;
+        /** Minimum video size to play */
+        minVideoSize?: {
+            width: number;
+            height: number;
+        };
+        /** Maximum video size to play */
+        maxVideoSize?: {
+            width: number;
+            height: number;
+        };
+        /** Preferred audio languages to play */
+        preferredAudioLanguages?: string[];
+        /** Preferred text languages to play */
+        preferredTextLanguages?: string[];
+    };
+    drm?: {
+        scheme: DrmScheme;
+        licenseUri: string;
+        licenseRequestHeaders: {
+            [key: string]: string;
+        };
+    };
+}
+
+type DrmScheme = 'CommonPSSH' | 'ClearKey' | 'Widevine' | 'PlayReady' | AnyString;
+
+type AnyString = string & {};
+
+```
+
+<Separator />
+
+### onPlay()
+
+The `onPlay()` method sets up a listener, which is called whenever a stream starts playing.
+
+```ts expandable
+onPlay(listener: (event: IStreamEvent<'play'>) => void): void;
+// show-more
+interface IStreamEvent<T extends StreamEventType> {
+    type: T;
+    srcArguments: IStreamEventProperties;
+}
+
+type StreamEventType = 'connected' | 'disconnected' | 'error' | 'stop' | 'play' | 'prepare' | 'pause' | 'resume' | 'tracks_changed';
+
+interface IStreamEventProperties {
+    uri: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    protocol?: keyof typeof StreamProtocol | string;
+    /**
+     * @deprecated Events should not return options object instead should return protocol {@link protocol}
+     */
+    options?: IStreamOptions | IStreamPrepareOptions;
+}
+
+interface IStreamOptions extends IOptions {
+    protocol?: keyof typeof StreamProtocol | string;
+    autoReconnect?: boolean;
+    autoReconnectInterval?: number;
+}
+
+interface IOptions {
+    /** @deprecated */
+    '4k'?: boolean;
+    background?: boolean;
+    volume?: number;
+}
+
+interface IStreamPrepareOptions extends IStreamOptions {
+    trackSelection?: {
+        /** Maximum number of audio channels to play */
+        maxAudioChannelCount?: number;
+        /** Minimum video size to play */
+        minVideoSize?: {
+            width: number;
+            height: number;
+        };
+        /** Maximum video size to play */
+        maxVideoSize?: {
+            width: number;
+            height: number;
+        };
+        /** Preferred audio languages to play */
+        preferredAudioLanguages?: string[];
+        /** Preferred text languages to play */
+        preferredTextLanguages?: string[];
+    };
+    drm?: {
+        scheme: DrmScheme;
+        licenseUri: string;
+        licenseRequestHeaders: {
+            [key: string]: string;
+        };
+    };
+}
+
+type DrmScheme = 'CommonPSSH' | 'ClearKey' | 'Widevine' | 'PlayReady' | AnyString;
+
+type AnyString = string & {};
+
+```
+
+<Separator />
+
+### onPrepare()
+
+The `onPrepare()` method sets up a listener, which is called whenever a stream gets prepared.
+
+```ts expandable
+onPrepare(listener: (event: IStreamEvent<'prepare'>) => void): void;
+// show-more
+interface IStreamEvent<T extends StreamEventType> {
+    type: T;
+    srcArguments: IStreamEventProperties;
+}
+
+type StreamEventType = 'connected' | 'disconnected' | 'error' | 'stop' | 'play' | 'prepare' | 'pause' | 'resume' | 'tracks_changed';
+
+interface IStreamEventProperties {
+    uri: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    protocol?: keyof typeof StreamProtocol | string;
+    /**
+     * @deprecated Events should not return options object instead should return protocol {@link protocol}
+     */
+    options?: IStreamOptions | IStreamPrepareOptions;
+}
+
+interface IStreamOptions extends IOptions {
+    protocol?: keyof typeof StreamProtocol | string;
+    autoReconnect?: boolean;
+    autoReconnectInterval?: number;
+}
+
+interface IOptions {
+    /** @deprecated */
+    '4k'?: boolean;
+    background?: boolean;
+    volume?: number;
+}
+
+interface IStreamPrepareOptions extends IStreamOptions {
+    trackSelection?: {
+        /** Maximum number of audio channels to play */
+        maxAudioChannelCount?: number;
+        /** Minimum video size to play */
+        minVideoSize?: {
+            width: number;
+            height: number;
+        };
+        /** Maximum video size to play */
+        maxVideoSize?: {
+            width: number;
+            height: number;
+        };
+        /** Preferred audio languages to play */
+        preferredAudioLanguages?: string[];
+        /** Preferred text languages to play */
+        preferredTextLanguages?: string[];
+    };
+    drm?: {
+        scheme: DrmScheme;
+        licenseUri: string;
+        licenseRequestHeaders: {
+            [key: string]: string;
+        };
+    };
+}
+
+type DrmScheme = 'CommonPSSH' | 'ClearKey' | 'Widevine' | 'PlayReady' | AnyString;
+
+type AnyString = string & {};
+
+```
+
+<Separator />
+
+### onResume()
+
+The `onStop()` method sets up a listener, which is called whenever a stream is resumed.
+
+```ts expandable
+onResume(listener: (event: IStreamEvent<'resume'>) => void): void;
+// show-more
+interface IStreamEvent<T extends StreamEventType> {
+    type: T;
+    srcArguments: IStreamEventProperties;
+}
+
+type StreamEventType = 'connected' | 'disconnected' | 'error' | 'stop' | 'play' | 'prepare' | 'pause' | 'resume' | 'tracks_changed';
+
+interface IStreamEventProperties {
+    uri: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    protocol?: keyof typeof StreamProtocol | string;
+    /**
+     * @deprecated Events should not return options object instead should return protocol {@link protocol}
+     */
+    options?: IStreamOptions | IStreamPrepareOptions;
+}
+
+interface IStreamOptions extends IOptions {
+    protocol?: keyof typeof StreamProtocol | string;
+    autoReconnect?: boolean;
+    autoReconnectInterval?: number;
+}
+
+interface IOptions {
+    /** @deprecated */
+    '4k'?: boolean;
+    background?: boolean;
+    volume?: number;
+}
+
+interface IStreamPrepareOptions extends IStreamOptions {
+    trackSelection?: {
+        /** Maximum number of audio channels to play */
+        maxAudioChannelCount?: number;
+        /** Minimum video size to play */
+        minVideoSize?: {
+            width: number;
+            height: number;
+        };
+        /** Maximum video size to play */
+        maxVideoSize?: {
+            width: number;
+            height: number;
+        };
+        /** Preferred audio languages to play */
+        preferredAudioLanguages?: string[];
+        /** Preferred text languages to play */
+        preferredTextLanguages?: string[];
+    };
+    drm?: {
+        scheme: DrmScheme;
+        licenseUri: string;
+        licenseRequestHeaders: {
+            [key: string]: string;
+        };
+    };
+}
+
+type DrmScheme = 'CommonPSSH' | 'ClearKey' | 'Widevine' | 'PlayReady' | AnyString;
+
+type AnyString = string & {};
+
+```
+
+<Separator />
+
+### onStop()
+
+The `onStop()` method sets up a listener, which is called whenever a stream stops.
+
+```ts expandable
+onStop(listener: (event: IStreamEvent<'stop'>) => void): void;
+// show-more
+interface IStreamEvent<T extends StreamEventType> {
+    type: T;
+    srcArguments: IStreamEventProperties;
+}
+
+type StreamEventType = 'connected' | 'disconnected' | 'error' | 'stop' | 'play' | 'prepare' | 'pause' | 'resume' | 'tracks_changed';
+
+interface IStreamEventProperties {
+    uri: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    protocol?: keyof typeof StreamProtocol | string;
+    /**
+     * @deprecated Events should not return options object instead should return protocol {@link protocol}
+     */
+    options?: IStreamOptions | IStreamPrepareOptions;
+}
+
+interface IStreamOptions extends IOptions {
+    protocol?: keyof typeof StreamProtocol | string;
+    autoReconnect?: boolean;
+    autoReconnectInterval?: number;
+}
+
+interface IOptions {
+    /** @deprecated */
+    '4k'?: boolean;
+    background?: boolean;
+    volume?: number;
+}
+
+interface IStreamPrepareOptions extends IStreamOptions {
+    trackSelection?: {
+        /** Maximum number of audio channels to play */
+        maxAudioChannelCount?: number;
+        /** Minimum video size to play */
+        minVideoSize?: {
+            width: number;
+            height: number;
+        };
+        /** Maximum video size to play */
+        maxVideoSize?: {
+            width: number;
+            height: number;
+        };
+        /** Preferred audio languages to play */
+        preferredAudioLanguages?: string[];
+        /** Preferred text languages to play */
+        preferredTextLanguages?: string[];
+    };
+    drm?: {
+        scheme: DrmScheme;
+        licenseUri: string;
+        licenseRequestHeaders: {
+            [key: string]: string;
+        };
+    };
+}
+
+type DrmScheme = 'CommonPSSH' | 'ClearKey' | 'Widevine' | 'PlayReady' | AnyString;
+
+type AnyString = string & {};
+
+```
+
+<Separator />
+
+### onTracksChanged()
+
+The `onTracksChanged()` method sets up a listener, which is called whenever a track is changed.
+
+```ts expandable
+onTracksChanged(listener: (event: IStreamTracksChangedEvent) => void): void;
+// show-more
+interface IStreamTracksChangedEvent extends IStreamEvent<'tracks_changed'> {
+    tracks: ITrackInfo[] | undefined;
+}
+
+type ITrackInfo = ITrackVideoInfo | ITrackAudioInfo | ITrackTextInfo;
+
+interface ITrackVideoInfo extends ITrack<'VIDEO'> {
+    videoSize: {
+        width: number;
+        height: number;
+    };
+}
+
+interface ITrack<T extends TrackType> {
+    trackType: T;
+    mimeType: string;
+    groupId: string;
+    trackIndex: number;
+    selected: boolean;
+    language: string | null;
+    supported: boolean;
+}
+
+type TrackType = 'TEXT' | 'AUDIO' | 'VIDEO';
+
+interface ITrackAudioInfo extends ITrack<'AUDIO'> {
+    channelCount: number;
+}
+
+interface ITrackTextInfo extends ITrack<'TEXT'> {
+    selection: string[];
+}
+
+interface IStreamEvent<T extends StreamEventType> {
+    type: T;
+    srcArguments: IStreamEventProperties;
+}
+
+type StreamEventType = 'connected' | 'disconnected' | 'error' | 'stop' | 'play' | 'prepare' | 'pause' | 'resume' | 'tracks_changed';
+
+interface IStreamEventProperties {
+    uri: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    protocol?: keyof typeof StreamProtocol | string;
+    /**
+     * @deprecated Events should not return options object instead should return protocol {@link protocol}
+     */
+    options?: IStreamOptions | IStreamPrepareOptions;
+}
+
+interface IStreamOptions extends IOptions {
+    protocol?: keyof typeof StreamProtocol | string;
+    autoReconnect?: boolean;
+    autoReconnectInterval?: number;
+}
+
+interface IOptions {
+    /** @deprecated */
+    '4k'?: boolean;
+    background?: boolean;
+    volume?: number;
+}
+
+interface IStreamPrepareOptions extends IStreamOptions {
+    trackSelection?: {
+        /** Maximum number of audio channels to play */
+        maxAudioChannelCount?: number;
+        /** Minimum video size to play */
+        minVideoSize?: {
+            width: number;
+            height: number;
+        };
+        /** Maximum video size to play */
+        maxVideoSize?: {
+            width: number;
+            height: number;
+        };
+        /** Preferred audio languages to play */
+        preferredAudioLanguages?: string[];
+        /** Preferred text languages to play */
+        preferredTextLanguages?: string[];
+    };
+    drm?: {
+        scheme: DrmScheme;
+        licenseUri: string;
+        licenseRequestHeaders: {
+            [key: string]: string;
+        };
+    };
+}
+
+type DrmScheme = 'CommonPSSH' | 'ClearKey' | 'Widevine' | 'PlayReady' | AnyString;
+
+type AnyString = string & {};
+
+```
+
+<Separator />
+
+### pause()
+
+The `pause()` method pauses the stream, it can be resumed with `resume()`.
+
+```ts expandable
+pause(uri: string, x: number, y: number, width: number, height: number): Promise<void>;
+```
+
+<Separator />
+
+### play()
+
+The `play()` method starts the streaming of a streaming previously prepared by `prepare()` method.
+
+```ts expandable
+play(uri: string, x: number, y: number, width: number, height: number, options?: IStreamOptions | keyof typeof StreamProtocol): Promise<void>;
+// show-more
+interface IStreamOptions extends IOptions {
+    protocol?: keyof typeof StreamProtocol | string;
+    autoReconnect?: boolean;
+    autoReconnectInterval?: number;
+}
+
+interface IOptions {
+    /** @deprecated */
+    '4k'?: boolean;
+    background?: boolean;
+    volume?: number;
+}
+
+```
+
+<Separator />
+
+### prepare()
+
+The `prepare()` method prepares the stream in the background.
+
+:::info
+
+If you want to play a video stream in full screen mode, use x = y = 0 and width = document.documentElement.clientWidth and height = document.documentElement.clientHeight as setup parameters.
+
+:::
+
+```ts expandable
+prepare(uri: string, x: number, y: number, width: number, height: number, options?: IStreamPrepareOptions | keyof typeof StreamProtocol): Promise<void>;
+// show-more
+interface IStreamPrepareOptions extends IStreamOptions {
+    trackSelection?: {
+        /** Maximum number of audio channels to play */
+        maxAudioChannelCount?: number;
+        /** Minimum video size to play */
+        minVideoSize?: {
+            width: number;
+            height: number;
+        };
+        /** Maximum video size to play */
+        maxVideoSize?: {
+            width: number;
+            height: number;
+        };
+        /** Preferred audio languages to play */
+        preferredAudioLanguages?: string[];
+        /** Preferred text languages to play */
+        preferredTextLanguages?: string[];
+    };
+    drm?: {
+        scheme: DrmScheme;
+        licenseUri: string;
+        licenseRequestHeaders: {
+            [key: string]: string;
+        };
+    };
+}
+
+type DrmScheme = 'CommonPSSH' | 'ClearKey' | 'Widevine' | 'PlayReady' | AnyString;
+
+type AnyString = string & {};
+
+interface IStreamOptions extends IOptions {
+    protocol?: keyof typeof StreamProtocol | string;
+    autoReconnect?: boolean;
+    autoReconnectInterval?: number;
+}
+
+interface IOptions {
+    /** @deprecated */
+    '4k'?: boolean;
+    background?: boolean;
+    volume?: number;
+}
+
+```
+
+:::note[GitHub Example]
+
+- [object Object]://github.com/signageos/applet-examples/tree/master/examples/content-js-api/stream
+
+:::
+
+<Separator />
+
+### removeEventListeners()
+
+The `removeEventListeners()` removes all listeners set up on `sos.stream`.
+
+```ts expandable
+removeEventListeners(): void;
+```
+
+<Separator />
+
+### resetTrack()
+
+The `resetTrack()` method resets a track of a stream.
+
+```ts expandable
+resetTrack(videoId: IVideoProperties, trackType: TrackType, groupId?: string): Promise<void>;
+// show-more
+interface IVideoProperties {
+    uri: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+
+type TrackType = 'TEXT' | 'AUDIO' | 'VIDEO';
+
+```
+
+<Separator />
+
+### resume()
+
+The `resume()` method resumes the stream paused by `pause()`.
+
+```ts expandable
+resume(uri: string, x: number, y: number, width: number, height: number): Promise<void>;
+```
+
+<Separator />
+
+### selectTrack()
+
+The `selectTrack()` method selects a track of a stream.
+
+```ts expandable
+selectTrack(videoId: IVideoProperties, trackType: TrackType, groupId: string, trackIndex: number): Promise<void>;
+// show-more
+interface IVideoProperties {
+    uri: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+
+type TrackType = 'TEXT' | 'AUDIO' | 'VIDEO';
+
+```
+
+<Separator />
+
+### stop()
+
+The `stop()` method stops the stream, it can't be resumed with `resume()`.
+
+```ts expandable
+stop(uri: string, x: number, y: number, width: number, height: number): Promise<void>;
+```