@microsoft/live-share-media 1.0.0-preview.1 → 1.0.0-preview.4

package/src/internals/GroupPlaybackPosition.ts

@@ -3,10 +3,17 @@
  * Licensed under the Microsoft Live Share SDK License.
  */
 
-import { LiveEvent, IRuntimeSignaler, TimeInterval } from '@microsoft/live-share';
-import { GroupTransportState } from './GroupTransportState';
-import { GroupPlaybackTrackEvents } from './GroupPlaybackTrack';
-import { CoordinationWaitPoint, ExtendedMediaSessionPlaybackState } from '../MediaSessionExtensions';
+import {
+    LiveEvent,
+    IRuntimeSignaler,
+    TimeInterval,
+} from "@microsoft/live-share";
+import { GroupTransportState } from "./GroupTransportState";
+import { GroupPlaybackTrackEvents } from "./GroupPlaybackTrack";
+import {
+    CoordinationWaitPoint,
+    ExtendedMediaSessionPlaybackState,
+} from "../MediaSessionExtensions";
 
 /**
  *Per client position
@@ -14,7 +21,7 @@ import { CoordinationWaitPoint, ExtendedMediaSessionPlaybackState } from '../Med
  */
 export interface ICurrentPlaybackPosition {
     playbackState: ExtendedMediaSessionPlaybackState;
-    waitPoint?: CoordinationWaitPoint
+    waitPoint?: CoordinationWaitPoint;
     position: number;
     duration?: number;
     timestamp: number;
@@ -30,25 +37,31 @@ export class GroupPlaybackPosition {
     private _updateInterval: TimeInterval;
     private _positions: Map<string, ICurrentPlaybackPosition>;
 
-
-    constructor(transportState: GroupTransportState, runtime: IRuntimeSignaler, updateInterval: TimeInterval) {
+    constructor(
+        transportState: GroupTransportState,
+        runtime: IRuntimeSignaler,
+        updateInterval: TimeInterval
+    ) {
         this._transportState = transportState;
         this._runtime = runtime;
         this._updateInterval = updateInterval;
         this._positions = new Map();
 
         // Listen for track change
-        this._transportState.track.on(GroupPlaybackTrackEvents.trackChange, _ => {
-            // Reset position tracking and duration
-            this._positions = new Map();
-            this.mediaDuration = undefined;
-        });
+        this._transportState.track.on(
+            GroupPlaybackTrackEvents.trackChange,
+            (_) => {
+                // Reset position tracking and duration
+                this._positions = new Map();
+                this.mediaDuration = undefined;
+            }
+        );
     }
 
     /**
      * Returns the latest position info for the local client.
      */
-    public get localPosition(): ICurrentPlaybackPosition|undefined {
+    public get localPosition(): ICurrentPlaybackPosition | undefined {
         return this._positions.get(this._runtime.clientId!);
     }
 
@@ -57,7 +70,7 @@ export class GroupPlaybackPosition {
      */
     public get totalClients(): number {
         let cnt = 0;
-        this.forEach(_ => cnt++);
+        this.forEach((_) => cnt++);
         return cnt;
     }
 
@@ -69,8 +82,8 @@ export class GroupPlaybackPosition {
         let playing = 0;
         this.forEach((position, projectedPosition) => {
             switch (position.playbackState) {
-                case 'none':
-                case 'ended':
+                case "none":
+                case "ended":
                     // not playing.
                     break;
                 default:
@@ -88,9 +101,16 @@ export class GroupPlaybackPosition {
     public get clientsWaiting(): number {
         let cnt = 0;
         const waitPoint = this.localPosition?.waitPoint;
-        if (waitPoint && (waitPoint.maxClients == undefined || this.totalClients <= waitPoint.maxClients)) {
+        if (
+            waitPoint &&
+            (waitPoint.maxClients == undefined ||
+                this.totalClients <= waitPoint.maxClients)
+        ) {
             this.forEach((position, projectedPosition) => {
-                if (position.playbackState == 'suspended' && position.waitPoint) {
+                if (
+                    position.playbackState == "suspended" &&
+                    position.waitPoint
+                ) {
                     cnt++;
                 } else if (position.position < waitPoint.position) {
                     cnt++;
@@ -108,9 +128,11 @@ export class GroupPlaybackPosition {
      * This is called when calculating the current seekTo position.
      */
     public get maxPosition(): number {
-        if (this._transportState.playbackState == 'playing') {
+        if (this._transportState.playbackState == "playing") {
             const now = LiveEvent.getTimestamp();
-            const projected = this._transportState.startPosition + ((now - this._transportState.timestamp) / 1000);
+            const projected =
+                this._transportState.startPosition +
+                (now - this._transportState.timestamp) / 1000;
             return this.limitProjectedPosition(projected);
         } else {
             return this._transportState.startPosition;
@@ -123,21 +145,25 @@ export class GroupPlaybackPosition {
     public mediaDuration?: number;
 
     public get targetPosition(): number {
-        if (this._transportState.playbackState == 'playing') {
+        if (this._transportState.playbackState == "playing") {
             return this.getMostProgressedPosition();
         } else {
             return this._transportState.startPosition;
         }
     }
 
-
     /**
      * Enumerates every reported playback position.
      * @param callbackFn Function applied to each position,
      */
-     public forEach(callbackFn: (position: ICurrentPlaybackPosition, projectedPosition: number) => void): void {
+    public forEach(
+        callbackFn: (
+            position: ICurrentPlaybackPosition,
+            projectedPosition: number
+        ) => void
+    ): void {
         const now = LiveEvent.getTimestamp();
-        const ignoreBefore = now - (this._updateInterval.milliseconds * 2);
+        const ignoreBefore = now - this._updateInterval.milliseconds * 2;
         const shouldProject = !this._transportState.track.metadata?.liveStream;
         this._positions.forEach((value, key) => {
             const position = this._positions.get(key)!;
@@ -146,7 +172,10 @@ export class GroupPlaybackPosition {
             if (position.timestamp > ignoreBefore) {
                 // Compute projected playback position
                 // - This computation does not take into account future wait points.
-                const projected = position.playbackState == 'playing' && shouldProject ?  position.position + ((now - position.timestamp) / 1000) : position.position;
+                const projected =
+                    position.playbackState == "playing" && shouldProject
+                        ? position.position + (now - position.timestamp) / 1000
+                        : position.position;
                 callbackFn(position, this.limitProjectedPosition(projected));
             }
         });
@@ -179,7 +208,10 @@ export class GroupPlaybackPosition {
         // Compute max progress
         let progress = -1;
         this.forEach((position, projectedPosition) => {
-            if (projectedPosition <= maxPosition && projectedPosition > progress) {
+            if (
+                projectedPosition <= maxPosition &&
+                projectedPosition > progress
+            ) {
                 progress = projectedPosition;
             }
         });
@@ -188,6 +220,8 @@ export class GroupPlaybackPosition {
     }
 
     private limitProjectedPosition(position: number): number {
-        return this.mediaDuration != undefined ? Math.min(position, this.mediaDuration) : position;
+        return this.mediaDuration != undefined
+            ? Math.min(position, this.mediaDuration)
+            : position;
     }
 }

package/src/internals/GroupPlaybackTrack.ts

@@ -3,46 +3,53 @@
  * 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';
+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;
+export interface IPlaybackTrack {
+    metadata: ExtendedMediaMetadata | null;
     waitPoints: CoordinationWaitPoint[];
     timestamp: number;
     clientId: string;
 }
 
-
 /**
  * @hidden
  */
- export enum GroupPlaybackTrackEvents {
-    trackChange = 'trackChange'
+export enum GroupPlaybackTrackEvents {
+    trackChange = "trackChange",
 }
 
 /**
  * @hidden
  */
- export interface IPlaybackTrackChangeEvent extends IEvent {
-    metadata: ExtendedMediaMetadata|null;
+export interface IPlaybackTrackChangeEvent extends IEvent {
+    metadata: ExtendedMediaMetadata | null;
 }
 
 /**
  * @hidden
  */
- export class GroupPlaybackTrack extends EventEmitter {
+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._current = {
+            metadata: null,
+            waitPoints: [],
+            timestamp: 0,
+            clientId: "",
+        };
         this._getMediaPlayerState = getMediaPlayerState;
     }
 
@@ -55,7 +62,7 @@ import { CoordinationWaitPoint, ExtendedMediaMetadata } from '../MediaSessionExt
         return this._current;
     }
 
-    public get metadata(): ExtendedMediaMetadata|null {
+    public get metadata(): ExtendedMediaMetadata | null {
         return this.current.metadata;
     }
 
@@ -77,7 +84,9 @@ import { CoordinationWaitPoint, ExtendedMediaMetadata } from '../MediaSessionExt
         return true;
     }
 
-    public findNextWaitPoint(lastWaitPoint: CoordinationWaitPoint|undefined): CoordinationWaitPoint|undefined {
+    public findNextWaitPoint(
+        lastWaitPoint: CoordinationWaitPoint | undefined
+    ): CoordinationWaitPoint | undefined {
         const waitPoints = this._current.waitPoints || [];
         for (const waitPoint of waitPoints) {
             if (lastWaitPoint && waitPoint.position <= lastWaitPoint.position) {
@@ -98,14 +107,22 @@ import { CoordinationWaitPoint, ExtendedMediaMetadata } from '../MediaSessionExt
 
         // Is this the same track?
         const current = this.current;
-        if (GroupPlaybackTrack.compareMetadata(this.current.metadata, track.metadata)) {
+        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) {
+            if (
+                track.timestamp == current.timestamp &&
+                track.clientId == current.clientId
+            ) {
                 return false;
             }
         }
@@ -117,7 +134,10 @@ import { CoordinationWaitPoint, ExtendedMediaMetadata } from '../MediaSessionExt
 
         // 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) {
+        if (
+            track.timestamp == current.timestamp &&
+            track.clientId.localeCompare(current.clientId) > 0
+        ) {
             return false;
         }
 
@@ -125,16 +145,25 @@ import { CoordinationWaitPoint, ExtendedMediaMetadata } from '../MediaSessionExt
         this._current = track;
 
         // Notify listeners
-        this.emit(GroupPlaybackTrackEvents.trackChange, { name: GroupPlaybackTrackEvents.trackChange, metadata: track.metadata });
+        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 compare(metadata: ExtendedMediaMetadata | null): boolean {
+        return GroupPlaybackTrack.compareMetadata(
+            this.current.metadata,
+            metadata
+        );
     }
 
-    public static compareMetadata(current: ExtendedMediaMetadata|null, metadata: ExtendedMediaMetadata|null): boolean {
+    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);

package/src/internals/GroupPlaybackTrackData.ts

@@ -3,16 +3,18 @@
  * Licensed under the Microsoft Live Share SDK License.
  */
 
-import { IEvent } from '@microsoft/live-share';
-import EventEmitter from 'events';
-import { GroupPlaybackTrack, GroupPlaybackTrackEvents } from './GroupPlaybackTrack';
-
+import { IEvent } from "@microsoft/live-share";
+import EventEmitter from "events";
+import {
+    GroupPlaybackTrack,
+    GroupPlaybackTrackEvents,
+} from "./GroupPlaybackTrack";
 
 /**
  * @hidden
  */
- export interface IPlaybackTrackData {
-    data: object|null;
+export interface IPlaybackTrackData {
+    data: object | null;
     timestamp: number;
     clientId: string;
 }
@@ -20,28 +22,28 @@ import { GroupPlaybackTrack, GroupPlaybackTrackEvents } from './GroupPlaybackTra
 /**
  * @hidden
  */
- export enum PlaybackTrackDataEvents {
-    dataChange = 'dataChange'
+export enum PlaybackTrackDataEvents {
+    dataChange = "dataChange",
 }
 
 /**
  * @hidden
  */
 export interface IPlaybackTrackDataChangeEvent extends IEvent {
-    data: object|null;
+    data: object | null;
 }
 
 /**
  * @hidden
  */
- export class GroupPlaybackTrackData extends EventEmitter {
+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: '' };
+        this._current = { data: null, timestamp: 0, clientId: "" };
 
         // Listen for track changes
         this._track.on(GroupPlaybackTrackEvents.trackChange, () => {
@@ -49,8 +51,8 @@ export interface IPlaybackTrackDataChangeEvent extends IEvent {
             this._current = {
                 data: null,
                 timestamp: this._track.current.timestamp,
-                clientId: this._track.current.clientId
-            }
+                clientId: this._track.current.clientId,
+            };
         });
     }
 
@@ -58,7 +60,7 @@ export interface IPlaybackTrackDataChangeEvent extends IEvent {
         return this._current;
     }
 
-    public get data(): object|null {
+    public get data(): object | null {
         return this.current.data;
     }
 
@@ -70,7 +72,10 @@ export interface IPlaybackTrackDataChangeEvent extends IEvent {
         }
 
         // Ignore state changes that have the same timestamp and the clientId sorts higher.
-        if (event.timestamp == current.timestamp && event.clientId.localeCompare(current.clientId) > 0) {
+        if (
+            event.timestamp == current.timestamp &&
+            event.clientId.localeCompare(current.clientId) > 0
+        ) {
             return false;
         }
 
@@ -83,7 +88,10 @@ export interface IPlaybackTrackDataChangeEvent extends IEvent {
         this._current = event;
 
         // Notify listeners
-        this.emit(PlaybackTrackDataEvents.dataChange, { type: PlaybackTrackDataEvents.dataChange, data: event.data });
+        this.emit(PlaybackTrackDataEvents.dataChange, {
+            type: PlaybackTrackDataEvents.dataChange,
+            data: event.data,
+        });
 
         return true;
     }

package/src/internals/GroupTransportState.ts

@@ -3,17 +3,22 @@
  * Licensed under the Microsoft Live Share SDK License.
  */
 
-import { IEvent, LiveEvent } from '@microsoft/live-share';
-import EventEmitter from 'events';
-import { IMediaPlayerState } from '../LiveMediaSessionCoordinator';
-import { ExtendedMediaSessionPlaybackState, ExtendedMediaSessionAction } from '../MediaSessionExtensions';
-import { GroupPlaybackTrack, GroupPlaybackTrackEvents } from './GroupPlaybackTrack';
-
+import { IEvent, LiveEvent } from "@microsoft/live-share";
+import EventEmitter from "events";
+import { IMediaPlayerState } from "../LiveMediaSessionCoordinator";
+import {
+    ExtendedMediaSessionPlaybackState,
+    ExtendedMediaSessionAction,
+} from "../MediaSessionExtensions";
+import {
+    GroupPlaybackTrack,
+    GroupPlaybackTrackEvents,
+} from "./GroupPlaybackTrack";
 
 /**
  * @hidden
  */
- export interface ITransportState {
+export interface ITransportState {
     playbackState: ExtendedMediaSessionPlaybackState;
     startPosition: number;
     timestamp: number;
@@ -24,7 +29,7 @@ import { GroupPlaybackTrack, GroupPlaybackTrackEvents } from './GroupPlaybackTra
  * @hidden
  */
 export enum GroupTransportStateEvents {
-    transportStateChange = 'transportStateChange'
+    transportStateChange = "transportStateChange",
 }
 
 /**
@@ -38,31 +43,34 @@ export interface ITransportStateChangeEvent extends IEvent {
 /**
  * @hidden
  */
- export class GroupTransportState extends EventEmitter {
+export class GroupTransportState extends EventEmitter {
     private readonly _getMediaPlayerState: () => IMediaPlayerState;
     private _track: GroupPlaybackTrack;
     private _current: ITransportState;
 
-    constructor(track: GroupPlaybackTrack, getMediaPlayerState: () => IMediaPlayerState) {
+    constructor(
+        track: GroupPlaybackTrack,
+        getMediaPlayerState: () => IMediaPlayerState
+    ) {
         super();
         this._getMediaPlayerState = getMediaPlayerState;
         this._track = track;
         this._current = {
-            playbackState: 'none',
+            playbackState: "none",
             startPosition: 0.0,
             timestamp: 0,
-            clientId: ''
+            clientId: "",
         };
 
         // Listen for track changes
         this._track.on(GroupPlaybackTrackEvents.trackChange, () => {
             // Track changed so reset state to stopped ad position 0.0
             this._current = {
-                playbackState: 'none',
+                playbackState: "none",
                 startPosition: 0.0,
                 timestamp: this._track.current.timestamp,
-                clientId: this._track.current.clientId
-            }
+                clientId: this._track.current.clientId,
+            };
         });
     }
 
@@ -87,7 +95,10 @@ export interface ITransportStateChangeEvent extends IEvent {
     }
 
     public compare(state: ITransportState): boolean {
-        return this.current.playbackState == state.playbackState && this.current.startPosition == state.startPosition;
+        return (
+            this.current.playbackState == state.playbackState &&
+            this.current.startPosition == state.startPosition
+        );
     }
 
     public updateState(state: ITransportState): boolean {
@@ -103,7 +114,10 @@ export interface ITransportStateChangeEvent extends IEvent {
         }
 
         // Ignore state changes that have the same timestamp and the clientId sorts higher.
-        if (state.timestamp == originalState.timestamp && state.clientId.localeCompare(originalState.clientId) > 0) {
+        if (
+            state.timestamp == originalState.timestamp &&
+            state.clientId.localeCompare(originalState.clientId) > 0
+        ) {
             return false;
         }
 
@@ -112,14 +126,30 @@ export interface ITransportStateChangeEvent extends IEvent {
 
         // Trigger transport change
         const playerState = this._getMediaPlayerState().playbackState;
-        if (originalState.playbackState == state.playbackState && playerState != 'ended') {
-            this.emit(GroupTransportStateEvents.transportStateChange, { type: GroupTransportStateEvents.transportStateChange, action: 'seekto', seekTime: state.startPosition });
-        } else if (state.playbackState == 'playing') {
+        if (
+            originalState.playbackState == state.playbackState &&
+            playerState != "ended"
+        ) {
+            this.emit(GroupTransportStateEvents.transportStateChange, {
+                type: GroupTransportStateEvents.transportStateChange,
+                action: "seekto",
+                seekTime: state.startPosition,
+            });
+        } else if (state.playbackState == "playing") {
             const now = LiveEvent.getTimestamp();
-            const projectedPosition = state.startPosition + ((now - state.timestamp) / 1000);
-            this.emit(GroupTransportStateEvents.transportStateChange, { type: GroupTransportStateEvents.transportStateChange, action: 'play', seekTime: projectedPosition});
+            const projectedPosition =
+                state.startPosition + (now - state.timestamp) / 1000;
+            this.emit(GroupTransportStateEvents.transportStateChange, {
+                type: GroupTransportStateEvents.transportStateChange,
+                action: "play",
+                seekTime: projectedPosition,
+            });
         } else {
-            this.emit(GroupTransportStateEvents.transportStateChange, { type: GroupTransportStateEvents.transportStateChange, action: 'pause', seekTime: state.startPosition});
+            this.emit(GroupTransportStateEvents.transportStateChange, {
+                type: GroupTransportStateEvents.transportStateChange,
+                action: "pause",
+                seekTime: state.startPosition,
+            });
         }
 
         return true;