@microsoft/live-share-media 1.3.0 → 1.4.0

package/src/internals/GroupPlaybackTrack.ts

@@ -1,182 +1,183 @@
-/**
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the Microsoft Live Share SDK License.
- */
-
-import { ILiveEvent } from "@microsoft/live-share";
-import EventEmitter from "events";
-import { IMediaPlayerState } from "../LiveMediaSessionCoordinator";
-import {
-    CoordinationWaitPoint,
-    ExtendedMediaMetadata,
-    ExtendedMediaSessionActionSource,
-} from "../MediaSessionExtensions";
-
-/**
- * @hidden
- */
-export interface IPlaybackTrack {
-    metadata: ExtendedMediaMetadata | null;
-    waitPoints: CoordinationWaitPoint[];
-    timestamp: number;
-    clientId: string;
-}
-
-/**
- * @hidden
- */
-export enum GroupPlaybackTrackEvents {
-    trackChange = "trackChange",
-}
-
-/**
- * @hidden
- */
-export interface IPlaybackTrackChangeEvent extends ILiveEvent {
-    metadata: ExtendedMediaMetadata | null;
-}
-
-/**
- * @hidden
- */
-export class GroupPlaybackTrack extends EventEmitter {
-    private readonly _getMediaPlayerState: () => IMediaPlayerState;
-    private _current: IPlaybackTrack;
-
-    constructor(getMediaPlayerState: () => IMediaPlayerState) {
-        super();
-        this._current = {
-            metadata: null,
-            waitPoints: [],
-            timestamp: 0,
-            clientId: "",
-        };
-        this._getMediaPlayerState = getMediaPlayerState;
-    }
-
-    public get current(): Readonly<IPlaybackTrack> {
-        // Populate with sessions current metadata if null
-        if (!this._current.metadata) {
-            this._current.metadata = this._getMediaPlayerState().metadata;
-        }
-
-        return this._current;
-    }
-
-    public get metadata(): ExtendedMediaMetadata | null {
-        return this.current.metadata;
-    }
-
-    public addWaitPoint(waitPoint: CoordinationWaitPoint): boolean {
-        for (let i = 0; i < this._current.waitPoints.length; i++) {
-            const current = this._current.waitPoints[i];
-            if (current.position == waitPoint.position) {
-                // Already exists
-                return false;
-            } else if (current.position > waitPoint.position) {
-                // Insert before current position
-                this._current.waitPoints.splice(i, 0, waitPoint);
-                return true;
-            }
-        }
-
-        // Append to list
-        this._current.waitPoints.push(waitPoint);
-        return true;
-    }
-
-    public findNextWaitPoint(
-        lastWaitPoint: CoordinationWaitPoint | undefined
-    ): CoordinationWaitPoint | undefined {
-        const waitPoints = this._current.waitPoints || [];
-        for (const waitPoint of waitPoints) {
-            if (lastWaitPoint && waitPoint.position <= lastWaitPoint.position) {
-                continue;
-            }
-
-            return waitPoint;
-        }
-
-        return undefined;
-    }
-
-    public updateTrack(
-        track: IPlaybackTrack,
-        source: ExtendedMediaSessionActionSource
-    ): boolean {
-        // Guard against missing waitPoints collection
-        if (!Array.isArray(track.waitPoints)) {
-            track.waitPoints = [];
-        }
-
-        // Is this the same track?
-        const current = this.current;
-        if (
-            GroupPlaybackTrack.compareMetadata(
-                this.current.metadata,
-                track.metadata
-            )
-        ) {
-            // Add any dynamic wait points.
-            track.waitPoints.forEach((waitPoint) => {
-                this.addWaitPoint(waitPoint);
-            });
-
-            // Ignore if same playback state
-            if (
-                track.timestamp == current.timestamp &&
-                track.clientId == current.clientId
-            ) {
-                return false;
-            }
-        }
-
-        // Ignore state changes that are older
-        if (track.timestamp < current.timestamp) {
-            return false;
-        }
-
-        // Ignore state changes that are from a clientId that sorts higher then the current one.
-        // - current.clientId should not be empty if current.timestamp != 0
-        if (
-            track.timestamp == current.timestamp &&
-            track.clientId.localeCompare(current.clientId) > 0
-        ) {
-            return false;
-        }
-
-        // Update current track
-        this._current = track;
-
-        // Notify listeners
-        this.emit(GroupPlaybackTrackEvents.trackChange, {
-            name: GroupPlaybackTrackEvents.trackChange,
-            clientId: track.clientId,
-            metadata: track.metadata,
-            source,
-        });
-
-        return true;
-    }
-
-    public compare(metadata: ExtendedMediaMetadata | null): boolean {
-        return GroupPlaybackTrack.compareMetadata(
-            this.current.metadata,
-            metadata
-        );
-    }
-
-    public static compareMetadata(
-        current: ExtendedMediaMetadata | null,
-        metadata: ExtendedMediaMetadata | null
-    ): boolean {
-        // Only compare when we have two metadata instances
-        if (current && metadata) {
-            return JSON.stringify(current) == JSON.stringify(metadata);
-        } else if (!current && metadata) {
-            return false;
-        }
-
-        return true;
-    }
-}
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the Microsoft Live Share SDK License.
+ */
+
+import EventEmitter from "events";
+import { IMediaPlayerState } from "../LiveMediaSessionCoordinator";
+import {
+    CoordinationWaitPoint,
+    ExtendedMediaMetadata,
+    ExtendedMediaSessionActionSource,
+} from "../MediaSessionExtensions";
+import { IGroupStateEvent } from "./interfaces";
+
+/**
+ * @hidden
+ */
+export interface IPlaybackTrack {
+    metadata: ExtendedMediaMetadata | null;
+    waitPoints: CoordinationWaitPoint[];
+    timestamp: number;
+    clientId: string;
+}
+
+/**
+ * @hidden
+ */
+export enum GroupPlaybackTrackEvents {
+    trackChange = "trackChange",
+}
+
+/**
+ * @hidden
+ */
+export interface IPlaybackTrackChangeEvent extends IGroupStateEvent {
+    metadata: ExtendedMediaMetadata | null;
+}
+
+/**
+ * @hidden
+ */
+export class GroupPlaybackTrack extends EventEmitter {
+    private readonly _getMediaPlayerState: () => IMediaPlayerState;
+    private _current: IPlaybackTrack;
+
+    constructor(getMediaPlayerState: () => IMediaPlayerState) {
+        super();
+        this._current = {
+            metadata: null,
+            waitPoints: [],
+            timestamp: 0,
+            clientId: "",
+        };
+        this._getMediaPlayerState = getMediaPlayerState;
+    }
+
+    public get current(): Readonly<IPlaybackTrack> {
+        // Populate with sessions current metadata if null
+        if (!this._current.metadata) {
+            this._current.metadata = this._getMediaPlayerState().metadata;
+        }
+
+        return this._current;
+    }
+
+    public get metadata(): ExtendedMediaMetadata | null {
+        return this.current.metadata;
+    }
+
+    public addWaitPoint(waitPoint: CoordinationWaitPoint): boolean {
+        for (let i = 0; i < this._current.waitPoints.length; i++) {
+            const current = this._current.waitPoints[i];
+            if (current.position == waitPoint.position) {
+                // Already exists
+                return false;
+            } else if (current.position > waitPoint.position) {
+                // Insert before current position
+                this._current.waitPoints.splice(i, 0, waitPoint);
+                return true;
+            }
+        }
+
+        // Append to list
+        this._current.waitPoints.push(waitPoint);
+        return true;
+    }
+
+    public findNextWaitPoint(
+        lastWaitPoint: CoordinationWaitPoint | undefined
+    ): CoordinationWaitPoint | undefined {
+        const waitPoints = this._current.waitPoints || [];
+        for (const waitPoint of waitPoints) {
+            if (lastWaitPoint && waitPoint.position <= lastWaitPoint.position) {
+                continue;
+            }
+
+            return waitPoint;
+        }
+
+        return undefined;
+    }
+
+    public updateTrack(
+        track: IPlaybackTrack,
+        source: ExtendedMediaSessionActionSource
+    ): boolean {
+        // Guard against missing waitPoints collection
+        if (!Array.isArray(track.waitPoints)) {
+            track.waitPoints = [];
+        }
+
+        // Is this the same track?
+        const current = this.current;
+        if (
+            GroupPlaybackTrack.compareMetadata(
+                this.current.metadata,
+                track.metadata
+            )
+        ) {
+            // Add any dynamic wait points.
+            track.waitPoints.forEach((waitPoint) => {
+                this.addWaitPoint(waitPoint);
+            });
+
+            // Ignore if same playback state
+            if (
+                track.timestamp == current.timestamp &&
+                track.clientId == current.clientId
+            ) {
+                return false;
+            }
+        }
+
+        // Ignore state changes that are older
+        if (track.timestamp < current.timestamp) {
+            return false;
+        }
+
+        // Ignore state changes that are from a clientId that sorts higher then the current one.
+        // - current.clientId should not be empty if current.timestamp != 0
+        if (
+            track.timestamp == current.timestamp &&
+            track.clientId.localeCompare(current.clientId) > 0
+        ) {
+            return false;
+        }
+
+        // Update current track
+        this._current = track;
+
+        // Notify listeners
+        const event: IPlaybackTrackChangeEvent = {
+            name: GroupPlaybackTrackEvents.trackChange,
+            clientId: track.clientId,
+            metadata: track.metadata,
+            source,
+        };
+        this.emit(GroupPlaybackTrackEvents.trackChange, event);
+
+        return true;
+    }
+
+    public compare(metadata: ExtendedMediaMetadata | null): boolean {
+        return GroupPlaybackTrack.compareMetadata(
+            this.current.metadata,
+            metadata
+        );
+    }
+
+    public static compareMetadata(
+        current: ExtendedMediaMetadata | null,
+        metadata: ExtendedMediaMetadata | null
+    ): boolean {
+        // Only compare when we have two metadata instances
+        if (current && metadata) {
+            return JSON.stringify(current) == JSON.stringify(metadata);
+        } else if (!current && metadata) {
+            return false;
+        }
+
+        return true;
+    }
+}

package/src/internals/GroupPlaybackTrackData.ts

@@ -1,104 +1,105 @@
-/**
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the Microsoft Live Share SDK License.
- */
-
-import { ILiveEvent } from "@microsoft/live-share";
-import EventEmitter from "events";
-import {
-    GroupPlaybackTrack,
-    GroupPlaybackTrackEvents,
-} from "./GroupPlaybackTrack";
-import { ExtendedMediaSessionActionSource } from "../MediaSessionExtensions";
-
-/**
- * @hidden
- */
-export interface IPlaybackTrackData {
-    data: object | null;
-    timestamp: number;
-    clientId: string;
-}
-
-/**
- * @hidden
- */
-export enum PlaybackTrackDataEvents {
-    dataChange = "dataChange",
-}
-
-/**
- * @hidden
- */
-export interface IPlaybackTrackDataChangeEvent extends ILiveEvent {
-    data: object | null;
-}
-
-/**
- * @hidden
- */
-export class GroupPlaybackTrackData extends EventEmitter {
-    private _track: GroupPlaybackTrack;
-    private _current: IPlaybackTrackData;
-
-    constructor(track: GroupPlaybackTrack) {
-        super();
-        this._track = track;
-        this._current = { data: null, timestamp: 0, clientId: "" };
-
-        // Listen for track changes
-        this._track.on(GroupPlaybackTrackEvents.trackChange, () => {
-            // Track changed so reset state to empty object
-            this._current = {
-                data: null,
-                timestamp: this._track.current.timestamp,
-                clientId: this._track.current.clientId,
-            };
-        });
-    }
-
-    public get current(): Readonly<IPlaybackTrackData> {
-        return this._current;
-    }
-
-    public get data(): object | null {
-        return this.current.data;
-    }
-
-    public updateData(
-        event: IPlaybackTrackData,
-        source: ExtendedMediaSessionActionSource
-    ): boolean {
-        // Ignore state changes that are older
-        const current = this.current;
-        if (event.timestamp < current.timestamp) {
-            return false;
-        }
-
-        // Ignore state changes that have the same timestamp and the clientId sorts higher.
-        if (
-            event.timestamp == current.timestamp &&
-            event.clientId.localeCompare(current.clientId) > 0
-        ) {
-            return false;
-        }
-
-        // Ignore state changes for same data object
-        if (JSON.stringify(current.data) == JSON.stringify(event.data)) {
-            return false;
-        }
-
-        // Update current data
-        this._current = event;
-
-        // Notify listeners
-        this.emit(PlaybackTrackDataEvents.dataChange, {
-            type: PlaybackTrackDataEvents.dataChange,
-            clientId: event.clientId,
-            data: event.data,
-            source,
-        });
-
-        return true;
-    }
-}
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the Microsoft Live Share SDK License.
+ */
+
+import EventEmitter from "events";
+import {
+    GroupPlaybackTrack,
+    GroupPlaybackTrackEvents,
+} from "./GroupPlaybackTrack";
+import { ExtendedMediaSessionActionSource } from "../MediaSessionExtensions";
+import { IGroupStateEvent } from "./interfaces";
+
+/**
+ * @hidden
+ */
+export interface IPlaybackTrackData {
+    data: object | null;
+    timestamp: number;
+    clientId: string;
+}
+
+/**
+ * @hidden
+ */
+export enum PlaybackTrackDataEvents {
+    dataChange = "dataChange",
+}
+
+/**
+ * @hidden
+ */
+export interface IPlaybackTrackDataChangeEvent extends IGroupStateEvent {
+    data: object | null;
+}
+
+/**
+ * @hidden
+ */
+export class GroupPlaybackTrackData extends EventEmitter {
+    private _track: GroupPlaybackTrack;
+    private _current: IPlaybackTrackData;
+
+    constructor(track: GroupPlaybackTrack) {
+        super();
+        this._track = track;
+        this._current = { data: null, timestamp: 0, clientId: "" };
+
+        // Listen for track changes
+        this._track.on(GroupPlaybackTrackEvents.trackChange, () => {
+            // Track changed so reset state to empty object
+            this._current = {
+                data: null,
+                timestamp: this._track.current.timestamp,
+                clientId: this._track.current.clientId,
+            };
+        });
+    }
+
+    public get current(): Readonly<IPlaybackTrackData> {
+        return this._current;
+    }
+
+    public get data(): object | null {
+        return this.current.data;
+    }
+
+    public updateData(
+        trackData: IPlaybackTrackData,
+        source: ExtendedMediaSessionActionSource
+    ): boolean {
+        // Ignore state changes that are older
+        const current = this.current;
+        if (trackData.timestamp < current.timestamp) {
+            return false;
+        }
+
+        // Ignore state changes that have the same timestamp and the clientId sorts higher.
+        if (
+            trackData.timestamp == current.timestamp &&
+            trackData.clientId.localeCompare(current.clientId) > 0
+        ) {
+            return false;
+        }
+
+        // Ignore state changes for same data object
+        if (JSON.stringify(current.data) == JSON.stringify(trackData.data)) {
+            return false;
+        }
+
+        // Update current data
+        this._current = trackData;
+
+        // Notify listeners
+        const event: IPlaybackTrackDataChangeEvent = {
+            name: PlaybackTrackDataEvents.dataChange,
+            clientId: trackData.clientId,
+            data: trackData.data,
+            source,
+        };
+        this.emit(PlaybackTrackDataEvents.dataChange, event);
+
+        return true;
+    }
+}