@microsoft/live-share-media 1.0.0-preview.8 → 1.0.0

package/bin/internals/GroupCoordinatorState.js

@@ -1,405 +1,408 @@
-"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.GroupCoordinatorState = exports.GroupCoordinatorStateEvents = void 0;
-const live_share_1 = require("@microsoft/live-share");
-const events_1 = __importDefault(require("events"));
-const GroupPlaybackTrack_1 = require("./GroupPlaybackTrack");
-const GroupTransportState_1 = require("./GroupTransportState");
-const GroupPlaybackPosition_1 = require("./GroupPlaybackPosition");
-const GroupTransportState_2 = require("./GroupTransportState");
-const GroupPlaybackTrackData_1 = require("./GroupPlaybackTrackData");
-const consts_1 = require("./consts");
-/**
- * @hidden
- */
-var GroupCoordinatorStateEvents;
-(function (GroupCoordinatorStateEvents) {
-    GroupCoordinatorStateEvents["newwaitpoint"] = "newwaitpoint";
-    GroupCoordinatorStateEvents["triggeraction"] = "triggeraction";
-})(GroupCoordinatorStateEvents = exports.GroupCoordinatorStateEvents || (exports.GroupCoordinatorStateEvents = {}));
-/**
- * @hidden
- */
-class GroupCoordinatorState extends events_1.default {
-    constructor(runtime, maxPlaybackDrift, positionUpdateInterval, getMediaPlayerState) {
-        super();
-        // Suspension tracking
-        this._suspensionCnt = 0;
-        // "Soft Suspension" tracking
-        // - Soft suspensions temporarily disconnect the local media session when transitioning between
-        //   paused, playing, and none states. This is to give the local client time to finish any inprogress
-        //   operations like sending a transport command or ending a suspension.
-        this._lastStateChange = "none";
-        this._lastStateChangeTime = 0;
-        this._runtime = runtime;
-        this._logger = new live_share_1.LiveTelemetryLogger(runtime);
-        this._maxPlaybackDrift = maxPlaybackDrift;
-        this._playbackTrack = new GroupPlaybackTrack_1.GroupPlaybackTrack(getMediaPlayerState);
-        this._playbackTrackData = new GroupPlaybackTrackData_1.GroupPlaybackTrackData(this._playbackTrack);
-        this._transportState = new GroupTransportState_1.GroupTransportState(this._playbackTrack, getMediaPlayerState);
-        this._playbackPosition = new GroupPlaybackPosition_1.GroupPlaybackPosition(this._transportState, this._runtime, positionUpdateInterval);
-        this._getMediaPlayerState = getMediaPlayerState;
-        // Listen track related events
-        this._playbackTrack.on(GroupPlaybackTrack_1.GroupPlaybackTrackEvents.trackChange, (evt) => {
-            if (!this.isSuspended) {
-                this._logger.sendTelemetryEvent(consts_1.TelemetryEvents.GroupCoordinator.TrackChanged);
-                this.emitSetTrack(evt.metadata);
-            }
-            else {
-                this._logger.sendTelemetryEvent(consts_1.TelemetryEvents.GroupCoordinator.TrackChangeDelayed);
-            }
-        });
-        // Listen for track data changes
-        this._playbackTrackData.on(GroupPlaybackTrackData_1.PlaybackTrackDataEvents.dataChange, (evt) => {
-            if (!this.isSuspended && !this.isWaiting) {
-                this._logger.sendTelemetryEvent(consts_1.TelemetryEvents.GroupCoordinator.TrackDataChanged);
-                this.emitTriggerAction({
-                    action: "datachange",
-                    data: evt.data,
-                });
-            }
-            else {
-                this._logger.sendTelemetryEvent(consts_1.TelemetryEvents.GroupCoordinator.TrackDataChangeDelayed);
-            }
-        });
-        // Listen to transport related events
-        this._transportState.on(GroupTransportState_2.GroupTransportStateEvents.transportStateChange, (evt) => {
-            if (!this.isSuspended && !this.isWaiting) {
-                this._logger.sendTelemetryEvent(consts_1.TelemetryEvents.GroupCoordinator.TransportStateChanged, null, {
-                    action: evt.action,
-                    seekTime: evt.seekTime,
-                });
-                // Trigger action
-                switch (evt.action) {
-                    case "play":
-                        this.emitTriggerAction({
-                            action: "play",
-                            seekTime: evt.seekTime,
-                        });
-                        break;
-                    case "pause":
-                        this.emitTriggerAction({
-                            action: "pause",
-                            seekTime: evt.seekTime,
-                        });
-                        break;
-                    case "seekto":
-                        this.emitTriggerAction({
-                            action: "seekto",
-                            seekTime: evt.seekTime,
-                        });
-                        break;
-                }
-            }
-            else {
-                this._logger.sendTelemetryEvent(consts_1.TelemetryEvents.GroupCoordinator
-                    .TransportStateChangeDelayed, null, {
-                    action: evt.action,
-                    seekTime: evt.seekTime,
-                });
-            }
-        });
-    }
-    get playbackTrack() {
-        return this._playbackTrack;
-    }
-    get playbackTrackData() {
-        return this._playbackTrackData;
-    }
-    get transportState() {
-        return this._transportState;
-    }
-    get playbackPosition() {
-        return this._playbackPosition;
-    }
-    get waitingAt() {
-        return this._waitPoint;
-    }
-    get isSuspended() {
-        return this._suspensionCnt > 0;
-    }
-    get isWaiting() {
-        return !!this._waitPoint;
-    }
-    beginSuspension(waitPoint) {
-        this._suspensionCnt++;
-        if (waitPoint) {
-            // Save most recent wait point
-            this._waitPoint = waitPoint;
-            // Add to track state if dynamic wait point
-            this.playbackTrack.addWaitPoint(waitPoint);
-        }
-    }
-    endSuspension(syncState) {
-        if (this._suspensionCnt == 0) {
-            throw new Error(`Too many suspensions.`);
-        }
-        this._suspensionCnt--;
-        if (this._suspensionCnt == 0 && syncState) {
-            // Sync media session to group
-            this.syncLocalMediaSession();
-        }
-    }
-    createPositionUpdateEvent(state) {
-        const { positionState, playbackState } = state;
-        if (this.isSuspended) {
-            // Report suspension state
-            return {
-                track: this.playbackTrack.current,
-                trackData: this.playbackTrackData.current,
-                transport: this.transportState.current,
-                playbackState: "suspended",
-                position: (positionState === null || positionState === void 0 ? void 0 : positionState.position) || 0.0,
-                waitPoint: this._waitPoint,
-            };
-        }
-        else {
-            // Report current position
-            return {
-                track: this.playbackTrack.current,
-                trackData: this.playbackTrackData.current,
-                transport: this.transportState.current,
-                playbackState: this._waitPoint ? "waiting" : playbackState,
-                position: (positionState === null || positionState === void 0 ? void 0 : positionState.position) || 0.0,
-                waitPoint: this._waitPoint,
-            };
-        }
-    }
-    handleSetTrack(event, local) {
-        // Update shared track
-        // - Will trigger 'trackChange' event to update media session
-        const updated = this.playbackTrack.updateTrack({
-            metadata: event.metadata,
-            waitPoints: event.waitPoints,
-            timestamp: event.timestamp,
-            clientId: event.clientId || "",
-        });
-        if (updated) {
-            this._logger.sendTelemetryEvent(consts_1.TelemetryEvents.SessionCoordinator.RemoteSetTrackReceived, null, {
-                correlationId: live_share_1.LiveTelemetryLogger.formatCorrelationId(event.clientId, event.timestamp),
-            });
-        }
-    }
-    handleSetTrackData(event, local) {
-        // Update shared track data
-        // - Will trigger 'dataChange' event to update media session
-        const updated = this.playbackTrackData.updateData({
-            data: event.data,
-            timestamp: event.timestamp,
-            clientId: event.clientId || "",
-        });
-        if (updated) {
-            this._logger.sendTelemetryEvent(consts_1.TelemetryEvents.SessionCoordinator.RemoteSetTrackReceived, null, {
-                correlationId: live_share_1.LiveTelemetryLogger.formatCorrelationId(event.clientId, event.timestamp),
-            });
-        }
-    }
-    handleTransportCommand(event, local) {
-        // Ensure change is for current track
-        // - Will trigger a 'trackChange' event if newer track.
-        this.playbackTrack.updateTrack(event.track);
-        if (this.playbackTrack.compare(event.track.metadata)) {
-            // Update playback state
-            let playbackState = this.transportState.playbackState;
-            switch (event.name) {
-                case "play":
-                    playbackState = "playing";
-                    break;
-                case "pause":
-                    playbackState = "paused";
-                    break;
-            }
-            // Try to update playback state
-            const newState = {
-                playbackState: playbackState,
-                startPosition: event.position,
-                timestamp: event.timestamp,
-                clientId: event.clientId || "",
-            };
-            const updated = this.transportState.updateState(newState);
-            if (updated) {
-                const correlationId = live_share_1.LiveTelemetryLogger.formatCorrelationId(event.clientId, event.timestamp);
-                switch (event.name) {
-                    case "play":
-                        this._logger.sendTelemetryEvent(consts_1.TelemetryEvents.SessionCoordinator
-                            .RemotePlayReceived, null, {
-                            correlationId: correlationId,
-                        });
-                        break;
-                    case "pause":
-                        this._logger.sendTelemetryEvent(consts_1.TelemetryEvents.SessionCoordinator
-                            .RemotePauseReceived, null, {
-                            correlationId: correlationId,
-                        });
-                        break;
-                    case "seekTo":
-                        this._logger.sendTelemetryEvent(consts_1.TelemetryEvents.SessionCoordinator
-                            .RemoteSeekToReceived, null, {
-                            correlationId: correlationId,
-                        });
-                        break;
-                }
-            }
-        }
-    }
-    handlePositionUpdate(event, local) {
-        // Ensure change is for current track
-        // - Will trigger a 'trackChange' event if newer track.
-        this.playbackTrack.updateTrack(event.track);
-        if (this.playbackTrack.compare(event.track.metadata)) {
-            // Ensure we have the latest track data
-            this.playbackTrackData.updateData(event.trackData);
-            // Update transport state if needed
-            // - Ignore transport state changes if the client has ended as this will cause the local
-            //   player to start playback even though the video may have ended for everyone.
-            if (event.playbackState != "ended") {
-                this.transportState.updateState(event.transport);
-            }
-            // Ensure change is for current transport state
-            if (this.transportState.compare(event.transport)) {
-                // Update playback position
-                const position = {
-                    playbackState: event.playbackState,
-                    waitPoint: event.waitPoint,
-                    position: event.position,
-                    timestamp: event.timestamp,
-                    clientId: event.clientId || "",
-                };
-                this.playbackPosition.UpdatePlaybackPosition(position);
-                // Ensure local media session is in sync with group
-                if (local && !this.isSuspended) {
-                    // Begin a "soft suspension" on select state changes
-                    // - This is needed because the catchup logic can try to sink the client with
-                    //  the rest of the group while the local player is trying to to seek to a
-                    //  new position.
-                    switch (event.playbackState) {
-                        case "none":
-                        case "paused":
-                        case "playing":
-                            if (event.playbackState != this._lastStateChange) {
-                                this._logger.sendTelemetryEvent(consts_1.TelemetryEvents.GroupCoordinator
-                                    .BeginSoftSuspension, null, { playbackState: event.playbackState });
-                                this._lastStateChange = event.playbackState;
-                                this._lastStateChangeTime =
-                                    live_share_1.LiveEvent.getTimestamp();
-                            }
-                            break;
-                    }
-                    // Are we waiting?
-                    if (this.isWaiting) {
-                        // Check for end of waiting
-                        if (this.playbackPosition.clientsWaiting == 0) {
-                            this._waitPoint = undefined;
-                            // Start syncing again
-                            this.syncLocalMediaSession();
-                        }
-                    }
-                    else {
-                        // Sync client with group
-                        this.syncLocalMediaSession();
-                    }
-                }
-            }
-        }
-    }
-    syncLocalMediaSession() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Skip further syncs if we're waiting or in a "soft suspension".
-            const softSuspensionDelta = live_share_1.LiveEvent.getTimestamp() - this._lastStateChangeTime;
-            if (!this.isWaiting && softSuspensionDelta >= 1000) {
-                let { metadata, trackData, positionState, playbackState } = this._getMediaPlayerState();
-                this._logger.sendTelemetryEvent(consts_1.TelemetryEvents.GroupCoordinator.CheckingForSyncIssues);
-                // Check for track change
-                if (!this.playbackTrack.compare(metadata)) {
-                    this._logger.sendTelemetryEvent(consts_1.TelemetryEvents.GroupCoordinator.TrackOutOfSync);
-                    this.emitSetTrack(this.playbackTrack.metadata);
-                    return;
-                }
-                // Once local playback has ended there's no need to further sync the client. In fact
-                // doing so could cause the player to loop.
-                // - The playbackPosition.trackEnded check is to catch late joiners and prevents syncing if everyone
-                //   else has finished the video.
-                // - Should another user seek or press play after the video has ended that will cause
-                //   a transport action to trigger which will take the player out of the ended state.
-                if (playbackState != "ended" &&
-                    !this._playbackPosition.trackEnded) {
-                    // Ensure we have a position
-                    let position = positionState === null || positionState === void 0 ? void 0 : positionState.position;
-                    if (position == undefined) {
-                        position = 0.0;
-                    }
-                    // Check for catchup
-                    // - Target can return -1 in cases where there is no position tracking data
-                    const target = this.playbackPosition.targetPosition;
-                    if (target >= 0.0 &&
-                        Math.abs(target - position) >=
-                            this._maxPlaybackDrift.seconds) {
-                        this._logger.sendTelemetryEvent(consts_1.TelemetryEvents.GroupCoordinator.PositionOutOfSync, null, {
-                            current: position,
-                            target: target,
-                        });
-                        yield this.emitTriggerAction({
-                            action: "catchup",
-                            seekTime: target,
-                        });
-                    }
-                    // Sync transport state
-                    if (this.transportState.playbackState != playbackState) {
-                        this._logger.sendTelemetryEvent(consts_1.TelemetryEvents.GroupCoordinator.TransportOutOfSync, null, {
-                            current: playbackState,
-                            target: this.transportState.playbackState,
-                        });
-                        switch (this.transportState.playbackState) {
-                            case "playing":
-                                yield this.emitTriggerAction({ action: "play" });
-                                break;
-                            case "paused":
-                                yield this.emitTriggerAction({ action: "pause" });
-                                break;
-                        }
-                    }
-                    // Sync track data
-                    if (JSON.stringify(this.playbackTrackData.data) !=
-                        JSON.stringify(trackData)) {
-                        this._logger.sendTelemetryEvent(consts_1.TelemetryEvents.GroupCoordinator.TrackDataOutOfSync);
-                        yield this.emitTriggerAction({
-                            action: "datachange",
-                            data: this.playbackTrackData.data,
-                        });
-                    }
-                }
-            }
-        });
-    }
-    emitSetTrack(metadata) {
-        // Reset tracking states
-        this._waitPoint = undefined;
-        // Trigger settrack action
-        this.emitTriggerAction({ action: "settrack", metadata: metadata });
-    }
-    emitTriggerAction(details) {
-        const evt = {
-            name: GroupCoordinatorStateEvents.triggeraction,
-            details: details,
-        };
-        this.emit(GroupCoordinatorStateEvents.triggeraction, evt);
-    }
-}
-exports.GroupCoordinatorState = GroupCoordinatorState;
+"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.GroupCoordinatorState = exports.GroupCoordinatorStateEvents = void 0;
+const live_share_1 = require("@microsoft/live-share");
+const events_1 = __importDefault(require("events"));
+const GroupPlaybackTrack_1 = require("./GroupPlaybackTrack");
+const GroupTransportState_1 = require("./GroupTransportState");
+const GroupPlaybackPosition_1 = require("./GroupPlaybackPosition");
+const GroupTransportState_2 = require("./GroupTransportState");
+const GroupPlaybackTrackData_1 = require("./GroupPlaybackTrackData");
+const consts_1 = require("./consts");
+/**
+ * @hidden
+ */
+var GroupCoordinatorStateEvents;
+(function (GroupCoordinatorStateEvents) {
+    GroupCoordinatorStateEvents["newwaitpoint"] = "newwaitpoint";
+    GroupCoordinatorStateEvents["triggeraction"] = "triggeraction";
+})(GroupCoordinatorStateEvents = exports.GroupCoordinatorStateEvents || (exports.GroupCoordinatorStateEvents = {}));
+/**
+ * @hidden
+ */
+class GroupCoordinatorState extends events_1.default {
+    constructor(runtime, liveRuntime, maxPlaybackDrift, positionUpdateInterval, getMediaPlayerState) {
+        super();
+        // Suspension tracking
+        this._suspensionCnt = 0;
+        // "Soft Suspension" tracking
+        // - Soft suspensions temporarily disconnect the local media session when transitioning between
+        //   paused, playing, and none states. This is to give the local client time to finish any inprogress
+        //   operations like sending a transport command or ending a suspension.
+        this._lastStateChange = "none";
+        this._lastStateChangeTime = 0;
+        this._runtime = runtime;
+        this._liveRuntime = liveRuntime;
+        this._logger = new live_share_1.LiveTelemetryLogger(runtime, liveRuntime);
+        this._maxPlaybackDrift = maxPlaybackDrift;
+        this._playbackTrack = new GroupPlaybackTrack_1.GroupPlaybackTrack(getMediaPlayerState);
+        this._playbackTrackData = new GroupPlaybackTrackData_1.GroupPlaybackTrackData(this._playbackTrack);
+        this._transportState = new GroupTransportState_1.GroupTransportState(this._playbackTrack, getMediaPlayerState, this._liveRuntime);
+        this._playbackPosition = new GroupPlaybackPosition_1.GroupPlaybackPosition(this._transportState, this._runtime, this._liveRuntime, positionUpdateInterval);
+        this._getMediaPlayerState = getMediaPlayerState;
+        // Listen track related events
+        this._playbackTrack.on(GroupPlaybackTrack_1.GroupPlaybackTrackEvents.trackChange, (evt) => {
+            if (!this.isSuspended) {
+                this._logger.sendTelemetryEvent(consts_1.TelemetryEvents.GroupCoordinator.TrackChanged);
+                this.emitSetTrack(evt.metadata);
+            }
+            else {
+                this._logger.sendTelemetryEvent(consts_1.TelemetryEvents.GroupCoordinator.TrackChangeDelayed);
+            }
+        });
+        // Listen for track data changes
+        this._playbackTrackData.on(GroupPlaybackTrackData_1.PlaybackTrackDataEvents.dataChange, (evt) => {
+            if (!this.isSuspended && !this.isWaiting) {
+                this._logger.sendTelemetryEvent(consts_1.TelemetryEvents.GroupCoordinator.TrackDataChanged);
+                this.emitTriggerAction({
+                    action: "datachange",
+                    data: evt.data,
+                });
+            }
+            else {
+                this._logger.sendTelemetryEvent(consts_1.TelemetryEvents.GroupCoordinator.TrackDataChangeDelayed);
+            }
+        });
+        // Listen to transport related events
+        this._transportState.on(GroupTransportState_2.GroupTransportStateEvents.transportStateChange, (evt) => {
+            if (!this.isSuspended && !this.isWaiting) {
+                this._logger.sendTelemetryEvent(consts_1.TelemetryEvents.GroupCoordinator.TransportStateChanged, null, {
+                    action: evt.action,
+                    seekTime: evt.seekTime,
+                });
+                // Trigger action
+                switch (evt.action) {
+                    case "play":
+                        this.emitTriggerAction({
+                            action: "play",
+                            seekTime: evt.seekTime,
+                        });
+                        break;
+                    case "pause":
+                        this.emitTriggerAction({
+                            action: "pause",
+                            seekTime: evt.seekTime,
+                        });
+                        break;
+                    case "seekto":
+                        this.emitTriggerAction({
+                            action: "seekto",
+                            seekTime: evt.seekTime,
+                        });
+                        break;
+                }
+            }
+            else {
+                this._logger.sendTelemetryEvent(consts_1.TelemetryEvents.GroupCoordinator
+                    .TransportStateChangeDelayed, null, {
+                    action: evt.action,
+                    seekTime: evt.seekTime,
+                });
+            }
+        });
+    }
+    get playbackTrack() {
+        return this._playbackTrack;
+    }
+    get playbackTrackData() {
+        return this._playbackTrackData;
+    }
+    get transportState() {
+        return this._transportState;
+    }
+    get playbackPosition() {
+        return this._playbackPosition;
+    }
+    get waitingAt() {
+        return this._waitPoint;
+    }
+    get isSuspended() {
+        return this._suspensionCnt > 0;
+    }
+    get isWaiting() {
+        return !!this._waitPoint;
+    }
+    beginSuspension(waitPoint) {
+        this._suspensionCnt++;
+        if (waitPoint) {
+            // Save most recent wait point
+            this._waitPoint = waitPoint;
+            // Add to track state if dynamic wait point
+            this.playbackTrack.addWaitPoint(waitPoint);
+        }
+    }
+    endSuspension(syncState) {
+        if (this._suspensionCnt == 0) {
+            throw new Error(`Too many suspensions.`);
+        }
+        this._suspensionCnt--;
+        if (this._suspensionCnt == 0 && syncState) {
+            // Sync media session to group
+            this.syncLocalMediaSession();
+        }
+    }
+    createPositionUpdateEvent(state) {
+        const { positionState, playbackState } = state;
+        if (this.isSuspended) {
+            // Report suspension state
+            return {
+                track: this.playbackTrack.current,
+                trackData: this.playbackTrackData.current,
+                transport: this.transportState.current,
+                playbackState: "suspended",
+                position: (positionState === null || positionState === void 0 ? void 0 : positionState.position) || 0.0,
+                waitPoint: this._waitPoint,
+            };
+        }
+        else {
+            // Report current position
+            return {
+                track: this.playbackTrack.current,
+                trackData: this.playbackTrackData.current,
+                transport: this.transportState.current,
+                playbackState: this._waitPoint ? "waiting" : playbackState,
+                position: (positionState === null || positionState === void 0 ? void 0 : positionState.position) || 0.0,
+                waitPoint: this._waitPoint,
+            };
+        }
+    }
+    handleSetTrack(event, local) {
+        // Update shared track
+        // - Will trigger 'trackChange' event to update media session
+        const updated = this.playbackTrack.updateTrack({
+            metadata: event.data.metadata,
+            waitPoints: event.data.waitPoints,
+            timestamp: event.timestamp,
+            clientId: event.clientId || "",
+        });
+        if (updated) {
+            this._logger.sendTelemetryEvent(consts_1.TelemetryEvents.SessionCoordinator.RemoteSetTrackReceived, null, {
+                correlationId: live_share_1.LiveTelemetryLogger.formatCorrelationId(event.clientId, event.timestamp),
+            });
+        }
+    }
+    handleSetTrackData(event, local) {
+        // Update shared track data
+        // - Will trigger 'dataChange' event to update media session
+        const updated = this.playbackTrackData.updateData({
+            data: event.data.data,
+            timestamp: event.timestamp,
+            clientId: event.clientId || "",
+        });
+        if (updated) {
+            this._logger.sendTelemetryEvent(consts_1.TelemetryEvents.SessionCoordinator.RemoteSetTrackReceived, null, {
+                correlationId: live_share_1.LiveTelemetryLogger.formatCorrelationId(event.clientId, event.timestamp),
+            });
+        }
+    }
+    handleTransportCommand(event, local) {
+        // Ensure change is for current track
+        // - Will trigger a 'trackChange' event if newer track.
+        this.playbackTrack.updateTrack(event.data.track);
+        if (this.playbackTrack.compare(event.data.track.metadata)) {
+            // Update playback state
+            let playbackState = this.transportState.playbackState;
+            switch (event.name) {
+                case "play":
+                    playbackState = "playing";
+                    break;
+                case "pause":
+                    playbackState = "paused";
+                    break;
+            }
+            // Try to update playback state
+            const newState = {
+                playbackState: playbackState,
+                startPosition: event.data.position,
+                timestamp: event.timestamp,
+                clientId: event.clientId || "",
+            };
+            const updated = this.transportState.updateState(newState);
+            if (updated) {
+                const correlationId = live_share_1.LiveTelemetryLogger.formatCorrelationId(event.clientId, event.timestamp);
+                switch (event.name) {
+                    case "play":
+                        this._logger.sendTelemetryEvent(consts_1.TelemetryEvents.SessionCoordinator
+                            .RemotePlayReceived, null, {
+                            correlationId: correlationId,
+                        });
+                        break;
+                    case "pause":
+                        this._logger.sendTelemetryEvent(consts_1.TelemetryEvents.SessionCoordinator
+                            .RemotePauseReceived, null, {
+                            correlationId: correlationId,
+                        });
+                        break;
+                    case "seekTo":
+                        this._logger.sendTelemetryEvent(consts_1.TelemetryEvents.SessionCoordinator
+                            .RemoteSeekToReceived, null, {
+                            correlationId: correlationId,
+                        });
+                        break;
+                }
+            }
+        }
+    }
+    handlePositionUpdate(event, local) {
+        // Ensure change is for current track
+        // - Will trigger a 'trackChange' event if newer track.
+        this.playbackTrack.updateTrack(event.data.track);
+        if (this.playbackTrack.compare(event.data.track.metadata)) {
+            // Ensure we have the latest track data
+            this.playbackTrackData.updateData(event.data.trackData);
+            // Update transport state if needed
+            // - Ignore transport state changes if the client has ended as this will cause the local
+            //   player to start playback even though the video may have ended for everyone.
+            if (event.data.playbackState != "ended") {
+                this.transportState.updateState(event.data.transport);
+            }
+            // Ensure change is for current transport state
+            if (this.transportState.compare(event.data.transport)) {
+                // Update playback position
+                const position = {
+                    playbackState: event.data.playbackState,
+                    waitPoint: event.data.waitPoint,
+                    position: event.data.position,
+                    timestamp: event.timestamp,
+                    clientId: event.clientId || "",
+                };
+                this.playbackPosition.UpdatePlaybackPosition(position);
+                // Ensure local media session is in sync with group
+                if (local && !this.isSuspended) {
+                    // Begin a "soft suspension" on select state changes
+                    // - This is needed because the catchup logic can try to sink the client with
+                    //  the rest of the group while the local player is trying to to seek to a
+                    //  new position.
+                    switch (event.data.playbackState) {
+                        case "none":
+                        case "paused":
+                        case "playing":
+                            if (event.data.playbackState !=
+                                this._lastStateChange) {
+                                this._logger.sendTelemetryEvent(consts_1.TelemetryEvents.GroupCoordinator
+                                    .BeginSoftSuspension, null, { playbackState: event.data.playbackState });
+                                this._lastStateChange =
+                                    event.data.playbackState;
+                                this._lastStateChangeTime =
+                                    this._liveRuntime.getTimestamp();
+                            }
+                            break;
+                    }
+                    // Are we waiting?
+                    if (this.isWaiting) {
+                        // Check for end of waiting
+                        if (this.playbackPosition.clientsWaiting == 0) {
+                            this._waitPoint = undefined;
+                            // Start syncing again
+                            this.syncLocalMediaSession();
+                        }
+                    }
+                    else {
+                        // Sync client with group
+                        this.syncLocalMediaSession();
+                    }
+                }
+            }
+        }
+    }
+    syncLocalMediaSession() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Skip further syncs if we're waiting or in a "soft suspension".
+            const softSuspensionDelta = this._liveRuntime.getTimestamp() - this._lastStateChangeTime;
+            if (!this.isWaiting && softSuspensionDelta >= 1000) {
+                let { metadata, trackData, positionState, playbackState } = this._getMediaPlayerState();
+                this._logger.sendTelemetryEvent(consts_1.TelemetryEvents.GroupCoordinator.CheckingForSyncIssues);
+                // Check for track change
+                if (!this.playbackTrack.compare(metadata)) {
+                    this._logger.sendTelemetryEvent(consts_1.TelemetryEvents.GroupCoordinator.TrackOutOfSync);
+                    this.emitSetTrack(this.playbackTrack.metadata);
+                    return;
+                }
+                // Once local playback has ended there's no need to further sync the client. In fact
+                // doing so could cause the player to loop.
+                // - The playbackPosition.trackEnded check is to catch late joiners and prevents syncing if everyone
+                //   else has finished the video.
+                // - Should another user seek or press play after the video has ended that will cause
+                //   a transport action to trigger which will take the player out of the ended state.
+                if (playbackState != "ended" &&
+                    !this._playbackPosition.trackEnded) {
+                    // Ensure we have a position
+                    let position = positionState === null || positionState === void 0 ? void 0 : positionState.position;
+                    if (position == undefined) {
+                        position = 0.0;
+                    }
+                    // Check for catchup
+                    // - Target can return -1 in cases where there is no position tracking data
+                    const target = this.playbackPosition.targetPosition;
+                    if (target >= 0.0 &&
+                        Math.abs(target - position) >=
+                            this._maxPlaybackDrift.seconds) {
+                        this._logger.sendTelemetryEvent(consts_1.TelemetryEvents.GroupCoordinator.PositionOutOfSync, null, {
+                            current: position,
+                            target: target,
+                        });
+                        yield this.emitTriggerAction({
+                            action: "catchup",
+                            seekTime: target,
+                        });
+                    }
+                    // Sync transport state
+                    if (this.transportState.playbackState != playbackState) {
+                        this._logger.sendTelemetryEvent(consts_1.TelemetryEvents.GroupCoordinator.TransportOutOfSync, null, {
+                            current: playbackState,
+                            target: this.transportState.playbackState,
+                        });
+                        switch (this.transportState.playbackState) {
+                            case "playing":
+                                yield this.emitTriggerAction({ action: "play" });
+                                break;
+                            case "paused":
+                                yield this.emitTriggerAction({ action: "pause" });
+                                break;
+                        }
+                    }
+                    // Sync track data
+                    if (JSON.stringify(this.playbackTrackData.data) !=
+                        JSON.stringify(trackData)) {
+                        this._logger.sendTelemetryEvent(consts_1.TelemetryEvents.GroupCoordinator.TrackDataOutOfSync);
+                        yield this.emitTriggerAction({
+                            action: "datachange",
+                            data: this.playbackTrackData.data,
+                        });
+                    }
+                }
+            }
+        });
+    }
+    emitSetTrack(metadata) {
+        // Reset tracking states
+        this._waitPoint = undefined;
+        // Trigger settrack action
+        this.emitTriggerAction({ action: "settrack", metadata: metadata });
+    }
+    emitTriggerAction(details) {
+        const evt = {
+            name: GroupCoordinatorStateEvents.triggeraction,
+            details: details,
+        };
+        this.emit(GroupCoordinatorStateEvents.triggeraction, evt);
+    }
+}
+exports.GroupCoordinatorState = GroupCoordinatorState;
 //# sourceMappingURL=GroupCoordinatorState.js.map