@microsoft/live-share-media 0.5.1 → 1.0.0-preview.3

package/src/internals/GroupPlaybackTrack.ts

@@ -1,147 +1,176 @@
-/**
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the Microsoft Live Share SDK License.
- */
-
-import { IEvent } from '@microsoft/live-share';
-import EventEmitter from 'events';
-import { IMediaPlayerState } from '../EphemeralMediaSessionCoordinator';
-import { CoordinationWaitPoint, ExtendedMediaMetadata } 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 IEvent {
-    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): 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, metadata: track.metadata });
-
-        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 { IEvent } from "@microsoft/live-share";
+import EventEmitter from "events";
+import { IMediaPlayerState } from "../LiveMediaSessionCoordinator";
+import {
+    CoordinationWaitPoint,
+    ExtendedMediaMetadata,
+} 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 IEvent {
+    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): 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,
+            metadata: track.metadata,
+        });
+
+        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,90 +1,98 @@
-/**
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the Microsoft Live Share SDK License.
- */
-
-import { IEvent } from '@microsoft/live-share';
-import EventEmitter from 'events';
-import { GroupPlaybackTrack, GroupPlaybackTrackEvents } from './GroupPlaybackTrack';
-
-
-/**
- * @hidden
- */
- export interface IPlaybackTrackData {
-    data: object|null;
-    timestamp: number;
-    clientId: string;
-}
-
-/**
- * @hidden
- */
- export enum PlaybackTrackDataEvents {
-    dataChange = 'dataChange'
-}
-
-/**
- * @hidden
- */
-export interface IPlaybackTrackDataChangeEvent extends IEvent {
-    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): 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, data: event.data });
-
-        return true;
-    }
-}
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the Microsoft Live Share SDK License.
+ */
+
+import { IEvent } from "@microsoft/live-share";
+import EventEmitter from "events";
+import {
+    GroupPlaybackTrack,
+    GroupPlaybackTrackEvents,
+} from "./GroupPlaybackTrack";
+
+/**
+ * @hidden
+ */
+export interface IPlaybackTrackData {
+    data: object | null;
+    timestamp: number;
+    clientId: string;
+}
+
+/**
+ * @hidden
+ */
+export enum PlaybackTrackDataEvents {
+    dataChange = "dataChange",
+}
+
+/**
+ * @hidden
+ */
+export interface IPlaybackTrackDataChangeEvent extends IEvent {
+    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): 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,
+            data: event.data,
+        });
+
+        return true;
+    }
+}