@microsoft/live-share-media 1.0.0-preview.9 → 1.0.1

package/bin/LiveMediaSessionCoordinator.js

@@ -1,408 +1,477 @@
-"use strict";
-/**
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the Microsoft Live Share SDK License.
- */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LiveMediaSessionCoordinator = void 0;
-const live_share_1 = require("@microsoft/live-share");
-const internals_1 = require("./internals");
-const LiveMediaSessionCoordinatorSuspension_1 = require("./LiveMediaSessionCoordinatorSuspension");
-const events_1 = __importDefault(require("events"));
-/**
- * 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.
- */
-class LiveMediaSessionCoordinator extends events_1.default {
-    /**
-     * @hidden
-     * Applications shouldn't directly create new coordinator instances.
-     */
-    constructor(runtime, getPlayerState) {
-        super();
-        this._positionUpdateInterval = new live_share_1.TimeInterval(2000);
-        this._maxPlaybackDrift = new live_share_1.TimeInterval(1000);
-        this._hasInitialized = false;
-        /**
-         * Controls whether or not the local client is allowed to instruct the group to play or pause.
-         *
-         * @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.
-         */
-        this.canPlayPause = true;
-        /**
-         * Controls whether or not the local client is allowed to seek the group to a new playback
-         * position.
-         *
-         * @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.
-         */
-        this.canSeek = true;
-        /**
-         * Controls whether or not the local client is allowed to change tracks.
-         *
-         * @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.
-         */
-        this.canSetTrack = true;
-        /**
-         * Controls whether or not the local client is allowed to change the tracks custom data object.
-         *
-         * @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.
-         */
-        this.canSetTrackData = true;
-        this._runtime = runtime;
-        this._logger = new live_share_1.LiveTelemetryLogger(runtime);
-        this._getPlayerState = getPlayerState;
-    }
-    /**
-     * Returns true if the local client is in a suspended state.
-     */
-    get isSuspended() {
-        return this._groupState ? this._groupState.isSuspended : false;
-    }
-    /**
-     * Max amount of playback drift allowed in seconds.
-     *
-     * @remarks
-     * Should the local clients playback position lag by more than the specified value, the
-     * coordinator will trigger a `catchup` action.
-     *
-     * Defaults to a value of `1` second.
-     */
-    get maxPlaybackDrift() {
-        return this._maxPlaybackDrift.seconds;
-    }
-    set maxPlaybackDrift(value) {
-        this._maxPlaybackDrift.seconds = value;
-    }
-    /**
-     * Frequency with which position updates are broadcast to the rest of the group in
-     * seconds.
-     *
-     * @remarks
-     * Defaults to a value of `2` seconds.
-     */
-    get positionUpdateInterval() {
-        return this._positionUpdateInterval.seconds;
-    }
-    set positionUpdateInterval(value) {
-        this._positionUpdateInterval.seconds = value;
-    }
-    /**
-     * Instructs the group to play the current track.
-     *
-     * @remarks
-     * Throws an exception if the session/coordinator hasn't been initialized, no track has been
-     * loaded, or `canPlayPause` is false.
-     */
-    play() {
-        var _a;
-        if (!this._hasInitialized) {
-            throw new Error(`LiveMediaSessionCoordinator.play() called before initialize() called.`);
-        }
-        if (!((_a = this._groupState) === null || _a === void 0 ? void 0 : _a.playbackTrack.current.metadata)) {
-            throw new Error(`LiveMediaSessionCoordinator.play() called before MediaSession.metadata assigned.`);
-        }
-        if (!this.canPlayPause) {
-            throw new Error(`LiveMediaSessionCoordinator.play() operation blocked.`);
-        }
-        // Get projected position
-        const position = this.getPlayerPosition();
-        // Send transport command
-        this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.SessionCoordinator.PlayCalled, null, { position: position });
-        this._playEvent.sendEvent({
-            track: this._groupState.playbackTrack.current,
-            position: position,
-        });
-    }
-    /**
-     * Instructs the group to pause the current track.
-     *
-     * @remarks
-     * Throws an exception if the session/coordinator hasn't been initialized, no track has been
-     * loaded, or `canPlayPause` is false.
-     */
-    pause() {
-        var _a;
-        if (!this._hasInitialized) {
-            throw new Error(`LiveMediaSessionCoordinator.pause() called before initialize() called.`);
-        }
-        if (!((_a = this._groupState) === null || _a === void 0 ? void 0 : _a.playbackTrack.current.metadata)) {
-            throw new Error(`LiveMediaSessionCoordinator.pause() called before MediaSession.metadata assigned.`);
-        }
-        if (!this.canPlayPause) {
-            throw new Error(`LiveMediaSessionCoordinator.pause() operation blocked.`);
-        }
-        // Get projected position
-        const position = this.getPlayerPosition();
-        // Send transport command
-        this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.SessionCoordinator.PauseCalled, null, { position: position });
-        this._pauseEvent.sendEvent({
-            track: this._groupState.playbackTrack.current,
-            position: position,
-        });
-    }
-    /**
-     * Instructs the group to seek to a new position within the current track.
-     *
-     * @remarks
-     * Throws an exception if the session/coordinator hasn't been initialized, no track has been
-     * loaded, or `canSeek` is false.
-     * @param time Playback position in seconds to seek to.
-     */
-    seekTo(time) {
-        var _a;
-        if (!this._hasInitialized) {
-            throw new Error(`LiveMediaSessionCoordinator.seekTo() called before initialize() called.`);
-        }
-        if (!((_a = this._groupState) === null || _a === void 0 ? void 0 : _a.playbackTrack.current.metadata)) {
-            throw new Error(`LiveMediaSessionCoordinator.seekTo() called before MediaSession.metadata assigned.`);
-        }
-        if (!this.canSeek) {
-            throw new Error(`LiveMediaSessionCoordinator.seekTo() operation blocked.`);
-        }
-        // Send transport command
-        this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.SessionCoordinator.SeekToCalled, null, { position: time });
-        this._seekToEvent.sendEvent({
-            track: this._groupState.playbackTrack.current,
-            position: time,
-        });
-    }
-    /**
-     * Instructs the group to load a new track.
-     *
-     * @remarks
-     * Throws an exception if the session/coordinator hasn't been initialized or `canSetTrack` is
-     * false.
-     * @param metadata The track to load or `null` to indicate that the end of the track is reached.
-     * @param waitPoints Optional. List of static wait points to configure for the track.  Dynamic wait points can be added via the `beginSuspension()` call.
-     */
-    setTrack(metadata, waitPoints) {
-        if (!this._hasInitialized) {
-            throw new Error(`LiveMediaSessionCoordinator.setTrack() called before initialize() called.`);
-        }
-        if (!this.canSetTrack) {
-            throw new Error(`LiveMediaSessionCoordinator.setTrack() operation blocked.`);
-        }
-        // Send transport command
-        this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.SessionCoordinator.SetTrackCalled);
-        this._setTrackEvent.sendEvent({
-            metadata: metadata,
-            waitPoints: waitPoints || [],
-        });
-    }
-    /**
-     * Updates the track data object for the current track.
-     *
-     * @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.
-     * @param data New data object to sync with the group. This value will be synchronized using a last writer wins strategy.
-     */
-    setTrackData(data) {
-        if (!this._hasInitialized) {
-            throw new Error(`LiveMediaSessionCoordinator.setTrackData() called before initialize() called.`);
-        }
-        if (!this.canSetTrackData) {
-            throw new Error(`LiveMediaSessionCoordinator.setTrackData() operation blocked.`);
-        }
-        // Send transport command
-        this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.SessionCoordinator.SetTrackDataCalled);
-        this._setTrackDataEvent.sendEvent({
-            data: data,
-        });
-    }
-    /**
-     * Begins a new local 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.
-     * @param waitPoint Optional. Dynamic wait point to broadcast to all of the clients.
-     * @returns The suspension object. Call `end()` on the returned suspension to end the suspension.
-     */
-    beginSuspension(waitPoint) {
-        var _a;
-        if (!this._hasInitialized) {
-            throw new Error(`LiveMediaSessionCoordinator.beginSuspension() called before initialize() called.`);
-        }
-        if (!((_a = this._groupState) === null || _a === void 0 ? void 0 : _a.playbackTrack.current.metadata)) {
-            throw new Error(`LiveMediaSessionCoordinator.beginSuspension() called before MediaSession.metadata assigned.`);
-        }
-        // Tell group state that suspension is started
-        if (waitPoint) {
-            this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.SessionCoordinator.BeginSuspensionAndWait, null, {
-                position: waitPoint.position,
-                maxClients: waitPoint.maxClients,
-            });
-            this._lastWaitPoint = waitPoint;
-            this._groupState.beginSuspension(waitPoint);
-        }
-        else {
-            this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.SessionCoordinator.BeginSuspension);
-            this._groupState.beginSuspension();
-        }
-        // Return new suspension object
-        return new LiveMediaSessionCoordinatorSuspension_1.LiveMediaSessionCoordinatorSuspension(waitPoint, (time) => {
-            var _a, _b;
-            if (waitPoint) {
-                this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.SessionCoordinator.EndSuspensionAndWait, null, {
-                    position: waitPoint.position,
-                    maxClients: waitPoint.maxClients,
-                });
-            }
-            else {
-                this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.SessionCoordinator.EndSuspension);
-            }
-            this._groupState.endSuspension(time == undefined);
-            if (time != undefined &&
-                !((_a = this._groupState) === null || _a === void 0 ? void 0 : _a.isSuspended) &&
-                !((_b = this._groupState) === null || _b === void 0 ? void 0 : _b.isWaiting)) {
-                // Seek to new position
-                this.seekTo(Math.max(time, 0.0));
-            }
-        });
-    }
-    /**
-     * @hidden
-     * Called by MediaSession to verify the coordinator has been initialized.
-     */
-    get isInitialized() {
-        return this._hasInitialized;
-    }
-    /**
-     * @hidden
-     * Called by MediaSession to start coordinator.
-     */
-    initialize(acceptTransportChangesFrom) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this._hasInitialized) {
-                throw new Error(`LiveMediaSessionCoordinator.initialize() already initialized.`);
-            }
-            // Create children
-            yield this.createChildren(acceptTransportChangesFrom);
-            this._hasInitialized = true;
-        });
-    }
-    /**
-     * @hidden
-     * Called by the MediaSession to detect if a wait point has been hit.
-     */
-    findNextWaitPoint() {
-        var _a;
-        return (((_a = this._groupState) === null || _a === void 0 ? void 0 : _a.playbackTrack.findNextWaitPoint(this._lastWaitPoint)) || null);
-    }
-    /**
-     * @hidden
-     * Called by MediaSession to trigger the sending of a position update.
-     */
-    sendPositionUpdate(state) {
-        var _a;
-        if (!this._hasInitialized) {
-            throw new Error(`LiveMediaSessionCoordinator.sendPositionUpdate() called before initialize() called.`);
-        }
-        // Send position update event
-        const evt = this._groupState.createPositionUpdateEvent(state);
-        (_a = this._positionUpdateEvent) === null || _a === void 0 ? void 0 : _a.sendEvent(evt);
-    }
-    createChildren(acceptTransportChangesFrom) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Create event scopes
-            const scope = new live_share_1.LiveEventScope(this._runtime, acceptTransportChangesFrom);
-            const unrestrictedScope = new live_share_1.LiveEventScope(this._runtime);
-            // Initialize internal coordinator state
-            this._groupState = new internals_1.GroupCoordinatorState(this._runtime, this._maxPlaybackDrift, this._positionUpdateInterval, this._getPlayerState);
-            this._groupState.on(internals_1.GroupCoordinatorStateEvents.triggeraction, (evt) => this.emit(evt.name, evt));
-            // Listen for track changes
-            this._setTrackEvent = new live_share_1.LiveEventTarget(scope, "setTrack", (event, local) => this._groupState.handleSetTrack(event, local));
-            this._setTrackDataEvent = new live_share_1.LiveEventTarget(scope, "setTrackData", (event, local) => this._groupState.handleSetTrackData(event, local));
-            // Listen for transport commands
-            this._playEvent = new live_share_1.LiveEventTarget(scope, "play", (event, local) => this._groupState.handleTransportCommand(event, local));
-            this._pauseEvent = new live_share_1.LiveEventTarget(scope, "pause", (event, local) => this._groupState.handleTransportCommand(event, local));
-            this._seekToEvent = new live_share_1.LiveEventTarget(scope, "seekTo", (event, local) => this._groupState.handleTransportCommand(event, local));
-            // Listen for position updates
-            this._positionUpdateEvent = new live_share_1.LiveEventTarget(unrestrictedScope, "positionUpdate", (event, local) => this._groupState.handlePositionUpdate(event, local));
-            // Listen for joined event
-            this._joinedEvent = new live_share_1.LiveEventTarget(unrestrictedScope, "joined", (evt, local) => {
-                var _a;
-                // Immediately send a position update
-                this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.SessionCoordinator.RemoteJoinReceived, null, {
-                    correlationId: live_share_1.LiveTelemetryLogger.formatCorrelationId(evt.clientId, evt.timestamp),
-                });
-                const state = this._getPlayerState();
-                const update = this._groupState.createPositionUpdateEvent(state);
-                (_a = this._positionUpdateEvent) === null || _a === void 0 ? void 0 : _a.sendEvent(update);
-            });
-            // Send initial joined event
-            this._joinedEvent.sendEvent({});
-        });
-    }
-    getPlayerPosition() {
-        const { positionState, playbackState } = this._getPlayerState();
-        switch (playbackState) {
-            case "none":
-            case "ended":
-                return 0.0;
-            default:
-                return positionState && positionState.position != undefined
-                    ? positionState.position
-                    : 0.0;
-        }
-    }
-}
-exports.LiveMediaSessionCoordinator = LiveMediaSessionCoordinator;
+"use strict";
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the Microsoft Live Share SDK License.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveMediaSessionCoordinator = void 0;
+const live_share_1 = require("@microsoft/live-share");
+const internals_1 = require("./internals");
+const LiveMediaSessionCoordinatorSuspension_1 = require("./LiveMediaSessionCoordinatorSuspension");
+const events_1 = __importDefault(require("events"));
+/**
+ * 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.
+ */
+class LiveMediaSessionCoordinator extends events_1.default {
+    /**
+     * @hidden
+     * Applications shouldn't directly create new coordinator instances.
+     */
+    constructor(runtime, liveRuntime, getPlayerState) {
+        super();
+        this._positionUpdateInterval = new live_share_1.TimeInterval(2000);
+        this._maxPlaybackDrift = new live_share_1.TimeInterval(1000);
+        this._hasInitialized = false;
+        /**
+         * Controls whether or not the local client is allowed to instruct the group to play or pause.
+         *
+         * @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.
+         */
+        this.canPlayPause = true;
+        /**
+         * Controls whether or not the local client is allowed to seek the group to a new playback
+         * position.
+         *
+         * @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.
+         */
+        this.canSeek = true;
+        /**
+         * Controls whether or not the local client is allowed to change tracks.
+         *
+         * @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.
+         */
+        this.canSetTrack = true;
+        /**
+         * Controls whether or not the local client is allowed to change the tracks custom data object.
+         *
+         * @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.
+         */
+        this.canSetTrackData = true;
+        this._runtime = runtime;
+        this._liveRuntime = liveRuntime;
+        this._logger = new live_share_1.LiveTelemetryLogger(runtime, liveRuntime);
+        this._getPlayerState = getPlayerState;
+    }
+    /**
+     * Returns true if the local client is in a suspended state.
+     */
+    get isSuspended() {
+        return this._groupState ? this._groupState.isSuspended : false;
+    }
+    /**
+     * Max amount of playback drift allowed in seconds.
+     *
+     * @remarks
+     * Should the local clients playback position lag by more than the specified value, the
+     * coordinator will trigger a `catchup` action.
+     *
+     * Defaults to a value of `1` second.
+     */
+    get maxPlaybackDrift() {
+        return this._maxPlaybackDrift.seconds;
+    }
+    set maxPlaybackDrift(value) {
+        this._maxPlaybackDrift.seconds = value;
+    }
+    /**
+     * Frequency with which position updates are broadcast to the rest of the group in
+     * seconds.
+     *
+     * @remarks
+     * Defaults to a value of `2` seconds.
+     */
+    get positionUpdateInterval() {
+        return this._positionUpdateInterval.seconds;
+    }
+    set positionUpdateInterval(value) {
+        this._positionUpdateInterval.seconds = value;
+    }
+    /**
+     * Instructs the group to play the current track.
+     *
+     * @remarks
+     * Throws an exception if the session/coordinator hasn't been initialized, no track has been
+     * loaded, or `canPlayPause` is false.
+     *
+     * @returns a void promise that resolves once complete, throws if user does not have proper roles
+     */
+    play() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._hasInitialized) {
+                throw new Error(`LiveMediaSessionCoordinator.play() called before initialize() called.`);
+            }
+            if (!((_a = this._groupState) === null || _a === void 0 ? void 0 : _a.playbackTrack.current.metadata)) {
+                throw new Error(`LiveMediaSessionCoordinator.play() called before MediaSession.metadata assigned.`);
+            }
+            if (!this.canPlayPause) {
+                throw new Error(`LiveMediaSessionCoordinator.play() operation blocked.`);
+            }
+            // Get projected position
+            const position = this.getPlayerPosition();
+            // Send transport command
+            this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.SessionCoordinator.PlayCalled, null, { position: position });
+            yield this._playEvent.sendEvent({
+                track: this._groupState.playbackTrack.current,
+                position: position,
+            });
+        });
+    }
+    /**
+     * Instructs the group to pause the current track.
+     *
+     * @remarks
+     * Throws an exception if the session/coordinator hasn't been initialized, no track has been
+     * loaded, or `canPlayPause` is false.
+     *
+     * @returns a void promise that resolves once complete, throws if user does not have proper roles
+     */
+    pause() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._hasInitialized) {
+                throw new Error(`LiveMediaSessionCoordinator.pause() called before initialize() called.`);
+            }
+            if (!((_a = this._groupState) === null || _a === void 0 ? void 0 : _a.playbackTrack.current.metadata)) {
+                throw new Error(`LiveMediaSessionCoordinator.pause() called before MediaSession.metadata assigned.`);
+            }
+            if (!this.canPlayPause) {
+                throw new Error(`LiveMediaSessionCoordinator.pause() operation blocked.`);
+            }
+            // Get projected position
+            const position = this.getPlayerPosition();
+            // Send transport command
+            this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.SessionCoordinator.PauseCalled, null, { position: position });
+            yield this._pauseEvent.sendEvent({
+                track: this._groupState.playbackTrack.current,
+                position: position,
+            });
+        });
+    }
+    /**
+     * Instructs the group to seek to a new position within the current track.
+     *
+     * @remarks
+     * Throws an exception if the session/coordinator hasn't been initialized, no track has been
+     * loaded, or `canSeek` is false.
+     * @param time Playback position in seconds to seek to.
+     * @returns a void promise that resolves once complete, throws if user does not have proper roles
+     */
+    seekTo(time) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._hasInitialized) {
+                throw new Error(`LiveMediaSessionCoordinator.seekTo() called before initialize() called.`);
+            }
+            if (!((_a = this._groupState) === null || _a === void 0 ? void 0 : _a.playbackTrack.current.metadata)) {
+                throw new Error(`LiveMediaSessionCoordinator.seekTo() called before MediaSession.metadata assigned.`);
+            }
+            if (!this.canSeek) {
+                throw new Error(`LiveMediaSessionCoordinator.seekTo() operation blocked.`);
+            }
+            // Send transport command
+            this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.SessionCoordinator.SeekToCalled, null, { position: time });
+            try {
+                yield this._seekToEvent.sendEvent({
+                    track: this._groupState.playbackTrack.current,
+                    position: time,
+                });
+            }
+            catch (err) {
+                yield this._groupState.syncLocalMediaSession();
+                throw err;
+            }
+        });
+    }
+    /**
+     * Instructs the group to load a new track.
+     *
+     * @remarks
+     * Throws an exception if the session/coordinator hasn't been initialized or `canSetTrack` is
+     * false.
+     * @param metadata The track to load or `null` to indicate that the end of the track is reached.
+     * @param waitPoints Optional. List of static wait points to configure for the track.  Dynamic wait points can be added via the `beginSuspension()` call.
+     * @returns a void promise that resolves once complete, throws if user does not have proper roles
+     */
+    setTrack(metadata, waitPoints) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._hasInitialized) {
+                throw new Error(`LiveMediaSessionCoordinator.setTrack() called before initialize() called.`);
+            }
+            if (!this.canSetTrack) {
+                throw new Error(`LiveMediaSessionCoordinator.setTrack() operation blocked.`);
+            }
+            // Send transport command
+            this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.SessionCoordinator.SetTrackCalled);
+            yield this._setTrackEvent.sendEvent({
+                metadata: metadata,
+                waitPoints: waitPoints || [],
+            });
+        });
+    }
+    /**
+     * Updates the track data object for the current track.
+     *
+     * @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.
+     * @param data New data object to sync with the group. This value will be synchronized using a last writer wins strategy.
+     * @returns a void promise that resolves once complete, throws if user does not have proper roles
+     */
+    setTrackData(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._hasInitialized) {
+                throw new Error(`LiveMediaSessionCoordinator.setTrackData() called before initialize() called.`);
+            }
+            if (!this.canSetTrackData) {
+                throw new Error(`LiveMediaSessionCoordinator.setTrackData() operation blocked.`);
+            }
+            // Send transport command
+            this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.SessionCoordinator.SetTrackDataCalled);
+            yield this._setTrackDataEvent.sendEvent({
+                data: data,
+            });
+        });
+    }
+    /**
+     * Begins a new local 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.
+     * @param waitPoint Optional. Dynamic wait point to broadcast to all of the clients.
+     * @returns The suspension object. Call `end()` on the returned suspension to end the suspension.
+     */
+    beginSuspension(waitPoint) {
+        var _a;
+        if (!this._hasInitialized) {
+            throw new Error(`LiveMediaSessionCoordinator.beginSuspension() called before initialize() called.`);
+        }
+        if (!((_a = this._groupState) === null || _a === void 0 ? void 0 : _a.playbackTrack.current.metadata)) {
+            throw new Error(`LiveMediaSessionCoordinator.beginSuspension() called before MediaSession.metadata assigned.`);
+        }
+        // Tell group state that suspension is started
+        if (waitPoint) {
+            this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.SessionCoordinator.BeginSuspensionAndWait, null, {
+                position: waitPoint.position,
+                maxClients: waitPoint.maxClients,
+            });
+            this._lastWaitPoint = waitPoint;
+            this._groupState.beginSuspension(waitPoint);
+        }
+        else {
+            this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.SessionCoordinator.BeginSuspension);
+            this._groupState.beginSuspension();
+        }
+        // Return new suspension object
+        return new LiveMediaSessionCoordinatorSuspension_1.LiveMediaSessionCoordinatorSuspension(waitPoint, (time) => {
+            var _a, _b;
+            if (waitPoint) {
+                this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.SessionCoordinator.EndSuspensionAndWait, null, {
+                    position: waitPoint.position,
+                    maxClients: waitPoint.maxClients,
+                });
+            }
+            else {
+                this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.SessionCoordinator.EndSuspension);
+            }
+            this._groupState.endSuspension(time == undefined);
+            if (time != undefined &&
+                !((_a = this._groupState) === null || _a === void 0 ? void 0 : _a.isSuspended) &&
+                !((_b = this._groupState) === null || _b === void 0 ? void 0 : _b.isWaiting)) {
+                // Seek to new position
+                this.seekTo(Math.max(time, 0.0));
+            }
+        });
+    }
+    /**
+     * @hidden
+     * Called by MediaSession to verify the coordinator has been initialized.
+     */
+    get isInitialized() {
+        return this._hasInitialized;
+    }
+    /**
+     * @hidden
+     * Called by MediaSession to start coordinator.
+     */
+    initialize(acceptTransportChangesFrom) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._hasInitialized) {
+                throw new Error(`LiveMediaSessionCoordinator.initialize() already initialized.`);
+            }
+            // Create children
+            yield this.createChildren(acceptTransportChangesFrom);
+            this._hasInitialized = true;
+        });
+    }
+    /**
+     * @hidden
+     * Called by the MediaSession to detect if a wait point has been hit.
+     */
+    findNextWaitPoint() {
+        var _a;
+        return (((_a = this._groupState) === null || _a === void 0 ? void 0 : _a.playbackTrack.findNextWaitPoint(this._lastWaitPoint)) || null);
+    }
+    /**
+     * @hidden
+     * Called by MediaSession to trigger the sending of a position update.
+     */
+    sendPositionUpdate(state) {
+        if (!this._hasInitialized) {
+            throw new Error(`LiveMediaSessionCoordinator.sendPositionUpdate() called before initialize() called.`);
+        }
+        // Send position update event
+        this.verifyLocalUserRoles()
+            .then((valid) => {
+            var _a, _b;
+            const evt = this._groupState.createPositionUpdateEvent(state);
+            if (!valid) {
+                // We still need to update _groupState with the local user's position.
+                // So we do this here rather than on the receiving end.
+                this._groupState.handlePositionUpdate({
+                    clientId: (_a = this._runtime.clientId) !== null && _a !== void 0 ? _a : "",
+                    timestamp: this._liveRuntime.getTimestamp(),
+                    data: evt,
+                }, true);
+                return;
+            }
+            return (_b = this._positionUpdateEvent) === null || _b === void 0 ? void 0 : _b.sendEvent(evt);
+        })
+            .catch((err) => {
+            this._logger.sendErrorEvent(internals_1.TelemetryEvents.SessionCoordinator.PositionUpdateEventError, err);
+        });
+    }
+    createChildren(acceptTransportChangesFrom) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._allowedRoles = acceptTransportChangesFrom;
+            // Create event scopes
+            const scope = new live_share_1.LiveEventScope(this._runtime, this._liveRuntime, acceptTransportChangesFrom);
+            const unrestrictedScope = new live_share_1.LiveEventScope(this._runtime, this._liveRuntime);
+            // Initialize internal coordinator state
+            this._groupState = new internals_1.GroupCoordinatorState(this._runtime, this._liveRuntime, this._maxPlaybackDrift, this._positionUpdateInterval, this._getPlayerState);
+            this._groupState.on(internals_1.GroupCoordinatorStateEvents.triggeraction, (evt) => this.emit(evt.name, evt));
+            // Listen for track changes
+            this._setTrackEvent = new live_share_1.LiveEventTarget(scope, "setTrack", (event, local) => this._groupState.handleSetTrack(event, local));
+            this._setTrackDataEvent = new live_share_1.LiveEventTarget(scope, "setTrackData", (event, local) => this._groupState.handleSetTrackData(event, local));
+            // Listen for transport commands
+            this._playEvent = new live_share_1.LiveEventTarget(scope, "play", (event, local) => this._groupState.handleTransportCommand(event, local));
+            this._pauseEvent = new live_share_1.LiveEventTarget(scope, "pause", (event, local) => this._groupState.handleTransportCommand(event, local));
+            this._seekToEvent = new live_share_1.LiveEventTarget(scope, "seekTo", (event, local) => this._groupState.handleTransportCommand(event, local));
+            // Listen for position updates
+            this._positionUpdateEvent = new live_share_1.LiveEventTarget(unrestrictedScope, "positionUpdate", (event, local) => this._groupState.handlePositionUpdate(event, local));
+            // Listen for joined event
+            this._joinedEvent = new live_share_1.LiveEventTarget(unrestrictedScope, "joined", (evt, local) => {
+                // Immediately send a position update
+                this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.SessionCoordinator.RemoteJoinReceived, null, {
+                    correlationId: live_share_1.LiveTelemetryLogger.formatCorrelationId(evt.clientId, evt.timestamp),
+                });
+                const state = this._getPlayerState();
+                this.sendPositionUpdate(state);
+            });
+            this.verifyLocalUserRoles()
+                .then((verified) => {
+                var _a;
+                if (!verified)
+                    return;
+                // Send initial joined event
+                return (_a = this._joinedEvent) === null || _a === void 0 ? void 0 : _a.sendEvent(undefined);
+            })
+                .catch((err) => {
+                this._logger.sendErrorEvent(internals_1.TelemetryEvents.SessionCoordinator.SendJoinedEventError, err);
+            });
+        });
+    }
+    getPlayerPosition() {
+        const { positionState, playbackState } = this._getPlayerState();
+        switch (playbackState) {
+            case "none":
+            case "ended":
+                return 0.0;
+            default:
+                return positionState && positionState.position != undefined
+                    ? positionState.position
+                    : 0.0;
+        }
+    }
+    verifyLocalUserRoles() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const clientId = yield this.waitUntilConnected();
+            return this._liveRuntime.verifyRolesAllowed(clientId, (_a = this._allowedRoles) !== null && _a !== void 0 ? _a : []);
+        });
+    }
+    waitUntilConnected() {
+        return new Promise((resolve) => {
+            const onConnected = (clientId) => {
+                this._runtime.off("connected", onConnected);
+                resolve(clientId);
+            };
+            if (this._runtime.clientId && this._runtime.connected) {
+                resolve(this._runtime.clientId);
+            }
+            else {
+                this._runtime.on("connected", onConnected);
+            }
+        });
+    }
+}
+exports.LiveMediaSessionCoordinator = LiveMediaSessionCoordinator;
 //# sourceMappingURL=LiveMediaSessionCoordinator.js.map