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

package/bin/MediaPlayerSynchronizer.js

@@ -1,469 +1,504 @@
-"use strict";
-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.MediaPlayerSynchronizer = exports.MediaPlayerSynchronizerEvents = void 0;
-const events_1 = __importDefault(require("events"));
-const MediaSessionExtensions_1 = require("./MediaSessionExtensions");
-const VolumeManager_1 = require("./VolumeManager");
-const internals_1 = require("./internals");
-/**
- * Events supported by `MediaPlayerSynchronizer` object.
- */
-var MediaPlayerSynchronizerEvents;
-(function (MediaPlayerSynchronizerEvents) {
-    /**
-     *
-     */
-    MediaPlayerSynchronizerEvents["coordinatorstatechange"] = "coordinatorstatechange";
-    MediaPlayerSynchronizerEvents["groupaction"] = "groupaction";
-    MediaPlayerSynchronizerEvents["useraction"] = "useraction";
-})(MediaPlayerSynchronizerEvents = exports.MediaPlayerSynchronizerEvents || (exports.MediaPlayerSynchronizerEvents = {}));
-/**
- * Synchronizes a local HTML Media Element with a group of remote HTML Media Elements.
- *
- * @remarks
- * All of an apps transport control commands should be routed through the synchronizer. If the
- * app is not currently joined to the group media session, the commands will be applied directly
- * to the local player. When the group session is joined the commands will be broadcast to the
- * group in addition to being applied to the local player.
- */
-class MediaPlayerSynchronizer extends events_1.default {
-    /**
-     * Creates a new `MediaElementSynchronizer` instance.
-     * @param player Media player element. This can be an HTML Media Element or any player that looks like an HTML Media Element.
-     * @param mediaSession Group MediaSession object being used.
-     * @param onEnd Optional. Function to call when synchronizers `end()` method is called.
-     */
-    constructor(player, mediaSession, onEnd) {
-        super();
-        this._viewOnly = false;
-        this._expectedPlaybackState = "none";
-        this._trackData = null;
-        this._player = player;
-        this._mediaSession = mediaSession;
-        this._logger = mediaSession.logger;
-        this._volumeManager = new VolumeManager_1.VolumeManager(player);
-        this._onEnd = onEnd;
-        // Listen for player state requests
-        mediaSession.setRequestPlayerStateHandler(() => {
-            // Find playback state
-            let playbackState;
-            const src = this._player.currentSrc || this._player.src;
-            if (this._player.ended) {
-                playbackState = "ended";
-            }
-            else if (!src ||
-                (this._player.paused && this._player.currentTime < 1.0)) {
-                playbackState = "none";
-            }
-            else if (this._player.paused) {
-                playbackState = "paused";
-            }
-            else {
-                playbackState = "playing";
-            }
-            const state = {
-                metadata: { trackIdentifier: src },
-                playbackState: playbackState,
-                positionState: {
-                    position: this._player.currentTime,
-                    playbackRate: this._player.playbackRate,
-                    duration: this._player.duration,
-                },
-                trackData: this._trackData,
-            };
-            return state;
-        });
-        // Listen for player events
-        this._onPlayerEvent = (evt) => {
-            if (evt.type != "timeupdate") {
-                this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.MediaPlayerSynchronizer.PlayerEvent, null, {
-                    type: evt.type,
-                });
-            }
-            switch (evt.type) {
-                case "loadedmetadata":
-                    // eslint-disable-next-line no-case-declarations
-                    const src = this._player.currentSrc || this._player.src;
-                    this._trackData = null;
-                    break;
-                case "playing":
-                    // Handle case for YouTube player where user can pause/play video by clicking on it.
-                    // - Videos don't always start at 0.0 seconds.
-                    if (this._expectedPlaybackState != "playing") {
-                        if (this._mediaSession.coordinator.canPlayPause &&
-                            this._player.currentTime < 1.0) {
-                            this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.MediaPlayerSynchronizer
-                                .UserTappedVideoToPlay);
-                            this.play();
-                        }
-                    }
-                    // block play if player state is playing when expected synced state is paused and coordinator is not suspended.
-                    // needed because cannot tell if its a user initiated event, so disallow play
-                    if (this._expectedPlaybackState === "paused" &&
-                        !this._mediaSession.coordinator.isSuspended) {
-                        this._player.pause();
-                    }
-                    // block play if player state is playing when expected synced state is none and coordinator is not suspended.
-                    // needed because user who is not in control should not be able to start, so disallow play
-                    if (this._expectedPlaybackState === "none" &&
-                        !this._mediaSession.coordinator.isSuspended) {
-                        this._player.pause();
-                    }
-                    break;
-                case "pause":
-                    // block pause if player state is paused when expected synced state is playing and coordinator is not suspended.
-                    // needed because cannot tell if its a user initiated event, so disallow pause
-                    if (this._expectedPlaybackState === "playing" &&
-                        !this._mediaSession.coordinator.isSuspended) {
-                        this._player.play();
-                    }
-                    break;
-                case "ratechange":
-                    // Block rate changes unless suspended.
-                    if (this._player.playbackRate != 1.0 &&
-                        !this._mediaSession.coordinator.isSuspended) {
-                        this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.MediaPlayerSynchronizer
-                            .PlaybackRateChangeBlocked);
-                        this._player.playbackRate = 1.0;
-                    }
-                    break;
-                case "blocked":
-                    this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.MediaPlayerSynchronizer
-                        .PlaybackRateChangeBlocked);
-                    break;
-            }
-        };
-        // Register for coordinator state changes
-        this._mediaSession.coordinator.on(MediaSessionExtensions_1.MediaSessionCoordinatorEvents.coordinatorstatechange, (evt) => this.emit(evt.type, evt));
-        // Register media session actions
-        for (const action of MediaPlayerSynchronizer.SESSION_ACTIONS) {
-            this._mediaSession.setActionHandler(action, (details) => __awaiter(this, void 0, void 0, function* () {
-                var _a;
-                let error;
-                try {
-                    switch (details.action) {
-                        case "play":
-                            this._expectedPlaybackState = "playing";
-                            if (this._player.paused) {
-                                this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.MediaPlayerSynchronizer
-                                    .PlayAction);
-                                if (typeof details.seekTime == "number" &&
-                                    this._player.currentTime < 1.0) {
-                                    this._logger.sendTelemetryEvent(internals_1.TelemetryEvents
-                                        .MediaPlayerSynchronizer
-                                        .SeekingPlayerToStartPosition, null, { position: details.seekTime });
-                                    this._player.currentTime =
-                                        details.seekTime;
-                                }
-                                // Reference: https://developer.mozilla.org/docs/Web/API/HTMLMediaElement/play#exceptions
-                                yield this._player.play();
-                            }
-                            break;
-                        case "pause":
-                            this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.MediaPlayerSynchronizer
-                                .PauseAction);
-                            this._expectedPlaybackState = "paused";
-                            if (typeof details.seekTime == "number" &&
-                                this._player.currentTime < 1.0) {
-                                this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.MediaPlayerSynchronizer
-                                    .SeekingPlayerToStartPosition, null, { position: details.seekTime });
-                                this._player.currentTime =
-                                    details.seekTime;
-                            }
-                            this._player.pause();
-                            break;
-                        case "seekto":
-                            if (typeof details.seekTime == "number") {
-                                this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.MediaPlayerSynchronizer
-                                    .SeekToAction, null, { position: details.seekTime });
-                                this._player.currentTime =
-                                    details.seekTime;
-                            }
-                            break;
-                        case "settrack":
-                            this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.MediaPlayerSynchronizer
-                                .SetTrackAction);
-                            this._expectedPlaybackState = "none";
-                            this._player.src =
-                                details.metadata.trackIdentifier;
-                            this._player.load();
-                            break;
-                        case "datachange":
-                            this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.MediaPlayerSynchronizer
-                                .DataChangeAction);
-                            break;
-                        case "catchup":
-                            if (typeof details.seekTime == "number") {
-                                this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.MediaPlayerSynchronizer
-                                    .CatchupAction, null, { position: details.seekTime });
-                                this.catchupPlayer(details.seekTime);
-                            }
-                            break;
-                    }
-                }
-                catch (err) {
-                    if (err instanceof Error) {
-                        error = err;
-                    }
-                    else {
-                        error = new Error((_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : "An unknown error occurred after processing the group session action.");
-                    }
-                }
-                this.dispatchGroupAction(details, false, error);
-            }));
-        }
-        // Subscribe to player events
-        for (const event of MediaPlayerSynchronizer.PLAYER_EVENTS) {
-            this._player.addEventListener(event, this._onPlayerEvent);
-        }
-        this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.MediaPlayerSynchronizer.SynchronizationStarted);
-    }
-    /**
-     * Media player being synchronized.
-     */
-    get player() {
-        return this._player;
-    }
-    /**
-     * Synchronizers media session.
-     */
-    get mediaSession() {
-        return this._mediaSession;
-    }
-    /**
-     * If true the client is in a view only mode.
-     *
-     * @remarks
-     * Toggling this value to true results in `mediaSession.coordinator.canPlayPause`,
-     * `mediaSession.coordinator.canSeek`, `mediaSession.coordinator.canSetTrack`, and
-     * `mediaSession.coordinator.canSetTrackData` all being set to false.  For more fine
-     * grained control over the local clients policies, call the `mediaSession.coordinator`
-     * directly.
-     */
-    get viewOnly() {
-        return this._viewOnly;
-    }
-    set viewOnly(value) {
-        this._viewOnly = value;
-        this.mediaSession.coordinator.canPlayPause = !value;
-        this.mediaSession.coordinator.canSeek = !value;
-        this.mediaSession.coordinator.canSetTrack = !value;
-        this.mediaSession.coordinator.canSetTrackData = !value;
-    }
-    /**
-     * Volume limiter used to temporarily reduce the videos volume when someone speaks in a meeting.
-     */
-    get volumeManager() {
-        return this._volumeManager;
-    }
-    /**
-     * Registers a new event listener.
-     * @param event Name of the event to add.
-     * @param listener Function to call when the event is triggered.
-     */
-    addEventListener(event, listener) {
-        this.on(event, listener);
-        return this;
-    }
-    /**
-     * Un-registers an existing event listener.
-     * @param event Name of the event to remove.
-     * @param listener Function that was registered in call to `addEventListener()`.
-     */
-    removeEventListener(event, listener) {
-        this.off(event, listener);
-        return this;
-    }
-    /**
-     * Ends synchronization of the current media player.
-     */
-    end() {
-        if (this._onEnd) {
-            try {
-                // Clear media session actions
-                for (const action of MediaPlayerSynchronizer.SESSION_ACTIONS) {
-                    this._mediaSession.setActionHandler(action, null);
-                }
-                // Subscribe to player events
-                for (const event of MediaPlayerSynchronizer.PLAYER_EVENTS) {
-                    this._player.removeEventListener(event, this._onPlayerEvent);
-                }
-                // Notify parent
-                this._onEnd();
-            }
-            finally {
-                this._onEnd = undefined;
-            }
-        }
-    }
-    /**
-     * Begin a local seek operation.
-     *
-     * @remarks
-     * UI can call this when a user grabs a timeline scrubber and starts scrubbing the video to a
-     * new playback position. The synchronizer will being a new suspension which temporarily
-     * disconnects the client for the rest of the group for synchronization purposes. Calling
-     * `endSeek()` will end the suspension and seek the group to the users final seek position.
-     */
-    beginSeek() {
-        if (this._seekSuspension) {
-            throw new Error(`MediaPlayerSynchronizer: cannot begin seek. A seek is already in progress.`);
-        }
-        this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.MediaPlayerSynchronizer.BeginSeekCalled);
-        this._seekSuspension = this._mediaSession.coordinator.beginSuspension();
-    }
-    /**
-     * Ends a seek operation that was started by calling `beginSeek()`.
-     * @param seekTo Playback position in seconds to seek the group to.
-     */
-    endSeek(seekTo) {
-        if (!this._seekSuspension) {
-            throw new Error(`MediaPlayerSynchronizer: cannot end seek. No seek is in progress.`);
-        }
-        // Seek player to new time immediately.
-        // - This resolves an issue where the timeline scrubber can temporarily snap back to the original
-        //   location.
-        this._player.currentTime = seekTo;
-        const suspension = this._seekSuspension;
-        this._seekSuspension = undefined;
-        this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.MediaPlayerSynchronizer.EndSeekCalled, null, {
-            position: seekTo,
-        });
-        suspension.end(seekTo);
-        this.dispatchUserAction({ action: "seekto", seekTime: seekTo });
-    }
-    /**
-     * Tells the group to begin playing the current video.
-     *
-     * @remarks
-     * For proper operation apps should avoid calling `mediaSession.coordinator.play()` directly
-     * and instead use the synchronizers `play()` method.
-     */
-    play() {
-        this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.MediaPlayerSynchronizer.PlayCalled);
-        this._expectedPlaybackState = "playing";
-        this._mediaSession.coordinator.play();
-        this.dispatchUserAction({ action: "play" });
-    }
-    /**
-     * Tells the group to pause the current video.
-     *
-     * @remarks
-     * For proper operation apps should avoid calling `mediaSession.coordinator.pause()` directly
-     * and instead use the synchronizers `pause()` method.
-     */
-    pause() {
-        this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.MediaPlayerSynchronizer.PauseCalled);
-        this._expectedPlaybackState = "paused";
-        this._mediaSession.coordinator.pause();
-        this.dispatchUserAction({ action: "pause" });
-    }
-    /**
-     * Tells the group to seek the current video to a new playback position.
-     *
-     * @remarks
-     * For proper operation apps should avoid calling `mediaSession.coordinator.seekTo()` directly
-     * and instead use the synchronizers `seekTo()` method.
-     */
-    seekTo(time) {
-        // Always seek player to new time.
-        // - This resolves an issue where the timeline scrubber can temporarily snap back to the original
-        //   location.
-        this._player.currentTime = time;
-        this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.MediaPlayerSynchronizer.SeekToCalled, null, { position: time });
-        this._mediaSession.coordinator.seekTo(time);
-        this.dispatchUserAction({ action: "seekto", seekTime: time });
-    }
-    /**
-     * Tells the group to change to a new track.
-     *
-     * @remarks
-     * For proper operation apps should avoid calling `mediaSession.coordinator.setTrack()` directly
-     * and instead use the synchronizers `setTrack()` method.
-     */
-    setTrack(track, waitPoints) {
-        this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.MediaPlayerSynchronizer.SetTrackCalled);
-        this._mediaSession.coordinator.setTrack(track, waitPoints);
-        this.dispatchUserAction({ action: "settrack", metadata: track });
-    }
-    /**
-     * Updates the current tracks data object.
-     *
-     * @remarks
-     * For proper operation apps should avoid calling `mediaSession.coordinator.setTrackData()` directly
-     * and instead use the synchronizers `setTrackData()` method.
-     */
-    setTrackData(data) {
-        this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.MediaPlayerSynchronizer.SetTrackDataCalled);
-        this._trackData = data;
-        this._mediaSession.coordinator.setTrackData(data);
-        this.dispatchUserAction({ action: "datachange", data: data });
-    }
-    dispatchGroupAction(details, delay = false, error) {
-        if (delay) {
-            setTimeout(() => this.emit(MediaPlayerSynchronizerEvents.groupaction, {
-                type: MediaPlayerSynchronizerEvents.groupaction,
-                details: details,
-                playerError: error,
-            }), 50);
-        }
-        else {
-            this.emit(MediaPlayerSynchronizerEvents.groupaction, {
-                type: MediaPlayerSynchronizerEvents.groupaction,
-                details: details,
-                error,
-            });
-        }
-    }
-    dispatchUserAction(details, delay = false) {
-        if (delay) {
-            setTimeout(() => this.emit(MediaPlayerSynchronizerEvents.useraction, {
-                type: MediaPlayerSynchronizerEvents.useraction,
-                details: details,
-            }), 50);
-        }
-        else {
-            this.emit(MediaPlayerSynchronizerEvents.useraction, {
-                type: MediaPlayerSynchronizerEvents.useraction,
-                details: details,
-            });
-        }
-    }
-    catchupPlayer(time) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this._player.currentTime = time;
-        });
-    }
-}
-exports.MediaPlayerSynchronizer = MediaPlayerSynchronizer;
-MediaPlayerSynchronizer.SESSION_ACTIONS = [
-    "play",
-    "pause",
-    "seekto",
-    "settrack",
-    "datachange",
-    "catchup",
-    "wait",
-];
-MediaPlayerSynchronizer.PLAYER_EVENTS = [
-    "playing",
-    "pause",
-    "ratechange",
-    "timeupdate",
-    "ended",
-    "loadedmetadata",
-    "blocked",
-];
+"use strict";
+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.MediaPlayerSynchronizer = exports.MediaPlayerSynchronizerEvents = void 0;
+const events_1 = __importDefault(require("events"));
+const MediaSessionExtensions_1 = require("./MediaSessionExtensions");
+const VolumeManager_1 = require("./VolumeManager");
+const internals_1 = require("./internals");
+/**
+ * Events supported by `MediaPlayerSynchronizer` object.
+ */
+var MediaPlayerSynchronizerEvents;
+(function (MediaPlayerSynchronizerEvents) {
+    /**
+     *
+     */
+    MediaPlayerSynchronizerEvents["coordinatorstatechange"] = "coordinatorstatechange";
+    MediaPlayerSynchronizerEvents["groupaction"] = "groupaction";
+    MediaPlayerSynchronizerEvents["useraction"] = "useraction";
+})(MediaPlayerSynchronizerEvents = exports.MediaPlayerSynchronizerEvents || (exports.MediaPlayerSynchronizerEvents = {}));
+/**
+ * Synchronizes a local HTML Media Element with a group of remote HTML Media Elements.
+ *
+ * @remarks
+ * All of an apps transport control commands should be routed through the synchronizer. If the
+ * app is not currently joined to the group media session, the commands will be applied directly
+ * to the local player. When the group session is joined the commands will be broadcast to the
+ * group in addition to being applied to the local player.
+ */
+class MediaPlayerSynchronizer extends events_1.default {
+    /**
+     * Creates a new `MediaElementSynchronizer` instance.
+     * @param player Media player element. This can be an HTML Media Element or any player that looks like an HTML Media Element.
+     * @param mediaSession Group MediaSession object being used.
+     * @param onEnd Optional. Function to call when synchronizers `end()` method is called.
+     */
+    constructor(player, mediaSession, onEnd) {
+        super();
+        this._viewOnly = false;
+        this._expectedPlaybackState = "none";
+        this._metadata = null;
+        this._trackData = null;
+        this._player = player;
+        this._mediaSession = mediaSession;
+        this._logger = mediaSession.logger;
+        this._volumeManager = new VolumeManager_1.VolumeManager(player);
+        this._onEnd = onEnd;
+        // Listen for player state requests
+        mediaSession.setRequestPlayerStateHandler(() => {
+            // Find playback state
+            let playbackState;
+            const src = this._player.currentSrc || this._player.src;
+            if (this._player.ended) {
+                playbackState = "ended";
+            }
+            else if (!src ||
+                (this._player.paused && this._player.currentTime < 1.0)) {
+                playbackState = "none";
+            }
+            else if (this._player.paused) {
+                playbackState = "paused";
+            }
+            else {
+                playbackState = "playing";
+            }
+            // Metadata equality check in `GroupPlaybackTrack` would return false if only providing src.
+            // Use full metadata if this._metadata has same src
+            const metadata = this._metadata && this._metadata.trackIdentifier === src
+                ? this._metadata
+                : { trackIdentifier: src };
+            const state = {
+                metadata: metadata,
+                playbackState: playbackState,
+                positionState: {
+                    position: this._player.currentTime,
+                    playbackRate: this._player.playbackRate,
+                    duration: this._player.duration,
+                },
+                trackData: this._trackData,
+            };
+            return state;
+        });
+        // Listen for player events
+        this._onPlayerEvent = (evt) => {
+            if (evt.type != "timeupdate") {
+                this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.MediaPlayerSynchronizer.PlayerEvent, null, {
+                    type: evt.type,
+                });
+            }
+            switch (evt.type) {
+                case "loadedmetadata":
+                    // eslint-disable-next-line no-case-declarations
+                    const src = this._player.currentSrc || this._player.src;
+                    this._trackData = null;
+                    break;
+                case "playing":
+                    // Handle case for YouTube player where user can pause/play video by clicking on it.
+                    // - Videos don't always start at 0.0 seconds.
+                    if (this._expectedPlaybackState != "playing") {
+                        if (this._mediaSession.coordinator.canPlayPause &&
+                            this._player.currentTime < 1.0) {
+                            this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.MediaPlayerSynchronizer
+                                .UserTappedVideoToPlay);
+                            this.play().catch((err) => {
+                                this._logger.sendErrorEvent(internals_1.TelemetryEvents.MediaPlayerSynchronizer
+                                    .UserTappedVideoToPlayError, err);
+                            });
+                        }
+                    }
+                    // block play if player state is playing when expected synced state is paused and coordinator is not suspended.
+                    // needed because cannot tell if its a user initiated event, so disallow play
+                    if (this._expectedPlaybackState === "paused" &&
+                        !this._mediaSession.coordinator.isSuspended) {
+                        this._player.pause();
+                    }
+                    // block play if player state is playing when expected synced state is none and coordinator is not suspended.
+                    // needed because user who is not in control should not be able to start, so disallow play
+                    if (this._expectedPlaybackState === "none" &&
+                        !this._mediaSession.coordinator.isSuspended) {
+                        this._player.pause();
+                    }
+                    break;
+                case "pause":
+                    // block pause if player state is paused when expected synced state is playing and coordinator is not suspended.
+                    // needed because cannot tell if its a user initiated event, so disallow pause
+                    if (this._expectedPlaybackState === "playing" &&
+                        !this._mediaSession.coordinator.isSuspended) {
+                        this._player.play();
+                    }
+                    break;
+                case "ratechange":
+                    // Block rate changes unless suspended.
+                    if (this._player.playbackRate != 1.0 &&
+                        !this._mediaSession.coordinator.isSuspended) {
+                        this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.MediaPlayerSynchronizer
+                            .PlaybackRateChangeBlocked);
+                        this._player.playbackRate = 1.0;
+                    }
+                    break;
+                case "blocked":
+                    this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.MediaPlayerSynchronizer
+                        .PlaybackRateChangeBlocked);
+                    break;
+            }
+        };
+        // Register for coordinator state changes
+        this._mediaSession.coordinator.on(MediaSessionExtensions_1.MediaSessionCoordinatorEvents.coordinatorstatechange, (evt) => this.emit(evt.type, evt));
+        // Register media session actions
+        for (const action of MediaPlayerSynchronizer.SESSION_ACTIONS) {
+            this._mediaSession.setActionHandler(action, (details) => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b, _c;
+                let error;
+                try {
+                    switch (details.action) {
+                        case "play":
+                            this._expectedPlaybackState = "playing";
+                            if (this._player.paused) {
+                                this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.MediaPlayerSynchronizer
+                                    .PlayAction);
+                                if (typeof details.seekTime == "number" &&
+                                    this._player.currentTime < 1.0) {
+                                    this._logger.sendTelemetryEvent(internals_1.TelemetryEvents
+                                        .MediaPlayerSynchronizer
+                                        .SeekingPlayerToStartPosition, null, { position: details.seekTime });
+                                    this._player.currentTime =
+                                        details.seekTime;
+                                }
+                                // Reference: https://developer.mozilla.org/docs/Web/API/HTMLMediaElement/play#exceptions
+                                yield this._player.play();
+                            }
+                            break;
+                        case "pause":
+                            this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.MediaPlayerSynchronizer
+                                .PauseAction);
+                            this._expectedPlaybackState = "paused";
+                            if (typeof details.seekTime == "number" &&
+                                this._player.currentTime < 1.0) {
+                                this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.MediaPlayerSynchronizer
+                                    .SeekingPlayerToStartPosition, null, { position: details.seekTime });
+                                this._player.currentTime =
+                                    details.seekTime;
+                            }
+                            this._player.pause();
+                            break;
+                        case "seekto":
+                            if (typeof details.seekTime == "number") {
+                                this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.MediaPlayerSynchronizer
+                                    .SeekToAction, null, { position: details.seekTime });
+                                this._player.currentTime =
+                                    details.seekTime;
+                            }
+                            break;
+                        case "settrack":
+                            this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.MediaPlayerSynchronizer
+                                .SetTrackAction);
+                            this._expectedPlaybackState = "none";
+                            this._metadata = (_a = details.metadata) !== null && _a !== void 0 ? _a : null;
+                            if (this._player.src ===
+                                ((_b = details.metadata) === null || _b === void 0 ? void 0 : _b.trackIdentifier)) {
+                                // Don't set duplicate src and load again.
+                                break;
+                            }
+                            this._player.src =
+                                details.metadata.trackIdentifier;
+                            this._player.load();
+                            break;
+                        case "datachange":
+                            this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.MediaPlayerSynchronizer
+                                .DataChangeAction);
+                            break;
+                        case "catchup":
+                            if (typeof details.seekTime == "number") {
+                                this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.MediaPlayerSynchronizer
+                                    .CatchupAction, null, { position: details.seekTime });
+                                this.catchupPlayer(details.seekTime);
+                            }
+                            break;
+                    }
+                }
+                catch (err) {
+                    if (err instanceof Error) {
+                        error = err;
+                    }
+                    else {
+                        error = new Error((_c = err === null || err === void 0 ? void 0 : err.message) !== null && _c !== void 0 ? _c : "An unknown error occurred after processing the group session action.");
+                    }
+                }
+                this.dispatchGroupAction(details, false, error);
+            }));
+        }
+        // Subscribe to player events
+        for (const event of MediaPlayerSynchronizer.PLAYER_EVENTS) {
+            this._player.addEventListener(event, this._onPlayerEvent);
+        }
+        this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.MediaPlayerSynchronizer.SynchronizationStarted);
+    }
+    /**
+     * Media player being synchronized.
+     */
+    get player() {
+        return this._player;
+    }
+    /**
+     * Synchronizers media session.
+     */
+    get mediaSession() {
+        return this._mediaSession;
+    }
+    /**
+     * If true the client is in a view only mode.
+     *
+     * @remarks
+     * Toggling this value to true results in `mediaSession.coordinator.canPlayPause`,
+     * `mediaSession.coordinator.canSeek`, `mediaSession.coordinator.canSetTrack`, and
+     * `mediaSession.coordinator.canSetTrackData` all being set to false.  For more fine
+     * grained control over the local clients policies, call the `mediaSession.coordinator`
+     * directly.
+     */
+    get viewOnly() {
+        return this._viewOnly;
+    }
+    set viewOnly(value) {
+        this._viewOnly = value;
+        this.mediaSession.coordinator.canPlayPause = !value;
+        this.mediaSession.coordinator.canSeek = !value;
+        this.mediaSession.coordinator.canSetTrack = !value;
+        this.mediaSession.coordinator.canSetTrackData = !value;
+    }
+    /**
+     * Volume limiter used to temporarily reduce the videos volume when someone speaks in a meeting.
+     */
+    get volumeManager() {
+        return this._volumeManager;
+    }
+    /**
+     * Registers a new event listener.
+     * @param event Name of the event to add.
+     * @param listener Function to call when the event is triggered.
+     */
+    addEventListener(event, listener) {
+        this.on(event, listener);
+        return this;
+    }
+    /**
+     * Un-registers an existing event listener.
+     * @param event Name of the event to remove.
+     * @param listener Function that was registered in call to `addEventListener()`.
+     */
+    removeEventListener(event, listener) {
+        this.off(event, listener);
+        return this;
+    }
+    /**
+     * Ends synchronization of the current media player.
+     */
+    end() {
+        if (this._onEnd) {
+            try {
+                // Clear media session actions
+                for (const action of MediaPlayerSynchronizer.SESSION_ACTIONS) {
+                    this._mediaSession.setActionHandler(action, null);
+                }
+                // Subscribe to player events
+                for (const event of MediaPlayerSynchronizer.PLAYER_EVENTS) {
+                    this._player.removeEventListener(event, this._onPlayerEvent);
+                }
+                // Notify parent
+                this._onEnd();
+            }
+            finally {
+                this._onEnd = undefined;
+            }
+        }
+    }
+    /**
+     * Begin a local seek operation.
+     *
+     * @remarks
+     * UI can call this when a user grabs a timeline scrubber and starts scrubbing the video to a
+     * new playback position. The synchronizer will being a new suspension which temporarily
+     * disconnects the client for the rest of the group for synchronization purposes. Calling
+     * `endSeek()` will end the suspension and seek the group to the users final seek position.
+     */
+    beginSeek() {
+        if (this._seekSuspension) {
+            throw new Error(`MediaPlayerSynchronizer: cannot begin seek. A seek is already in progress.`);
+        }
+        this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.MediaPlayerSynchronizer.BeginSeekCalled);
+        this._seekSuspension = this._mediaSession.coordinator.beginSuspension();
+    }
+    /**
+     * Ends a seek operation that was started by calling `beginSeek()`.
+     * @param seekTo Playback position in seconds to seek the group to.
+     */
+    endSeek(seekTo) {
+        if (!this._seekSuspension) {
+            throw new Error(`MediaPlayerSynchronizer: cannot end seek. No seek is in progress.`);
+        }
+        // Seek player to new time immediately.
+        // - This resolves an issue where the timeline scrubber can temporarily snap back to the original
+        //   location.
+        this._player.currentTime = seekTo;
+        const suspension = this._seekSuspension;
+        this._seekSuspension = undefined;
+        this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.MediaPlayerSynchronizer.EndSeekCalled, null, {
+            position: seekTo,
+        });
+        suspension.end(seekTo);
+        this.dispatchUserAction({ action: "seekto", seekTime: seekTo });
+    }
+    /**
+     * Tells the group to begin playing the current video.
+     *
+     * @remarks
+     * For proper operation apps should avoid calling `mediaSession.coordinator.play()` directly
+     * and instead use the synchronizers `play()` method.
+     *
+     * @returns a void promise that resolves once complete, throws if user does not have proper roles
+     */
+    play() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.MediaPlayerSynchronizer.PlayCalled);
+            this._expectedPlaybackState = "playing";
+            yield this._mediaSession.coordinator.play();
+            this.dispatchUserAction({ action: "play" });
+        });
+    }
+    /**
+     * Tells the group to pause the current video.
+     *
+     * @remarks
+     * For proper operation apps should avoid calling `mediaSession.coordinator.pause()` directly
+     * and instead use the synchronizers `pause()` method.
+     *
+     * @returns a void promise that resolves once complete, throws if user does not have proper roles
+     */
+    pause() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.MediaPlayerSynchronizer.PauseCalled);
+            this._expectedPlaybackState = "paused";
+            yield this._mediaSession.coordinator.pause();
+            this.dispatchUserAction({ action: "pause" });
+        });
+    }
+    /**
+     * Tells the group to seek the current video to a new playback position.
+     *
+     * @remarks
+     * For proper operation apps should avoid calling `mediaSession.coordinator.seekTo()` directly
+     * and instead use the synchronizers `seekTo()` method.
+     *
+     * @returns a void promise that resolves once complete, throws if user does not have proper roles
+     */
+    seekTo(time) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Always seek player to new time.
+            // - This resolves an issue where the timeline scrubber can temporarily snap back to the original
+            //   location.
+            this._player.currentTime = time;
+            this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.MediaPlayerSynchronizer.SeekToCalled, null, { position: time });
+            yield this._mediaSession.coordinator.seekTo(time);
+            this.dispatchUserAction({ action: "seekto", seekTime: time });
+        });
+    }
+    /**
+     * Tells the group to change to a new track.
+     *
+     * @remarks
+     * For proper operation apps should avoid calling `mediaSession.coordinator.setTrack()` directly
+     * and instead use the synchronizers `setTrack()` method.
+     *
+     * @returns a void promise that resolves once complete, throws if user does not have proper roles
+     */
+    setTrack(track, waitPoints) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.MediaPlayerSynchronizer.SetTrackCalled);
+            yield this._mediaSession.coordinator.setTrack(track, waitPoints);
+            this.dispatchUserAction({ action: "settrack", metadata: track });
+        });
+    }
+    /**
+     * Updates the current tracks data object.
+     *
+     * @remarks
+     * For proper operation apps should avoid calling `mediaSession.coordinator.setTrackData()` directly
+     * and instead use the synchronizers `setTrackData()` method.
+     *
+     * @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* () {
+            this._logger.sendTelemetryEvent(internals_1.TelemetryEvents.MediaPlayerSynchronizer.SetTrackDataCalled);
+            this._trackData = data;
+            yield this._mediaSession.coordinator.setTrackData(data);
+            this.dispatchUserAction({ action: "datachange", data: data });
+        });
+    }
+    dispatchGroupAction(details, delay = false, error) {
+        if (delay) {
+            setTimeout(() => this.emit(MediaPlayerSynchronizerEvents.groupaction, {
+                type: MediaPlayerSynchronizerEvents.groupaction,
+                details: details,
+                playerError: error,
+            }), 50);
+        }
+        else {
+            this.emit(MediaPlayerSynchronizerEvents.groupaction, {
+                type: MediaPlayerSynchronizerEvents.groupaction,
+                details: details,
+                error,
+            });
+        }
+    }
+    dispatchUserAction(details, delay = false) {
+        if (delay) {
+            setTimeout(() => this.emit(MediaPlayerSynchronizerEvents.useraction, {
+                type: MediaPlayerSynchronizerEvents.useraction,
+                details: details,
+            }), 50);
+        }
+        else {
+            this.emit(MediaPlayerSynchronizerEvents.useraction, {
+                type: MediaPlayerSynchronizerEvents.useraction,
+                details: details,
+            });
+        }
+    }
+    catchupPlayer(time) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._player.currentTime = time;
+        });
+    }
+}
+MediaPlayerSynchronizer.SESSION_ACTIONS = [
+    "play",
+    "pause",
+    "seekto",
+    "settrack",
+    "datachange",
+    "catchup",
+    "wait",
+];
+MediaPlayerSynchronizer.PLAYER_EVENTS = [
+    "playing",
+    "pause",
+    "ratechange",
+    "timeupdate",
+    "ended",
+    "loadedmetadata",
+    "blocked",
+];
+exports.MediaPlayerSynchronizer = MediaPlayerSynchronizer;
 //# sourceMappingURL=MediaPlayerSynchronizer.js.map